Exemples de code pour la personnalisation des modèles

Créez d'abord un fichier texte nomméFineTuningData.json. Copiez le code JSON ci-dessous dans le fichier texte, en ${output-bucket} remplaçant ${training-bucket} et par 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 contenu FineTuningData.json dans un terminal et exécutez la commande suivante dans la ligne de commande, en la ${your-customization-role-arn} remplaçant par 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=.0001,learningRateWarmupSteps=0 \
    --cli-input-json file://FineTuningData.json
                

La réponse renvoie un jobArn. Prévoyez un certain temps pour la réalisation de la tâche. Vous pouvez vérifier son état à l’aide de la commande suivante.

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

Lorsque status a la valeur COMPLETE, vous pouvez voir les trainingMetrics dans la réponse. Vous pouvez télécharger les artefacts dans le dossier actuel en exécutant la commande suivante, en les aet.et-bucket remplaçant par le nom de votre compartiment de sortie et jobId par 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 du 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 un provisionedModelArn. Prévoyez un certain temps pour la création du débit provisionné. Pour vérifier son état, indiquez le nom ou l’ARN du modèle provisionné en tant que provisioned-model-id dans la commande suivante.

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

Lorsque status a la valeur InService, vous pouvez exécuter l’inférence avec votre modèle personnalisé à l’aide de la commande suivante. Vous devez fournir l’ARN du modèle provisionné en tant que model-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 isAWS?", "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 peaufinage. ${your-customization-role-arn}Remplacez-le par l'ARN du compartiment MyCustomizationRole que vous avez configuré ${training-bucket} et remplacé, ainsi que ${output-bucket} par 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": ".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')

La réponse renvoie un jobArn. Prévoyez un certain temps pour la réalisation de la tâche. 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 du 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 un provisionedModelArn. Prévoyez un certain temps pour la création du débit provisionné. Pour vérifier son état, indiquez le nom ou l’ARN du modèle provisionné en tant que provisionedModelId dans la commande suivante.

bedrock.get_provisioned_model_throughput(provisionedModelId=provisionedModelArn)

Lorsque status a la valeur InService, vous pouvez exécuter l’inférence avec votre modèle personnalisé à l’aide de la commande suivante. Vous devez fournir l’ARN du modèle provisionné en tant que 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 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()