As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Amostras de código para personalização de modelos Os exemplos de código a seguir mostram como preparar um conjunto de dados básico, configurar permissões, criar um modelo personalizado, visualizar os arquivos de saída, comprar o throughput do modelo e executar inferência no modelo. É possível modificar esses trechos de código de acordo com o caso de uso específico. 1. Prepare o conjunto de dados de treinamento. 1. Crie um arquivo de conjunto de dados de treinamento contendo a linha a seguir e dê um nome a ela*train.jsonl*. ``` {"prompt": "what is AWS", "completion": "it's Amazon Web Services"} ``` 1. Crie um bucket do S3 para os dados de treinamento e outro para os dados de saída (os nomes devem ser exclusivos). 1. Faça o upload *train.jsonl* para o repositório de dados de treinamento. 1. Crie uma política para acessar o treinamento e anexe-a a um perfil do IAM com uma relação de confiança do Amazon Bedrock. Escolha a guia correspondente ao método de sua preferência e siga as etapas: ------ #### [ Console ] 1. Crie a política do S3. 1. Navegue até o console do IAM em [https://console.aws.amazon.com/iam](https://console.aws.amazon.com/iam) e escolha **Políticas** no painel de navegação esquerdo. 1. Selecione **Criar política** e escolha **JSON** para abrir o **Editor de políticas**. 1. Cole a política a seguir, *\$1\$1training-bucket\$1* substituindo-a pelos nomes dos seus buckets, e selecione **Avançar**. *\$1\$1output-bucket\$1* ------ #### [ 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. Nomeie a política *MyFineTuningDataAccess* e selecione **Criar política**. 1. Crie um perfil do IAM e anexe a política. 1. No painel de navegação à esquerda, escolha **Perfis** e selecione **Criar perfil**. 1. Selecione **Política de confiança personalizada**, cole a política a seguir e selecione **Próximo**. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "bedrock.amazonaws.com" }, "Action": "sts:AssumeRole" } ] } ``` ------ 1. Procure a *MyFineTuningDataAccess* política que você criou, marque a caixa de seleção e escolha **Avançar**. 1. Nomeie a função *MyCustomizationRole* e selecione*Create role*. ------ #### [ CLI ] 1. Crie um arquivo chamado *BedrockTrust.json* e cole a política a seguir nele. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "bedrock.amazonaws.com" }, "Action": "sts:AssumeRole" } ] } ``` ------ 1. Crie outro arquivo chamado *MyFineTuningDataAccess.json* e cole a política a seguir nele, substituindo *\$1\$1training-bucket\$1* e *\$1\$1output-bucket\$1* pelos nomes dos seus 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. Em um terminal, navegue até a pasta que contém as políticas que criou. 1. Faça uma [CreateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateRole.html)solicitação para criar uma função do IAM chamada *MyCustomizationRole* e anexe a política de *BedrockTrust.json* confiança que você criou. ``` aws iam create-role \ --role-name MyCustomizationRole \ --assume-role-policy-document file://BedrockTrust.json ``` 1. Faça uma [CreatePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreatePolicy.html)solicitação para criar a política de acesso a dados do S3 com o *MyFineTuningDataAccess.json* arquivo que você criou. A resposta retorna um `Arn` para a política. ``` aws iam create-policy \ --policy-name MyFineTuningDataAccess \ --policy-document file://myFineTuningDataAccess.json ``` 1. Faça uma [AttachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachRolePolicy.html)solicitação para anexar a política de acesso a dados do S3 à sua função, substituindo-a `policy-arn` pelo ARN na resposta da etapa anterior: ``` aws iam attach-role-policy \ --role-name MyCustomizationRole \ --policy-arn ${policy-arn} ``` ------ #### [ Python ] 1. Execute o código a seguir para fazer uma [CreateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateRole.html)solicitação para criar uma função do IAM chamada *MyCustomizationRole* e para fazer uma [CreatePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreatePolicy.html)solicitação para criar uma política de acesso a dados do S3 chamada*MyFineTuningDataAccess*. Para a política de acesso a dados do S3, substitua *\$1\$1training-bucket\$1* e *\$1\$1output-bucket\$1* pelos nomes dos seus buckets do 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. Um `Arn` é retornado na resposta. Execute o seguinte trecho de código para fazer uma [AttachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachRolePolicy.html)solicitação, *\$1\$1policy-arn\$1* substituindo-o pelo retornado. `Arn` ``` iam.attach_role_policy( RoleName="MyCustomizationRole", PolicyArn="${policy-arn}" ) ``` ------ 1. Selecione uma linguagem para obter os exemplos de código para chamar as operações de API de personalização de modelo. ------ #### [ CLI ] Primeiro, crie um arquivo de texto chamado*FineTuningData.json*. Copie o código JSON abaixo para o arquivo de texto, substituindo-o pelos nomes *\$1\$1training-bucket\$1* dos seus buckets do S3. *\$1\$1output-bucket\$1* ``` { "trainingDataConfig": { "s3Uri": "s3://${training-bucket}/train.jsonl" }, "outputDataConfig": { "s3Uri": "s3://${output-bucket}" } } ``` Para enviar um trabalho de personalização de modelo, navegue até a pasta contida *FineTuningData.json* em um terminal e execute o seguinte comando na linha de comando, *\$1\$1your-customization-role-arn\$1* substituindo-o pela função de personalização de modelo que você configurou. ``` 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 ``` A resposta retorna o *jobArn*. Aguarde até que o trabalho seja concluído. É possível verificar seu status com o seguinte comando: ``` aws bedrock get-model-customization-job \ --job-identifier "jobArn" ``` Quando o `status` for `COMPLETE`, será possível ver as `trainingMetrics` na resposta. Você pode baixar os artefatos para a pasta atual executando o comando a seguir, *aet.et-bucket* substituindo-o pelo nome do bucket de saída e *jobId* pelo ID do trabalho de personalização (a sequência após a última barra no). `jobArn` ``` aws s3 cp s3://${output-bucket}/model-customization-job-jobId . --recursive ``` Compre throughput provisionado sem compromisso para o modelo personalizado com o comando a seguir. **nota** Você receberá cobrança por hora por essa compra. Use o console para ver as estimativas de preços para diferentes opções. ``` aws bedrock create-provisioned-model-throughput \ --model-id MyCustomModel \ --provisioned-model-name MyProvisionedCustomModel \ --model-units 1 ``` A resposta retorna o `provisionedModelArn`. Aguarde até que o throughput provisionado seja criado. Para verificar o status, forneça o nome ou o ARN do modelo provisionado como `provisioned-model-id` no comando a seguir. ``` aws bedrock get-provisioned-model-throughput \ --provisioned-model-id ${provisioned-model-arn} ``` Quando o `status` for `InService`, será possível executar a inferência com o modelo personalizado com o comando a seguir. Forneça o ARN do modelo provisionado como o `model-id`. A saída é gravada em um arquivo chamado *output.txt* na sua pasta atual. ``` 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 ] Execute o trecho de código a seguir para enviar um trabalho de ajuste. *\$1\$1your-customization-role-arn\$1*Substitua pelo ARN do *MyCustomizationRole* que você configurou e substituiu e pelos nomes dos seus *\$1\$1training-bucket\$1* *\$1\$1output-bucket\$1* buckets do 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') ``` A resposta retorna o *jobArn*. Aguarde até que o trabalho seja concluído. É possível verificar seu status com o seguinte comando: ``` bedrock.get_model_customization_job(jobIdentifier=jobArn).get('status') ``` Quando o `status` é`COMPLETE`, você pode ver o `trainingMetrics` na [GetModelCustomizationJob](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_GetModelCustomizationJob.html)resposta. Você também pode seguir as etapas em [Baixar objetos](https://docs.aws.amazon.com/AmazonS3/latest/userguide/download-objects.html) para baixar as métricas. Compre throughput provisionado sem compromisso para o modelo personalizado com o comando a seguir. ``` response_pt = bedrock.create_provisioned_model_throughput( modelId="MyCustomModel", provisionedModelName="MyProvisionedCustomModel", modelUnits="1" ) provisionedModelArn = response_pt.get('provisionedModelArn') ``` A resposta retorna o `provisionedModelArn`. Aguarde até que o throughput provisionado seja criado. Para verificar o status, forneça o nome ou o ARN do modelo provisionado como `provisionedModelId` no comando a seguir. ``` bedrock.get_provisioned_model_throughput(provisionedModelId=provisionedModelArn) ``` Quando o `status` for `InService`, será possível executar a inferência com o modelo personalizado com o comando a seguir. Forneça o ARN do modelo provisionado como o `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() ``` ------