Exemples de code pour la personnalisation des modèles

Les exemples de code suivants montrent comment préparer un jeu de données de base, configurer des autorisations, créer un modèle personnalisé, afficher les fichiers de sortie, acheter du débit pour le modèle et exécuter une inférence sur le modèle. Vous pouvez modifier ces extraits de code en fonction de votre cas d'utilisation spécifique.

Préparez le jeu de données d'entraînement.
1. Créez un fichier d'ensemble de données d'entraînement contenant la ligne suivante et nommez-le train.jsonl.
```
{"prompt": "what is AWS", "completion": "it's Amazon Web Services"}
```
2. Créez un compartiment S3 pour vos données d'entraînement et un autre pour vos données de sortie (les noms doivent être uniques).
3. Téléchargez train.jsonl dans le compartiment de données d'entraînement.

Créez une politique pour accéder à votre formation et associez-la à un rôle IAM bénéficiant d'une relation de confiance avec Amazon Bedrock. Sélectionnez l'onglet correspondant à la méthode de votre choix et suivez les étapes.

Console

Créez la politique S3.

Accédez à la console IAM à l'adresse https://console.aws.amazon.com/iam et choisissez Policies dans le volet de navigation de gauche.
Sélectionnez Créer une politique, puis choisissez JSON pour ouvrir l'éditeur de stratégie.

Collez la politique suivante en remplaçant $ {training-bucket} et $ {output-bucket} par les noms de vos compartiments, puis sélectionnez Next.


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::${training-bucket}",
                "arn:aws:s3:::${training-bucket}/*"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:PutObject",
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::${output-bucket}",
                "arn:aws:s3:::${output-bucket}/*"
            ]
        }
    ]
}

Donnez un nom à la politique MyFineTuningDataAccesset sélectionnez Créer une politique.

Créez un rôle IAM et associez la politique.
1. Dans le volet de navigation de gauche, choisissez Rôles, puis sélectionnez Créer un rôle.
2. Sélectionnez Politique de confiance personnalisée, collez la politique suivante, puis sélectionnez Suivant.
```
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service": "bedrock.amazonaws.com"
            },
            "Action": "sts:AssumeRole"
        }
    ] 
}
```
3. Recherchez la MyFineTuningDataAccesspolitique que vous avez créée, cochez la case et choisissez Next.
4. Nommez le rôle MyCustomizationRoleet sélectionnez Créer un rôle.

CLI

Créez un fichier appelé BedrockTrust.json et collez-y la politique suivante.


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service": "bedrock.amazonaws.com"
            },
            "Action": "sts:AssumeRole"
        }
    ] 
}

Créez un autre fichier appelé MyFineTuningDataAccess.json et collez-y la politique suivante, en remplaçant $ {training-bucket} et $ {output-bucket} par les noms de vos compartiments.


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::${training-bucket}",
                "arn:aws:s3:::${training-bucket}/*"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:PutObject",
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::${training-bucket}",
                "arn:aws:s3:::${training-bucket}/*"
            ]
        }
    ]
}

Dans un terminal, accédez au dossier contenant les politiques que vous avez créées.
Faites une CreateRoledemande pour créer un rôle IAM appelé MyCustomizationRoleet joignez la politique de confiance BedrockTrust.json que vous avez créée.
```
aws iam create-role \
    --role-name MyCustomizationRole \
    --assume-role-policy-document file://BedrockTrust.json
```
Faites une CreatePolicydemande pour créer la politique d'accès aux données S3 avec le fichier MyFineTuningDataAccess.json que vous avez créé. La réponse renvoie un Arn pour la politique.
```
aws iam create-policy \
    --policy-name MyFineTuningDataAccess \
    --policy-document file://myFineTuningDataAccess.json
```
Faites une AttachRolePolicydemande pour associer la politique d'accès aux données S3 à votre rôle, en policy-arn remplaçant le par l'ARN dans la réponse de l'étape précédente :
```
aws iam attach-role-policy \
    --role-name MyCustomizationRole \
    --policy-arn ${policy-arn}
```

Python

Exécutez le code suivant pour effectuer une CreateRoledemande de création d'un rôle IAM appelé MyCustomizationRoleet pour faire une CreatePolicydemande de création d'une politique d'accès aux données S3 appelée MyFineTuningDataAccess. Pour la politique d'accès aux données S3, remplacez $ {training-bucket} et $ {output-bucket} par les noms de vos compartiments S3.


import boto3
import json

iam = boto3.client("iam")

iam.create_role(
    RoleName="MyCustomizationRole",
    AssumeRolePolicyDocument=json.dumps({
        "Version": "2012-10-17",
        "Statement": [
            {
                "Effect": "Allow",
                "Principal": {
                    "Service": "bedrock.amazonaws.com"
                },
                "Action": "sts:AssumeRole"
            }
        ] 
    })
)

iam.create_policy(
    PolicyName="MyFineTuningDataAccess",
    PolicyDocument=json.dumps({
        "Version": "2012-10-17",
        "Statement": [
            {
                "Effect": "Allow",
                "Action": [
                    "s3:GetObject",
                    "s3:ListBucket"
                ],
                "Resource": [
                    "arn:aws:s3:::${training-bucket}",
                    "arn:aws:s3:::${training-bucket}/*"
                ]
            },
            {
                "Effect": "Allow",
                "Action": [
                    "s3:GetObject",
                    "s3:PutObject",
                    "s3:ListBucket"
                ],
                "Resource": [
                    "arn:aws:s3:::${output-bucket}",
                    "arn:aws:s3:::${output-bucket}/*"
                ]
            }
        ]
    })
)

An Arn est renvoyé dans la réponse. Exécutez l'extrait de code suivant pour effectuer une AttachRolePolicydemande, en remplaçant $ {policy-arn} par le code renvoyé. Arn
```
iam.attach_role_policy(
    RoleName="MyCustomizationRole",
    PolicyArn="${policy-arn}"
)
```

Sélectionnez une langue pour voir des exemples de code permettant d'appeler les opérations de l'API de personnalisation du modèle.

CLI

Créez d'abord un fichier texte nommé FineTuningData.json. Copiez le code JSON ci-dessous dans le fichier texte, en remplaçant $ {training-bucket} et $ {output-bucket} 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 de 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} par le rôle de personnalisation de 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 par le nom de votre bucket de sortie et JobID par l'ID de la tâche de personnalisation (la séquence suivant la dernière barre oblique du). jobArn


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.

Note

Cet achat vous sera facturé toutes les heures. Utilisez la console pour consulter les estimations de prix des différentes options.


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. Le résultat est écrit 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

Python

Exécutez l'extrait de code suivant pour soumettre une tâche de réglage précis. Remplacez $ {your-customization-role-arn} par l'ARN du compartiment MyCustomizationRoleque vous avez configuré et remplacez $ {training-bucket} et $ {output-bucket} par les noms de vos compartiments S3.


import boto3
import json

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


bedrock.get_provisioned_model_throughput(provisionedModelId=provisionedModelArn)


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

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Utiliser un modèle personnalisé

Consignes