Codebeispiele für die Modellanpassung

Erstellen Sie zunächst eine Textdatei mit dem NamenFineTuningData.json. Kopieren Sie den JSON-Code von unten in die Textdatei ${training-bucket} und ${output-bucket} ersetzen Sie ihn durch Ihre S3-Bucket-Namen.

{
    "trainingDataConfig": {
        "s3Uri": "s3://${training-bucket}/train.jsonl"
    },
    "outputDataConfig": {
        "s3Uri": "s3://${output-bucket}"
    }
}

Um einen Auftrag zur Modellanpassung einzureichen, navigieren Sie zu dem Ordner, der sich FineTuningData.json in einem Terminal befindet, und führen Sie den folgenden Befehl in der Befehlszeile aus. ${your-customization-role-arn} Ersetzen Sie ihn durch die Rolle für die Modellanpassung, die Sie eingerichtet haben.

aws bedrock create-model-customization-job \
    --customization-type FINE_TUNING \
    --base-model-identifier arn:aws:bedrock:us-east-1::foundation-model/amazon.titan-text-express-v1 \
    --role-arn ${your-customization-role-arn} \
    --job-name MyFineTuningJob \
    --custom-model-name MyCustomModel \
    --hyper-parameters epochCount=1,batchSize=1,learningRate=.0001,learningRateWarmupSteps=0 \
    --cli-input-json file://FineTuningData.json
                

Die Antwort gibt a zurückjobArn. Warten Sie, bis der Job abgeschlossen ist. Sie können seinen Status mit dem folgenden Befehl überprüfen.

aws bedrock get-model-customization-job \
    --job-identifier "jobArn"

Wenn ja statusCOMPLETE, können Sie das trainingMetrics in der Antwort sehen. Sie können die Artefakte in den aktuellen Ordner herunterladen, indem Sie den folgenden Befehl ausführen und ihn aet.et-bucket durch den Namen Ihres Ausgabe-Buckets und jobId durch die ID des Anpassungsjobs ersetzen (die Reihenfolge nach dem letzten Schrägstrich imjobArn).

aws s3 cp s3://${output-bucket}/model-customization-job-jobId . --recursive

Erwerben Sie mit dem folgenden Befehl einen unverbindlichen Provisioned Throughput für Ihr benutzerdefiniertes Modell.

aws bedrock create-provisioned-model-throughput \
    --model-id MyCustomModel \
    --provisioned-model-name MyProvisionedCustomModel \
    --model-units 1

Die Antwort gibt a zurückprovisionedModelArn. Warten Sie einige Zeit, bis der bereitgestellte Durchsatz erstellt wurde. Um den Status zu überprüfen, geben Sie den Namen oder den ARN des bereitgestellten Modells wie provisioned-model-id im folgenden Befehl ein.

aws bedrock get-provisioned-model-throughput \
    --provisioned-model-id ${provisioned-model-arn}

Wenn dies der status Fall istInService, können Sie mit dem folgenden Befehl Inferenz für Ihr benutzerdefiniertes Modell ausführen. Sie müssen den ARN des bereitgestellten Modells als angeben. model-id Die Ausgabe wird in eine Datei mit dem Namen output.txt in Ihrem aktuellen Ordner geschrieben.

aws bedrock-runtime invoke-model \
    --model-id ${provisioned-model-arn} \
    --body '{"inputText": "What is AWS?", "textGenerationConfig": {"temperature": 0.5}}' \
    --cli-binary-format raw-in-base64-out \
    output.txt

Führen Sie den folgenden Codeausschnitt aus, um einen Feinabstimmungsauftrag einzureichen. ${your-customization-role-arn}Ersetzen Sie es durch den ARN desMyCustomizationRole, den Sie eingerichtet und ersetzt haben, ${training-bucket} und ${output-bucket} durch Ihre S3-Bucket-Namen.

import boto3

bedrock = boto3.client(service_name='bedrock')
    
# Set parameters
customizationType = "FINE_TUNING"
baseModelIdentifier = "arn:aws:bedrock:us-east-1::foundation-model/amazon.titan-text-express-v1"
roleArn = "${your-customization-role-arn}"
jobName = "MyFineTuningJob"
customModelName = "MyCustomModel"
hyperParameters = {
        "epochCount": "1",
        "batchSize": "1",
        "learningRate": ".0001",
        "learningRateWarmupSteps": "0"
    }
