Codebeispiele für die Modellanpassung

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

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

Um einen Job zur Modellanpassung einzureichen, navigieren Sie zu dem Ordner mit FineTuningData.json in einem Terminal und führen Sie den folgenden Befehl in der Befehlszeile aus, wobei Sie Folgendes ersetzen ${your-customization-role-arn} mit der 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=.0005,learningRateWarmupSteps=0 \
    --cli-input-json file://FineTuningData.json
                

Die Antwort gibt a zurück jobArn. 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 dabei Folgendes ersetzen aet.et-bucket mit dem Namen Ihres Ausgabe-Buckets und jobId mit der ID des Anpassungsjobs (die Reihenfolge nach dem letzten Schrägstrich injobArn).

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 Namen 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 eine Inferenz für Ihr benutzerdefiniertes Modell ausführen. Sie müssen das ARN des bereitgestellten Modells als angeben. model-id Die Ausgabe wird in eine Datei mit dem Namen geschrieben output.txt in Ihrem aktuellen Ordner.

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. Ersetzen ${your-customization-role-arn} mit dem von ARN MyCustomizationRole die du einrichtest und ersetzst ${training-bucket} and ${output-bucket} mit Ihren 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": ".0005",
        "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ück jobArn. 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 dies der status Fall istCOMPLETE, 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 Namen 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 eine Inferenz für Ihr benutzerdefiniertes Modell ausführen. Sie müssen das 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()