Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # 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. 1. 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"} ``` 1. 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). 1. *train.jsonl*Téléchargez-le dans le compartiment de données d'entraînement. 1. Créez une politique pour accéder à votre entraînement et associez-la à un rôle IAM bénéficiant d’une relation d’approbation avec Amazon Bedrock. Choisissez l’onglet correspondant à votre méthode préférée, puis suivez les étapes : ------ #### [ Console ] 1. Créez la politique S3. 1. Accédez à la console IAM à l'adresse [https://console.aws.amazon.com/iam](https://console.aws.amazon.com/iam) et choisissez **Policies dans le volet** de navigation de gauche. 1. Sélectionnez **Créer une politique**, puis choisissez **JSON** pour ouvrir l’**Éditeur de politique**. 1. Collez la politique suivante, en *\$1\$1output-bucket\$1* remplaçant *\$1\$1training-bucket\$1* et par les noms de vos compartiments, puis sélectionnez **Next**. ------ #### [ JSON ] **** ``` { "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}/*" ] } ] } ``` ------ 1. Donnez un nom à la politique *MyFineTuningDataAccess* et sélectionnez **Créer une politique**. 1. Créez un rôle IAM et associez la politique. 1. Dans le panneau de navigation de gauche, choisissez **Rôles**, puis **Créer un rôle**. 1. Sélectionnez **Politique d’approbation personnalisée**, collez la politique suivante, puis sélectionnez **Suivant**. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "bedrock.amazonaws.com" }, "Action": "sts:AssumeRole" } ] } ``` ------ 1. Recherchez la *MyFineTuningDataAccess* politique que vous avez créée, cochez la case et choisissez **Next**. 1. Nommez le rôle *MyCustomizationRole* et sélectionnez*Create role*. ------ #### [ CLI ] 1. Créez un fichier appelé *BedrockTrust.json* et collez-y la politique suivante. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "bedrock.amazonaws.com" }, "Action": "sts:AssumeRole" } ] } ``` ------ 1. Créez un autre fichier appelé *MyFineTuningDataAccess.json* et collez-y la politique suivante, en remplaçant *\$1\$1training-bucket\$1* et par *\$1\$1output-bucket\$1* les noms de vos compartiments. ------ #### [ JSON ] **** ``` { "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}/*" ] } ] } ``` ------ 1. Dans un terminal, accédez au dossier contenant les politiques que vous avez créées. 1. Faites une [CreateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateRole.html)demande pour créer un rôle IAM appelé *MyCustomizationRole* et joignez la politique de *BedrockTrust.json* confiance que vous avez créée. ``` aws iam create-role \ --role-name MyCustomizationRole \ --assume-role-policy-document file://BedrockTrust.json ``` 1. Faites une [CreatePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreatePolicy.html)demande pour créer la politique d'accès aux données S3 avec le *MyFineTuningDataAccess.json* fichier 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 ``` 1. Faites une [AttachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachRolePolicy.html)demande 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 ] 1. Exécutez le code suivant pour effectuer une [CreateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateRole.html)demande de création d'un rôle IAM appelé *MyCustomizationRole* et pour faire une [CreatePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreatePolicy.html)demande 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 *\$1\$1training-bucket\$1* et *\$1\$1output-bucket\$1* 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}/*" ] } ] }) ) ``` 1. Un `Arn` est renvoyé dans la réponse. Exécutez l'extrait de code suivant pour effectuer une [AttachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachRolePolicy.html)demande, en le *\$1\$1policy-arn\$1* remplaçant par le code renvoyé. `Arn` ``` iam.attach_role_policy( RoleName="MyCustomizationRole", PolicyArn="${policy-arn}" ) ``` ------ 1. Sélectionnez une langue pour voir des exemples de code permettant d’appeler les opérations d’API de personnalisation de modèles. ------ #### [ CLI ] Créez d'abord un fichier texte nommé*FineTuningData.json*. Copiez le code JSON ci-dessous dans le fichier texte, en *\$1\$1output-bucket\$1* remplaçant *\$1\$1training-bucket\$1* 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 *\$1\$1your-customization-role-arn\$1* 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 du`jobArn`). ``` 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. **Note** Cet achat vous sera facturé par heure. 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 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 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 peaufinage. *\$1\$1your-customization-role-arn\$1*Remplacez-le par l'ARN du compartiment *MyCustomizationRole* que vous avez configuré *\$1\$1training-bucket\$1* et remplacé, ainsi que *\$1\$1output-bucket\$1* 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 cas`COMPLETE`, vous pouvez le voir `trainingMetrics` dans la [GetModelCustomizationJob](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_GetModelCustomizationJob.html)réponse. Vous pouvez également suivre les étapes décrites dans [Téléchargement d’objets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/download-objects.html) 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 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() ``` ------