Exemples de code pour la personnalisation des modèles

Créez d'abord un fichier texte nommé FineTuningData.json. Copiez le JSON code ci-dessous dans le fichier texte, en remplaçant ${training-bucket} and ${output-bucket} avec les noms de vos compartiments S3.

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

Pour soumettre une tâche de personnalisation du modèle, accédez au dossier contenant FineTuningData.json dans un terminal et exécutez la commande suivante dans la ligne de commande, en remplaçant ${your-customization-role-arn} avec le rôle de personnalisation du modèle que vous avez configuré.

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
                

La réponse renvoie un jobArn. Laissez le travail se terminer pendant un certain temps. Vous pouvez vérifier son état à l'aide de la commande suivante.

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

Quand status c'est le casCOMPLETE, vous pouvez le voir trainingMetrics dans la réponse. Vous pouvez télécharger les artefacts dans le dossier actuel en exécutant la commande suivante, en remplaçant aet.et-bucket avec le nom de votre bucket de sortie et jobId avec l'ID de la tâche de personnalisation (la séquence suivant la dernière barre oblique dujobArn).

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

Achetez un débit provisionné sans engagement pour votre modèle personnalisé à l'aide de la commande suivante.

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

La réponse renvoie unprovisionedModelArn. Laissez le débit provisionné être créé pendant un certain temps. Pour vérifier son état, indiquez le nom ou ARN le modèle provisionné comme indiqué provisioned-model-id dans la commande suivante.

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

Lorsque status c'est le casInService, vous pouvez exécuter l'inférence avec votre modèle personnalisé à l'aide de la commande suivante. Vous devez fournir le ARN modèle provisionné en tant quemodel-id. La sortie est écrite dans un fichier nommé output.txt dans votre dossier actuel.

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

Exécutez l'extrait de code suivant pour soumettre une tâche de réglage précis. Remplacez ${your-customization-role-arn} avec ARN le MyCustomizationRole que vous configurez et remplacez ${training-bucket} and ${output-bucket} avec les noms de vos compartiments S3.

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

La réponse renvoie un jobArn. Laissez le travail se terminer pendant un certain temps. Vous pouvez vérifier son état à l'aide de la commande suivante.

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

Quand status c'est le casCOMPLETE, vous pouvez le voir trainingMetrics dans la GetModelCustomizationJobréponse. Vous pouvez également suivre les étapes de la section Téléchargement d'objets pour télécharger les métriques.

Achetez un débit provisionné sans engagement pour votre modèle personnalisé à l'aide de la commande suivante.

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

provisionedModelArn = response_pt.get('provisionedModelArn')

La réponse renvoie unprovisionedModelArn. Laissez le débit provisionné être créé pendant un certain temps. Pour vérifier son état, indiquez le nom ou ARN le modèle provisionné comme indiqué provisionedModelId dans la commande suivante.

bedrock.get_provisioned_model_throughput(provisionedModelId=provisionedModelArn)

Lorsque status c'est le casInService, vous pouvez exécuter l'inférence avec votre modèle personnalisé à l'aide de la commande suivante. Vous devez fournir le ARN modèle provisionné en tant quemodelId.

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