Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés. # Ejemplos de código para la personalización de modelos Los siguientes ejemplos de código muestran cómo preparar un conjunto de datos básico, configurar los permisos, crear un modelo personalizado, ver los archivos de salida, adquirir el rendimiento para el modelo y realizar inferencias en el modelo. Puede modificar estos fragmentos de código según su caso de uso específico. 1. Prepare el conjunto de datos de entrenamiento. 1. Crea un archivo de conjunto de datos de entrenamiento que contenga la siguiente línea y asígnale un nombre*train.jsonl*. ``` {"prompt": "what is AWS", "completion": "it's Amazon Web Services"} ``` 1. Cree un bucket de S3 para los datos de entrenamiento y otro para los datos de salida (los nombres deben ser únicos). 1. Cárgalo *train.jsonl* en el depósito de datos de entrenamiento. 1. Cree una política para acceder al entrenamiento y asóciela a un rol de IAM con una relación de confianza en Amazon Bedrock. Elija la pestaña del método que prefiera y siga estos pasos: ------ #### [ Console ] 1. Cree la política de S3. 1. Ve a la consola de IAM en [https://console.aws.amazon.com/iam](https://console.aws.amazon.com/iam) y selecciona **Políticas en el panel** de navegación izquierdo. 1. Seleccione **Crear política** y, a continuación, elija **JSON** para abrir el **Editor de políticas**. 1. **Pegue la siguiente política, sustituya *\$1\$1training-bucket\$1* y por los nombres *\$1\$1output-bucket\$1* de su bucket y, a continuación, seleccione Siguiente.** ------ #### [ 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. Asigne un nombre a la política *MyFineTuningDataAccess* y seleccione **Crear política**. 1. Cree un rol de IAM y asóciele la política. 1. En el panel de navegación de la izquierda, seleccione **Roles** y, a continuación, seleccione **Crear rol**. 1. Seleccione **Política de confianza personalizada**, pegue la siguiente política y seleccione **Siguiente**. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "bedrock.amazonaws.com" }, "Action": "sts:AssumeRole" } ] } ``` ------ 1. Busca la *MyFineTuningDataAccess* política que creaste, selecciona la casilla de verificación y selecciona **Siguiente**. 1. Asigne un nombre al rol *MyCustomizationRole* y selecciónelo*Create role*. ------ #### [ CLI ] 1. Cree un archivo llamado *BedrockTrust.json* y pegue la siguiente política en él. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "bedrock.amazonaws.com" }, "Action": "sts:AssumeRole" } ] } ``` ------ 1. Crea otro archivo llamado *MyFineTuningDataAccess.json* y pega la siguiente política en él, sustituyendo *\$1\$1training-bucket\$1* y *\$1\$1output-bucket\$1* por los nombres de tus buckets. ------ #### [ 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. En un terminal, navegue hasta la carpeta que contiene las políticas que ha creado. 1. [CreateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateRole.html)Solicita la creación de un rol de IAM llamado *MyCustomizationRole* y adjunta la política de *BedrockTrust.json* confianza que creaste. ``` aws iam create-role \ --role-name MyCustomizationRole \ --assume-role-policy-document file://BedrockTrust.json ``` 1. [CreatePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreatePolicy.html)Solicita crear la política de acceso a los datos de S3 con el *MyFineTuningDataAccess.json* archivo que has creado. La respuesta devuelve un `Arn` para la política. ``` aws iam create-policy \ --policy-name MyFineTuningDataAccess \ --policy-document file://myFineTuningDataAccess.json ``` 1. Realice una [AttachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachRolePolicy.html)solicitud para adjuntar la política de acceso a datos de S3 a su función, sustituyéndola por el ARN en la respuesta del paso anterior: `policy-arn` ``` aws iam attach-role-policy \ --role-name MyCustomizationRole \ --policy-arn ${policy-arn} ``` ------ #### [ Python ] 1. Ejecute el siguiente código para realizar una [CreateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateRole.html)solicitud de creación de un rol de IAM *MyCustomizationRole* y para realizar una [CreatePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreatePolicy.html)solicitud de creación de una política de acceso a datos de S3 denominada. *MyFineTuningDataAccess* Para la política de acceso a datos de S3, sustituya *\$1\$1training-bucket\$1* y por los nombres *\$1\$1output-bucket\$1* de los buckets de 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. En la respuesta se devuelve un `Arn`. Ejecuta el siguiente fragmento de código para realizar una [AttachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachRolePolicy.html)solicitud y sustitúyelo por el *\$1\$1policy-arn\$1* devuelto. `Arn` ``` iam.attach_role_policy( RoleName="MyCustomizationRole", PolicyArn="${policy-arn}" ) ``` ------ 1. Seleccione un idioma para ver ejemplos de código para llamar a las operaciones de la API de personalización de modelos. ------ #### [ CLI ] En primer lugar, crea un archivo de texto llamado. *FineTuningData.json* Copia el código JSON que aparece a continuación en el archivo de texto, sustituyendo *\$1\$1training-bucket\$1* y por *\$1\$1output-bucket\$1* los nombres de los buckets de S3. ``` { "trainingDataConfig": { "s3Uri": "s3://${training-bucket}/train.jsonl" }, "outputDataConfig": { "s3Uri": "s3://${output-bucket}" } } ``` Para enviar un trabajo de personalización de modelos, navegue hasta la carpeta que contiene *FineTuningData.json* una terminal y ejecute el siguiente comando en la línea de comandos, *\$1\$1your-customization-role-arn\$1* sustituyéndolo por el rol de personalización del modelo que haya configurado. ``` 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 respuesta devuelve un *jobArn*. El trabajo puede tardar unos minutos en completarse. Puede comprobar su estado con el siguiente comando. ``` aws bedrock get-model-customization-job \ --job-identifier "jobArn" ``` Cuando el `status` sea `COMPLETE`, podrá ver `trainingMetrics` en la respuesta. Para descargar los artefactos a la carpeta actual, ejecute el siguiente comando y *aet.et-bucket* reemplácelos por el nombre del bucket de salida y *jobId* por el ID del trabajo de personalización (la secuencia que sigue a la última barra del`jobArn`). ``` aws s3 cp s3://${output-bucket}/model-customization-job-jobId . --recursive ``` Adquiera un rendimiento aprovisionado sin compromiso para el modelo personalizado con el siguiente comando. **nota** Se le cobrará por hora por esta compra. Use la consola para ver las estimaciones de precios de las diferentes opciones. ``` aws bedrock create-provisioned-model-throughput \ --model-id MyCustomModel \ --provisioned-model-name MyProvisionedCustomModel \ --model-units 1 ``` La respuesta devuelve un `provisionedModelArn`. Debe esperar unos minutos a que se cree el rendimiento aprovisionado. Para comprobar el estado, proporcione el nombre o el ARN del modelo aprovisionado como `provisioned-model-id` en el siguiente comando. ``` aws bedrock get-provisioned-model-throughput \ --provisioned-model-id ${provisioned-model-arn} ``` Si el `status` es `InService`, puede ejecutar una inferencia con su modelo personalizado con el siguiente comando. Debe proporcionar el ARN del modelo aprovisionado como `model-id`. El resultado se graba en un archivo con el nombre *output.txt* de la carpeta actual. ``` 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 ] Ejecute el siguiente fragmento de código para enviar un trabajo de afinación. *\$1\$1your-customization-role-arn\$1*Sustitúyalo por el ARN del depósito *MyCustomizationRole* que configuró y *\$1\$1training-bucket\$1* sustituyó y por los nombres de sus *\$1\$1output-bucket\$1* buckets de 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 respuesta devuelve un *jobArn*. El trabajo puede tardar unos minutos en completarse. Puede comprobar su estado con el siguiente comando. ``` bedrock.get_model_customization_job(jobIdentifier=jobArn).get('status') ``` Cuando el `status` es`COMPLETE`, puedes verlo `trainingMetrics` en la [GetModelCustomizationJob](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_GetModelCustomizationJob.html)respuesta. También puede seguir los pasos que se indican en [Descarga de objetos](https://docs.aws.amazon.com/AmazonS3/latest/userguide/download-objects.html) para descargar las métricas. Adquiera un rendimiento aprovisionado sin compromiso para el modelo personalizado con el siguiente comando. ``` response_pt = bedrock.create_provisioned_model_throughput( modelId="MyCustomModel", provisionedModelName="MyProvisionedCustomModel", modelUnits="1" ) provisionedModelArn = response_pt.get('provisionedModelArn') ``` La respuesta devuelve un `provisionedModelArn`. Debe esperar unos minutos a que se cree el rendimiento aprovisionado. Para comprobar el estado, proporcione el nombre o el ARN del modelo aprovisionado como `provisionedModelId` en el siguiente comando. ``` bedrock.get_provisioned_model_throughput(provisionedModelId=provisionedModelArn) ``` Si el `status` es `InService`, puede ejecutar una inferencia con su modelo personalizado con el siguiente comando. Debe proporcionar el ARN del modelo aprovisionado como `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() ``` ------