Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Esempi di codice per la personalizzazione del modello I seguenti esempi di codice mostrano come preparare un set di dati di base, impostare le autorizzazioni, creare un modello personalizzato, visualizzare i file di output, acquistare throughput per il modello ed eseguire l’inferenza sul modello. È possibile modificare questi frammenti di codice in base al caso d’uso specifico. 1. Preparare il set di dati di addestramento. 1. Crea un file del set di dati di addestramento contenente la riga seguente e assegnagli un nome. *train.jsonl* ``` {"prompt": "what is AWS", "completion": "it's Amazon Web Services"} ``` 1. Creare un bucket S3 per i dati di addestramento e un altro per i dati di output (i nomi devono essere univoci). 1. Caricalo *train.jsonl* nel bucket dei dati di allenamento. 1. Creare una policy per accedere all’addestramento e collegarla a un ruolo IAM con una relazione di attendibilità di Amazon Bedrock. Scegli la scheda relativa al metodo che preferisci, quindi segui la procedura: ------ #### [ Console ] 1. Crea la policy S3. 1. Accedi alla console IAM all'indirizzo [https://console.aws.amazon.com/iam](https://console.aws.amazon.com/iam) e scegli **Policies** dal riquadro di navigazione a sinistra. 1. Seleziona **Crea policy**, quindi scegli **JSON** per aprire l’**Editor di policy**. 1. **Incolla la seguente policy, sostituendo *\$1\$1training-bucket\$1* e *\$1\$1output-bucket\$1* con i nomi dei bucket, quindi seleziona Avanti.** ------ #### [ 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. Assegna un nome alla politica *MyFineTuningDataAccess* e seleziona **Crea politica**. 1. Crea un ruolo IAM e collega la policy. 1. Nel riquadro di navigazione a sinistra, scegli **Ruoli**, poi **Crea ruolo**. 1. Seleziona **Policy di attendibilità personalizzata**, incolla la seguente policy e seleziona **Avanti**. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "bedrock.amazonaws.com" }, "Action": "sts:AssumeRole" } ] } ``` ------ 1. Cerca la *MyFineTuningDataAccess* politica che hai creato, seleziona la casella di controllo e scegli **Avanti**. 1. Assegna un nome al ruolo *MyCustomizationRole* e seleziona*Create role*. ------ #### [ CLI ] 1. Crea un file chiamato *BedrockTrust.json* e incolla la seguente politica al suo interno. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "bedrock.amazonaws.com" }, "Action": "sts:AssumeRole" } ] } ``` ------ 1. Crea un altro file chiamato *MyFineTuningDataAccess.json* e incolla la seguente politica al suo interno, sostituendo *\$1\$1training-bucket\$1* e *\$1\$1output-bucket\$1* con i nomi dei tuoi bucket. ------ #### [ 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. In un terminale, accedi alla cartella contenente le policy che hai creato. 1. Fai una [CreateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateRole.html)richiesta per creare un ruolo IAM chiamato *MyCustomizationRole* e allega la policy di *BedrockTrust.json* fiducia che hai creato. ``` aws iam create-role \ --role-name MyCustomizationRole \ --assume-role-policy-document file://BedrockTrust.json ``` 1. Fai una [CreatePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreatePolicy.html)richiesta per creare la policy di accesso ai dati di S3 con il *MyFineTuningDataAccess.json* file che hai creato. La risposta restituisce un `Arn` per la policy. ``` aws iam create-policy \ --policy-name MyFineTuningDataAccess \ --policy-document file://myFineTuningDataAccess.json ``` 1. Fai una [AttachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachRolePolicy.html)richiesta per allegare la policy di accesso ai dati di S3 al tuo ruolo, sostituendola `policy-arn` con l'ARN nella risposta del passaggio precedente: ``` aws iam attach-role-policy \ --role-name MyCustomizationRole \ --policy-arn ${policy-arn} ``` ------ #### [ Python ] 1. Esegui il codice seguente per fare una [CreateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateRole.html)richiesta per creare un ruolo IAM chiamato *MyCustomizationRole* e per fare una [CreatePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreatePolicy.html)richiesta per creare una policy di accesso ai dati S3 chiamata. *MyFineTuningDataAccess* Per la politica di accesso ai dati di S3, sostituisci *\$1\$1training-bucket\$1* e *\$1\$1output-bucket\$1* con i nomi dei bucket 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` viene restituito nella risposta. Esegui il seguente frammento di codice per effettuare una [AttachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachRolePolicy.html)richiesta, sostituendolo con quello restituito. *\$1\$1policy-arn\$1* `Arn` ``` iam.attach_role_policy( RoleName="MyCustomizationRole", PolicyArn="${policy-arn}" ) ``` ------ 1. Seleziona una lingua per visualizzare esempi di codice per chiamare le operazioni dell’API per la personalizzazione del modello. ------ #### [ CLI ] Innanzitutto, crea un file di testo denominato. *FineTuningData.json* Copia il codice JSON dal basso nel file di testo, sostituendo *\$1\$1training-bucket\$1* e *\$1\$1output-bucket\$1* con i nomi dei bucket S3. ``` { "trainingDataConfig": { "s3Uri": "s3://${training-bucket}/train.jsonl" }, "outputDataConfig": { "s3Uri": "s3://${output-bucket}" } } ``` Per inviare un lavoro di personalizzazione del modello, accedi alla cartella contenuta *FineTuningData.json* in un terminale ed esegui il seguente comando nella riga di comando, sostituendolo *\$1\$1your-customization-role-arn\$1* con il ruolo di personalizzazione del modello che hai impostato. ``` 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 risposta restituisce un *jobArn*. Attendi il completamento del processo. Puoi verificarne lo stato con il seguente comando. ``` aws bedrock get-model-customization-job \ --job-identifier "jobArn" ``` Quando lo `status` è `COMPLETE`, puoi visualizzare le `trainingMetrics` nella risposta. È possibile scaricare gli artefatti nella cartella corrente eseguendo il comando seguente, sostituendolo *aet.et-bucket* con il nome del bucket di output e *jobId* con l'ID del processo di personalizzazione (la sequenza che segue l'ultima barra del). `jobArn` ``` aws s3 cp s3://${output-bucket}/model-customization-job-jobId . --recursive ``` Acquista uno throughput assegnato senza impegno per il tuo modello personalizzato con il seguente comando. **Nota** Per questo acquisto ti verrà addebitata una tariffa oraria. Usa la console per visualizzare le stime dei prezzi per le diverse opzioni. ``` aws bedrock create-provisioned-model-throughput \ --model-id MyCustomModel \ --provisioned-model-name MyProvisionedCustomModel \ --model-units 1 ``` La risposta restituisce un `provisionedModelArn`. Attendi un po’ di tempo per la creazione dello throughput assegnato. Per verificarne lo stato, fornisci il nome o l’ARN del modello assegnato come il `provisioned-model-id` nel seguente comando. ``` aws bedrock get-provisioned-model-throughput \ --provisioned-model-id ${provisioned-model-arn} ``` Quando lo `status` è `InService`, puoi eseguire l’inferenza con il tuo modello personalizzato con il seguente comando. Devi fornire l’ARN del modello assegnato come il `model-id`. L'output viene scritto in un file denominato *output.txt* nella cartella corrente. ``` 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 ] Esegui il seguente frammento di codice per inviare un processo di fine-tuning. Sostituisci *\$1\$1your-customization-role-arn\$1* con l'ARN del file *MyCustomizationRole* che hai impostato e sostituito *\$1\$1training-bucket\$1* e *\$1\$1output-bucket\$1* con i nomi dei tuoi bucket 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 risposta restituisce un *jobArn*. Attendi il completamento del processo. Puoi verificarne lo stato con il seguente comando. ``` bedrock.get_model_customization_job(jobIdentifier=jobArn).get('status') ``` Quando lo `status` è`COMPLETE`, puoi vederlo `trainingMetrics` nella risposta. [GetModelCustomizationJob](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_GetModelCustomizationJob.html) Puoi anche seguire la procedura descritta in [Download degli oggetti](https://docs.aws.amazon.com/AmazonS3/latest/userguide/download-objects.html) per scaricare le metriche. Acquista uno throughput assegnato senza impegno per il tuo modello personalizzato con il seguente comando. ``` response_pt = bedrock.create_provisioned_model_throughput( modelId="MyCustomModel", provisionedModelName="MyProvisionedCustomModel", modelUnits="1" ) provisionedModelArn = response_pt.get('provisionedModelArn') ``` La risposta restituisce un `provisionedModelArn`. Attendi un po’ di tempo per la creazione dello throughput assegnato. Per verificarne lo stato, fornisci il nome o l’ARN del modello assegnato come il `provisionedModelId` nel seguente comando. ``` bedrock.get_provisioned_model_throughput(provisionedModelId=provisionedModelArn) ``` Quando lo `status` è `InService`, puoi eseguire l’inferenza con il tuo modello personalizzato con il seguente comando. Devi fornire l’ARN del modello assegnato come il `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() ``` ------