trainingDataConfig = {"s3Uri": "s3://${training-bucket}/myInputData/train.jsonl"}
outputDataConfig = {"s3Uri": "s3://${output-bucket}/myOutputData"}

# Create job
response_ft = bedrock.create_model_customization_job(
    jobName=jobName, 
    customModelName=customModelName,
    roleArn=roleArn,
    baseModelIdentifier=baseModelIdentifier,
    hyperParameters=hyperParameters,
    trainingDataConfig=trainingDataConfig,
    outputDataConfig=outputDataConfig
)

jobArn = response_ft.get('jobArn')

Die Antwort gibt a zurückjobArn. Warten Sie, bis der Job abgeschlossen ist. Sie können seinen Status mit dem folgenden Befehl überprüfen.

bedrock.get_model_customization_job(jobIdentifier=jobArn).get('status')

Wenn ja statusCOMPLETE, können Sie das trainingMetrics in der GetModelCustomizationJobAntwort sehen. Sie können auch den Schritten unter Objekte herunterladen folgen, um die Metriken herunterzuladen.

Erwerben Sie mit dem folgenden Befehl einen unverbindlichen Provisioned Throughput für Ihr benutzerdefiniertes Modell.

response_pt = bedrock.create_provisioned_model_throughput(
    modelId="MyCustomModel",
    provisionedModelName="MyProvisionedCustomModel",
    modelUnits="1"
)

provisionedModelArn = response_pt.get('provisionedModelArn')

Die Antwort gibt a zurück. provisionedModelArn Warten Sie einige Zeit, bis der bereitgestellte Durchsatz erstellt wurde. Um den Status zu überprüfen, geben Sie den Namen oder den ARN des bereitgestellten Modells wie provisionedModelId im folgenden Befehl ein.

bedrock.get_provisioned_model_throughput(provisionedModelId=provisionedModelArn)

Wenn dies der status Fall istInService, können Sie mit dem folgenden Befehl Inferenz für Ihr benutzerdefiniertes Modell ausführen. Sie müssen den ARN des bereitgestellten Modells als angeben. modelId

import json
import logging
import boto3

from botocore.exceptions import ClientError


class ImageError(Exception):
    "Custom exception for errors returned by the model"

    def __init__(self, message):
        self.message = message


logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)


def generate_text(model_id, body):
    """
    Generate text using your provisioned custom model.
    Args:
        model_id (str): The model ID to use.
        body (str) : The request body to use.
    Returns:
        response (json): The response from the model.
    """

    logger.info(
        "Generating text with your provisioned custom model %s", model_id)

    brt = boto3.client(service_name='bedrock-runtime')

    accept = "application/json"
    content_type = "application/json"

    response = brt.invoke_model(
        body=body, modelId=model_id, accept=accept, contentType=content_type
    )
    response_body = json.loads(response.get("body").read())

    finish_reason = response_body.get("error")

    if finish_reason is not None:
        raise ImageError(f"Text generation error. Error is {finish_reason}")

    logger.info(
        "Successfully generated text with provisioned custom model %s", model_id)

    return response_body


def main():
    """
    Entrypoint for example.
    """
    try:
        logging.basicConfig(level=logging.INFO,
                            format="%(levelname)s: %(message)s")

        model_id = provisionedModelArn

        body = json.dumps({
            "inputText": "what is AWS?"
        })

        response_body = generate_text(model_id, body)
        print(f"Input token count: {response_body['inputTextTokenCount']}")

        for result in response_body['results']:
            print(f"Token count: {result['tokenCount']}")
            print(f"Output text: {result['outputText']}")
            print(f"Completion reason: {result['completionReason']}")

    except ClientError as err:
        message = err.response["Error"]["Message"]
        logger.error("A client error occurred: %s", message)
        print("A client error occured: " +
              format(message))
    except ImageError as err:
        logger.error(err.message)
        print(err.message)

    else:
        print(
            f"Finished generating text with your provisioned custom model {model_id}.")


if __name__ == "__main__":
    main()