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 unjobArn. Laissez le temps de terminer le travail. 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 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 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 l'ARN du 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 l'ARN du modèle provisionné sous la model-id forme. 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. ${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 unjobArn. Laissez le temps de terminer le travail. 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 l'ARN du 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 l'ARN du modèle provisionné sous la modelId forme.

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