Amostras de código para personalização do modelo

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 a taxa de transferência do modelo e executar inferências sobre o modelo. Você pode modificar esses trechos de código de acordo com seu caso de uso específico.

Prepare o conjunto de dados de treinamento.
1. Crie um arquivo de conjunto de dados de treinamento contendo a linha a seguir e chame-o de train.jsonl.
```
{"prompt": "what is AWS", "completion": "it's Amazon Web Services"}
```
2. Crie um bucket S3 para seus dados de treinamento e outro para seus dados de saída (os nomes devem ser exclusivos).
3. Faça upload do train.jsonl no repositório de dados de treinamento.

Crie uma política para acessar seu treinamento e anexe-a a uma função do IAM com uma relação de confiança da Amazon Bedrock. Selecione a guia correspondente ao seu método de escolha e siga as etapas.

Console

Crie a política do S3.

Navegue até o console do IAM em https://console.aws.amazon.com/iam e escolha Políticas no painel de navegação esquerdo.
Selecione Criar política e, em seguida, escolha JSON para abrir o editor de políticas.

Cole a política a seguir, substituindo $ {training-bucket} e $ {output-bucket} pelos nomes do seu bucket e selecione Avançar.


{
    "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}/*"
            ]
        }
    ]
}

Nomeie a política MyFineTuningDataAccesse selecione Criar política.

Crie uma função do IAM e anexe a política.
1. No painel de navegação esquerdo, escolha Funções e, em seguida, selecione Criar função.
2. Selecione Política de confiança personalizada, cole a política a seguir e selecione Avançar.
```
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service": "bedrock.amazonaws.com"
            },
            "Action": "sts:AssumeRole"
        }
    ] 
}
```
3. Procure a MyFineTuningDataAccesspolítica que você criou, marque a caixa de seleção e escolha Avançar.
4. Dê um nome à função MyCustomizationRolee selecione Criar função.

CLI

Crie um arquivo chamado BedrockTrust.json e cole a política a seguir nele.


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

Crie outro arquivo chamado MyFineTuningDataAccess.json e cole a política a seguir nele, substituindo $ {training-bucket} e $ {output-bucket} pelos nomes do seu bucket.


{
    "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}/*"
            ]
        }
    ]
}

Em um terminal, navegue até a pasta que contém as políticas que você criou.
Faça uma CreateRolesolicitação para criar uma função do IAM chamada MyCustomizationRolee anexar a política de confiança BedrockTrust.json que você criou.
```
aws iam create-role \
    --role-name MyCustomizationRole \
    --assume-role-policy-document file://BedrockTrust.json
```
Faça uma CreatePolicysolicitação para criar a política de acesso a dados do S3 com o MyFineTuningDataAccessarquivo.json que você criou. A resposta retorna um Arn para a política.
```
aws iam create-policy \
    --policy-name MyFineTuningDataAccess \
    --policy-document file://myFineTuningDataAccess.json
```
Faça uma AttachRolePolicysolicitaçã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

Execute o código a seguir para fazer uma CreateRolesolicitação para criar uma função do IAM chamada MyCustomizationRolee para fazer uma CreatePolicysolicitaçã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 $ {training-bucket} e $ {output-bucket} 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}/*"
                ]
            }
        ]
    })
)

Um Arn é retornado na resposta. Execute o seguinte trecho de código para fazer uma AttachRolePolicysolicitação, substituindo $ {policy-arn} pelo retornado. Arn
```
iam.attach_role_policy(
    RoleName="MyCustomizationRole",
    PolicyArn="${policy-arn}"
)
```

Selecione um idioma para ver exemplos de código para chamar as operações da API de personalização do modelo.

CLI

Primeiro, crie um arquivo de texto chamado FineTuningData.json. Copie o código JSON abaixo para o arquivo de texto, substituindo $ {training-bucket} e $ {output-bucket} pelos nomes dos seus buckets do S3.


{
    "trainingDataConfig": {
        "s3Uri": "s3://${training-bucket}/train.jsonl"
    },
    "outputDataConfig": {
        "s3Uri": "s3://${output-bucket}"
    }
}

Para enviar um trabalho de personalização do modelo, navegue até a pasta que contém FineTuningData.json em um terminal e execute o seguinte comando na linha de comando, substituindo $ {your-customization-role-arn} pela função de personalização do 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=.0005,learningRateWarmupSteps=0 \
    --cli-input-json file://FineTuningData.json

A resposta retorna um JobArn. Aguarde algum tempo para que o trabalho seja concluído. Você pode verificar seu status com o comando a seguir.


aws bedrock get-model-customization-job \
    --job-identifier "jobArn"

Quando o status éCOMPLETE, você pode ver o trainingMetrics na resposta. Você pode baixar os artefatos para a pasta atual executando o comando a seguir, substituindo aet.et-bucket 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 uma taxa de transferência provisionada sem compromisso para seu modelo personalizado com o comando a seguir.

nota

Você será cobrado por hora por essa compra. Use o console para ver 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 umprovisionedModelArn. Permita que a taxa de transferência provisionada seja criada por algum tempo. Para verificar seu status, forneça o nome ou ARN do modelo provisionado conforme o comando a seguirprovisioned-model-id.


aws bedrock get-provisioned-model-throughput \
    --provisioned-model-id ${provisioned-model-arn}

Quando status estiverInService, você pode executar a inferência com seu modelo personalizado com o comando a seguir. Você deve fornecer o ARN do modelo provisionado como o. model-id A saída é gravada em um arquivo chamado output.txt em 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 seguinte trecho de código para enviar um trabalho de ajuste fino. Substitua $ {your-customization-role-arn} pelo ARN do MyCustomizationRoleque você configurou e substitua $ {training-bucket} e $ {output-bucket} pelos nomes dos seus buckets do 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')

A resposta retorna um JobArn. Aguarde algum tempo para que o trabalho seja concluído. Você pode verificar seu status com o comando a seguir.


bedrock.get_model_customization_job(jobIdentifier=jobArn).get('status')

Quando o status éCOMPLETE, você pode ver o trainingMetrics na GetModelCustomizationJobresposta. Você também pode seguir as etapas em Baixar objetos para baixar as métricas.

Compre uma taxa de transferência provisionada sem compromisso para seu 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')


bedrock.get_provisioned_model_throughput(provisionedModelId=provisionedModelArn)

Quando status estiverInService, você pode executar a inferência com seu modelo personalizado com o comando a seguir. Você deve fornecer 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()

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Use um modelo personalizado

Diretrizes