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 ${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
                

In der Antwort wird ein jobArn zurückgegeben. Warten Sie, bis der Auftrag abgeschlossen ist. Sie können den Status mit dem folgenden Befehl überprüfen.

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

Wenn der status COMPLETE lautet, können Sie die 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 die ID des Anpassungsauftrags ersetzen (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 bereitgestellten Durchsatz für Ihr benutzerdefiniertes Modell.

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

In der Antwort wird ein provisionedModelArn zurückgegeben. Warten Sie, bis der bereitgestellte Durchsatz erstellt wurde. Zum Überprüfen des Status geben Sie den Namen oder den ARN des bereitgestellten Modells als provisioned-model-id im folgenden Befehl ein.

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

Wenn der status InService lautet, können Sie mit dem folgenden Befehl Inferenz für Ihr benutzerdefiniertes Modell ausführen. Sie müssen den ARN des bereitgestellten Modells als model-id angeben. 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 isAWS?", "textGenerationConfig": {"temperature": 0.5}}' \
    --cli-binary-format raw-in-base64-out \
    output.txt

Führen Sie den folgenden Codeausschnitt aus, um einen Feinabstimmungsauftrag zu übermitteln. ${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')

In der Antwort wird ein jobArn zurückgegeben. Warten Sie, bis der Auftrag abgeschlossen ist. Sie können den 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 Herunterladen von Objekten folgen, um die Metriken herunterzuladen.

Erwerben Sie mit dem folgenden Befehl einen unverbindlichen bereitgestellten Durchsatz für Ihr benutzerdefiniertes Modell.

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

provisionedModelArn = response_pt.get('provisionedModelArn')

In der Antwort wird ein provisionedModelArn zurückgegeben. Warten Sie, bis der bereitgestellte Durchsatz erstellt wurde. Zum Überprüfen des Status geben Sie den Namen oder den ARN des bereitgestellten Modells als provisionedModelId im folgenden Befehl ein.

bedrock.get_provisioned_model_throughput(provisionedModelId=provisionedModelArn)

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

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 isAWS?"
        })

        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()