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á.
# Ajuste os modelos Amazon Nova com ajuste fino de reforço
Antes de fazer o ajuste fino, certifique-se de ter os pré-requisitos, pois o Amazon Bedrock precisa de permissões específicas para criar e gerenciar o processo de ajuste fino. Para obter informações abrangentes sobre segurança e permissões, consulte[Acesso e segurança para modelos Amazon Nova](rft-access-security.md).
Execute o ajuste fino de reforço para os modelos Amazon Nova em 5 etapas:
1. **Forneça o conjunto de dados de treinamento** — faça o upload de solicitações no formato necessário (por exemplo, JSONL) como conjunto de dados de treinamento de ajuste fino de reforço. Para obter mais informações, consulte [Prepare dados para os modelos Amazon Nova](rft-prepare-data.md).
1. **Configurar a função de recompensa (avaliador)** — Defina um avaliador para pontuar as respostas do modelo com base na exatidão, estrutura, tom ou outros objetivos. A função de recompensa pode ser executada usando o Lambda para calcular as pontuações objetivas. Você também pode escolher um modelo como juiz (via console) e avaliar as respostas com base nos critérios e princípios que você configura (o console os converte em funções Lambda automaticamente). Para obter mais informações, consulte [Configurando funções de recompensa para modelos Amazon Nova](reward-functions.md).
1. **Envie o trabalho de ajuste fino do reforço — Inicie o trabalho** de ajuste fino do reforço especificando o modelo base, o conjunto de dados, a função de recompensa e outras configurações opcionais, como hiperparâmetros. Para obter mais informações, consulte [Crie e gerencie trabalhos de ajuste fino para modelos Amazon Nova](rft-submit-job.md).
1. **Monitore o treinamento** — acompanhe o status do trabalho, as métricas de recompensa e o progresso do treinamento até a conclusão. Para obter mais informações, consulte [Monitore seu trabalho de treinamento em RFT](rft-submit-job.md#rft-monitor-job).
1. **Use um modelo ajustado** — após a conclusão do trabalho, implante o modelo RFT resultante com um clique para inferência sob demanda. Você também pode usar o Provisioned Throughput para cargas de trabalho de missão crítica que exigem desempenho consistente. Consulte [Configurar a inferência para um modelo personalizado](model-customization-use.md). Use **Test in Playground** para avaliar e comparar as respostas com o modelo básico.
**Importante**
Você pode fornecer no máximo 20 mil solicitações ao Amazon Bedrock para reforçar o ajuste fino do modelo.
## Modelos Nova compatíveis
A tabela a seguir mostra os modelos do Amazon Nova que você pode personalizar com o ajuste fino do reforço:
**nota**
Para obter informações sobre modelos adicionais compatíveis, incluindo modelos de peso aberto, consulte[Ajuste modelos de peso aberto usando -compatible OpenAI APIs](fine-tuning-openai-apis.md).
**Modelos compatíveis para ajuste fino do reforço**
| Fornecedor | Modelo | ID do modelo | Suporte ao modelo de região única |
| --- | --- | --- | --- |
| Amazon | Nova 2 Lite | amazon.nova-2-lite-v1:0:256k | us-east-1 |
# Acesso e segurança para modelos Amazon Nova
Antes de começar o ajuste fino do reforço, certifique-se de entender que tipo de acesso o Amazon Bedrock precisa para operações específicas de RFT. O RFT requer permissões adicionais além do ajuste fino padrão devido aos seus recursos de execução da função de recompensa.
Para a configuração básica de segurança da personalização do modelo, incluindo relações de confiança, permissões do Amazon S3 e criptografia KMS, consulte. [Criar um perfil de serviço do IAM para a personalização de modelo](custom-model-job-access-security.md#custom-model-job-service-role)
## Pré-requisitos
Antes de adicionar permissões do IAM específicas do RFT, você deve adicionar as seguintes funções de serviço do IAM:
+ [Relação de confiança](custom-model-job-access-security.md#custom-model-job-service-role-trust-relationship)
+ [Permissões para acessar arquivos de treinamento e de validação e gravar os arquivos de saída no S3](custom-model-job-access-security.md#custom-model-job-service-role-s3-permissions)
## Permissões do IAM específicas do RFT
Adicione essas permissões à sua função de serviço de personalização de modelo existente para a funcionalidade RFT.
### Permissões do Lambda para funções de recompensa
Você deve adicionar permissões de invocação do Lambda. Veja a seguir um exemplo de política que você pode usar:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": [
"arn:aws:lambda:*:*:function:reward-function-name"
]
}
]
}
```
### Acesso ao registro de invocação
Para usar os registros de invocação do modelo Amazon Bedrock existentes como dados de treinamento, adicione permissões para acessar seu bucket do Amazon S3 onde os registros de invocação são armazenados.
Você precisa fornecer permissões de acesso ao bucket do Amazon S3 para o bucket de entrada. Veja a seguir um exemplo de política que você pode usar:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::s3-invocation-logs-bucket",
"arn:aws:s3:::s3-invocation-logs-bucket/*"
]
}
]
}
```
Para configuração de segurança, incluindo funções básicas do IAM, permissões do Amazon S3 e criptografia, consulte. [Criar um perfil de serviço do IAM para a personalização de modelo](custom-model-job-access-security.md#custom-model-job-service-role)
## Permissões da função Grader Lambda para RLAIF
Se você criar sua própria função Lambda para Aprendizado por Reforço a partir de funções de recompensa de Feedback de IA (RLAIF), precisará adicionar permissões específicas à função de execução do Lambda.
### Permissões fundamentais para juízes de LLM
Para funções de LLM-as-Judge recompensa (RLAIF), adicione permissões para invocar modelos básicos. Veja a seguir um exemplo de política que você pode usar para sua função de execução do Lambda.
**nota**
Adicione essas permissões à sua função de execução do Lambda somente se você criar sua própria função do Lambda. O console lida com isso automaticamente ao criar funções Lambda por meio do console.
A seguir está um exemplo de LLM básico como invocação de juiz usando modelos básicos:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"bedrock:InvokeModel"
],
"Resource": [
"arn:aws:bedrock:*:*:foundation-model/*"
]
}
]
}
```
A seguir está um exemplo de LLM básico como invocação de juiz usando perfil de inferência:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"bedrock:InvokeModel"
],
"Resource": [
"arn:aws:bedrock:us-east-1::foundation-model/amazon.nova-premier-v1:0",
"arn:aws:bedrock:us-east-2::foundation-model/amazon.nova-premier-v1:0",
"arn:aws:bedrock:us-west-2::foundation-model/amazon.nova-premier-v1:0"
],
"Condition": {
"StringLike": {
"bedrock:InferenceProfileArn": "arn:aws:bedrock:us-east-1:111122223333:inference-profile/us.amazon.nova-premier-v1:0"
}
}
},
{
"Effect": "Allow",
"Action": [
"bedrock:InvokeModel"
],
"Resource": [
"arn:aws:bedrock:us-east-1:111122223333:inference-profile/us.amazon.nova-premier-v1:0"
]
}
]
}
```
Para obter informações sobre os pré-requisitos do perfil de inferência, consulte [Pré-requisitos](https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-prereq.html) para perfis de inferência.
# Prepare dados para os modelos Amazon Nova
Ao ajustar um modelo do Amazon Nova com ajuste fino de reforço, você pode trazer seus próprios prompts ou usar os registros de invocação da API Amazon Bedrock existentes como dados de treinamento.
## Requisitos e fontes de dados de treinamento
Você pode fornecer dados de treinamento por meio de uma das seguintes opções:
**nota**
Só oferecemos suporte ao formato de conclusão de bate-papo do OpenAI.
### Opção 1: forneça suas próprias instruções
Colete seus prompts e armazene-os no formato de arquivo `.jsonl`. Você pode fazer upload de conjuntos de dados personalizados no formato JSONL ou selecionar conjuntos de dados existentes do Amazon S3. Cada registro no JSONL deve usar o formato de conclusão de bate-papo do OpenAI na seguinte estrutura:
+ `messages`: nesse campo, inclua a função de usuário, sistema ou assistente contendo o prompt de entrada fornecido ao modelo.
+ `reference_answer`: nesse campo, ele deve conter o resultado esperado ou os critérios de avaliação que sua função de recompensa usa para pontuar a resposta do modelo. Ela não se limita a resultados estruturados — ela pode conter qualquer formato que ajude sua função de recompensa a avaliar a qualidade.
+ [Opcional] Você pode adicionar campos usados pelo avaliador Lambda para avaliação.
**Requisitos:**
+ Formato JSONL com prompts no formato de conclusão de chat OpenAI (um prompt por linha)
+ Um mínimo de 100 registros no conjunto de dados de treinamento
+ O Amazon Bedrock valida automaticamente o formato do conjunto de dados de treinamento
------
#### [ Example: General question-answering ]
```
{
"messages": [
{
"role": "system",
"content": "You are a helpful assistant"
},
{
role": "user",
"content": "What is machine learning?"}
],
"reference_answer": "Machine learning is a subset of artificial intelligence that enables computers to learn and make decisions from data without being explicitly programmed."
}
```
------
#### [ Example: Math problem ]
```
{
"id": "sample-001",
"messages": [
{
"role": "system",
"content": "You are a math tutor"
},
{
"role": "user",
"content": "Solve: 2x + 5 = 13"
}
],
"reference_answer": {
"solution": "x = 4",
"steps": ["2x = 13 - 5", "2x = 8", "x = 4"]
}
}
```
------
### Opção 2: usar registros de invocação
Ao criar um trabalho de ajuste fino de reforço, você pode fazer com que o Amazon Bedrock use os registros de invocação existentes do seu bucket do S3 como dados de treinamento. Para o Amazon Bedrock, um log de invocação é um registro detalhado das invocações do modelo.
Você pode usar registros de invocação de Invoke/Converse API armazenados no lado do cliente do Amazon S3 para treinamento.
**Requisitos:**
+ O registro de API deve estar habilitado para seu uso do Amazon Bedrock
+ Os registros devem estar em um formato compatível (Amazon Bedrock Invoke/Converse API)
+ Um mínimo de 100 exemplos de solicitações
Para usar registros de invocação para reforçar o ajuste fino, configure o login de invocação do modelo, use uma das operações de invocação do modelo e certifique-se de ter configurado um bucket do Amazon S3 como destino para os registros. Para obter mais informações sobre como configurar os registros de invocação, consulte [Monitorar a invocação do modelo usando o Logs e o CloudWatch Amazon](https://docs.aws.amazon.com/bedrock/latest/userguide/model-invocation-logging.html) S3.
Antes de iniciar o trabalho de ajuste fino de reforço com registros de invocação de um bucket do S3 como entrada, você deve fornecer permissões ao Amazon Bedrock para acessar os registros de um bucket do S3. Para obter mais informações, consulte [Acesso e segurança na personalização de modelos](custom-model-job-access-security.md).
Opcionalmente, você pode adicionar metadados de solicitação aos pares de prompt-resposta no log de invocação usando uma das operações de invocação do modelo e depois usá-los para filtrar os logs. O Amazon Bedrock pode usar os registros filtrados para ajustar o modelo.
#### Adicione metadados de solicitação às solicitações e respostas em seus registros de invocação
Com os registros de invocação, você pode identificar as solicitações do conjunto de dados de treinamento que você deseja que o Amazon Bedrock use para reforçar o ajuste fino usando metadados de solicitação anexados aos registros de invocação.
Veja a seguir um exemplo de um registro de invocação de uma `InvokeModel` chamada com o: `requestMetadata`
```
{
"schemaType": "ModelInvocationLog",
"schemaVersion": "1.0",
"timestamp": "2024-09-11T17:16:18Z",
"accountId": "XXXXX",
"identity": {
"arn": "arn:aws:sts::XXXXXXX:assumed-role/Admin/XXXXXX"
},
"region": "us-east-1",
"requestId": "7ee514f3-9eff-467c-af75-8fd564ce58e5",
"operation": "InvokeModel",
"modelId": "meta.llama3-1-405b-instruct-v1:0",
"input": {
"inputContentType": "application/json",
"inputBodyJson": {
"prompt": "story of two dogs",
"max_tokens_to_sample": 300
},
"inputTokenCount": 13
},
"output": {
"outputContentType": "application/json",
"outputBodyJson": {
"type": "completion",
"completion": " Here is a story about two dogs:\n\nRex and Charlie were best friends who lived next door to each other. Every morning, their owners would let them out into the backyard to play. Rex was a golden retriever with long, shaggy fur. He loved to run and chase sticks. Charlie was a corgi with short legs and a big smile. He was happy just sniffing the grass and rolling around. \n\nThe two dogs spent every day playing together. Rex would grab a stick and bring it over to Charlie, wagging his tail excitedly. Charlie would take the other end of the stick in his mouth and they'd have a friendly game of tug-of-war. After tiring themselves out, they'd flop down in the warm sunshine for a nap. \n\nAt lunchtime, their owners would call them in for food. Rex would gobble up his kibble hungrily while Charlie ate his at a more leisurely pace. After lunch, it was right back outside for more playtime. The afternoon sunbeams would light up their fur as they chased each other around the yard. \n\nWhen it started getting late, their owners called them in for the night. Rex and Charlie would head inside, tired but happy after another fun day of play. After slurping up fresh water from their bowls, they'd curl up on their beds, Rex's fluffy golden tail tucked over his nose and little",
"stop_reason": "max_tokens",
"stop": null
},
"outputTokenCount": 300
},
"requestMetadata": {
"project": "CustomerService",
"intent": "ComplaintResolution",
"priority": "High"
}
}
```
Você pode especificar o registro de invocação como sua fonte de dados de entrada ao iniciar um trabalho de ajuste fino de reforço. Você pode iniciar um trabalho de ajuste fino de reforço por meio do console Amazon Bedrock, usando a API ou o SDK. AWS CLI
##### Requisitos para fornecer metadados de solicitação
Os metadados solicitados devem cumprir os seguintes requisitos:
+ Fornecido no formato JSON `key:value`.
+ O par de chave-valor deve ser uma string de no máximo 256 caracteres.
+ Forneça no máximo de 16 pares de chave-valor.
##### Usar filtros de metadados de solicitação
Depois que os registros de invocação com metadados de solicitação estiverem disponíveis, você poderá aplicar filtros com base nos metadados da solicitação para escolher seletivamente quais solicitações incluir para ajustar o modelo. Por exemplo, talvez você queira incluir somente aqueles com metadados `"project": "CustomerService"` e `"priority": "High"` solicitados.
Para filtrar os registros usando vários metadados de solicitação, use um único operador `AND` booleano ou. `OR` Você não pode combinar esses operadores. Para filtragem de metadados de solicitação única, use o operador `Equals` ou`Not Equals`.
## Características dos dados de treinamento efetivos
Dados eficazes de treinamento de RFT requerem três características principais:
+ **Clareza e consistência** — use instruções claras e inequívocas com formatação consistente. Evite rótulos contraditórios, instruções ambíguas ou respostas de referência conflitantes que enganem o treinamento.
+ **Diversidade** — inclua formatos de entrada variados, casos extremos e níveis de dificuldade que refletem os padrões de uso da produção em diferentes tipos e cenários de usuários.
+ **Funções de recompensa eficientes** — Crie funções que sejam executadas rapidamente (segundos, não minutos), que se paralelizem e retornem pontuações consistentes para um treinamento econômico. AWS Lambda
## Propriedades adicionais
O formato de dados RFT oferece suporte a campos personalizados além dos requisitos principais do esquema (`messages`e`reference_answer`). Essa flexibilidade permite que você adicione quaisquer dados adicionais que sua função de recompensa precise para uma avaliação adequada.
**nota**
Você não precisa configurar isso em sua receita. O formato de dados suporta inerentemente campos adicionais. Basta incluí-los em seus dados de treinamento JSON e eles serão passados para sua função de recompensa em `metadata` campo.
**Propriedades adicionais comuns**
+ `task_id`— Identificador exclusivo para rastreamento
+ `difficulty_level`— Indicador de complexidade do problema
+ `domain`— Área temática ou categoria
+ `expected_reasoning_steps`— Número de etapas na solução
Esses campos adicionais são passados para sua função de recompensa durante a avaliação, permitindo uma lógica de pontuação sofisticada adaptada ao seu caso de uso específico.
**Exemplos com propriedades adicionais**
------
#### [ Chemistry problem ]
```
{
"id": "chem-001",
"messages": [
{
"role": "system",
"content": "You are a helpful chemistry assistant"
},
{
"role": "user",
"content": "Predict hydrogen bond donors and acceptors for this SMILES: CCN(CC)CCC(=O)c1sc(N)nc1C"
}
],
"reference_answer": {
"donor_bond_counts": 2,
"acceptor_bond_counts": 4
}
}
```
O `reference_answer` campo contém o resultado esperado ou os critérios de avaliação que sua função de recompensa usa para pontuar a resposta do modelo. Ela não se limita a resultados estruturados — ela pode conter qualquer formato que ajude sua função de recompensa a avaliar a qualidade.
------
#### [ Math problem with metadata ]
```
{
"messages": [
{
"role": "system",
"content": "You are a math tutor"
},
{
"role": "user",
"content": "Solve: 2x + 5 = 13"
}
],
"reference_answer": {
"solution": "x = 4",
"steps": ["2x = 13 - 5", "2x = 8", "x = 4"]
},
"task_id": "algebra_001",
"difficulty_level": "easy",
"domain": "algebra",
"expected_reasoning_steps": 3
}
```
------
# Configurando funções de recompensa para modelos Amazon Nova
As funções de recompensa avaliam a qualidade da resposta e fornecem sinais de feedback para o treinamento do modelo. Você pode configurar funções de recompensa usando funções personalizadas do Lambda ou modelos de fundação hospedados no Amazon Bedrock como juízes. Modelos guiados estão disponíveis para simplificar a criação de funções de recompensa para tarefas comuns, como acompanhamento de instruções e validação de formato. Escolha a abordagem que corresponda aos requisitos da sua tarefa.
## Aprendizagem por reforço por meio de recompensas verificáveis (RLVR)
O RLVR otimiza modelos para tarefas objetivas, como geração de código ou raciocínio matemático, usando avaliadores ou modelos baseados em regras verificáveis. ready-to-use
Você tem duas opções para RLVR (Código Personalizado):
### Opção 1: usar modelos fornecidos pelo console
O console Amazon Bedrock fornece exemplos de modelos para as funções do nivelador Lambda:
+ Raciocínio matemático com verificação da verdade básica
+ Validação de formato e verificação de restrições
+ Modelo Lambda de avaliador genérico com código padronizado
Siga as instruções no modelo fornecido na página de **trabalho Create RFT** no console [Amazon Bedrock](https://console.aws.amazon.com/bedrock).
### Opção 2: Traga sua própria função Lambda
Crie funções de recompensa personalizadas usando seu próprio ARN do Lambda para cálculos lógicos complexos APIs, externos e de várias etapas ou combinando vários critérios de avaliação.
**nota**
Se você trouxer sua própria função Lambda, tenha em mente o seguinte:
Aumente o tempo limite do Lambda do padrão de 3 segundos para o máximo 15 minutos para avaliações complexas.
A função de execução do Lambda precisa de permissões para invocar modelos, conforme descrito em. [Acesso e segurança para modelos Amazon Nova](rft-access-security.md)
## Aprendizagem por reforço por meio de feedback de IA (RLAIF)
O RLAIF otimiza modelos para tarefas subjetivas, como acompanhamento de instruções ou interações de chatbots, usando juízes baseados em IA com modelos. ready-to-use
**Para RLAIF (modelo como juiz):**
+ Selecione um modelo base hospedado no Amazon Bedrock como juiz
+ Configurar instruções para avaliação
+ Definir critérios de avaliação e diretrizes de pontuação
Modelos de LLM-as-Judge prompt disponíveis no console Amazon Bedrock:
+ Instrução seguinte (treinamento do modelo Judge)
+ Sumarização (caixas de diálogo com várias voltas)
+ Avaliação do raciocínio (CoT para domínios especializados)
+ Fidelidade ao RAG (perguntas e respostas baseadas no contexto)
**nota**
A opção **Model as Judge** do console converte automaticamente sua configuração em uma função Lambda durante o treinamento.
## Detalhes da implementação da função Lambda
Ao implementar funções personalizadas de recompensa do Lambda, sua função deve aceitar e retornar dados no formato a seguir.
------
#### [ Input structure ]
```
[{
"id": "123",
"messages": [
{
"role": "user",
"content": "Do you have a dedicated security team?"
},
{
"role": "assistant",
"content": "As an AI developed by Amazon, I don not have a dedicated security team..."
}
],
"metadata": {
"reference_answer": {
"compliant": "No",
"explanation": "As an AI developed by Company, I do not have a traditional security team..."
},
"my_key": "sample-001"
}
}]
```
------
#### [ Output structure ]
```
[{
"id": "123",
"aggregate_reward_score": 0.85,
"metrics_list": [
{
"name": "accuracy",
"value": 0.9,
"type": "Reward"
},
{
"name": "policy_compliance",
"value": 0.8,
"type": "Metric"
}
]
}]
```
------
**Diretrizes de design**
+ **Classifique as respostas** — Dê à melhor resposta uma pontuação claramente mais alta
+ **Use verificações consistentes** — Avalie a conclusão da tarefa, a aderência ao formato, a segurança e a duração razoável
+ **Mantenha o escalonamento estável** — mantenha as pontuações normalizadas e não exploráveis
# Crie e gerencie trabalhos de ajuste fino para modelos Amazon Nova
Você pode criar um trabalho de ajuste fino de reforço (RFT) usando o console ou a API do Amazon Bedrock. O trabalho de RFT pode levar algumas horas, dependendo do tamanho dos dados de treinamento, do número de épocas e da complexidade das funções de recompensa.
## Pré-requisitos
+ Crie uma função de serviço do IAM com as permissões necessárias. Para obter informações abrangentes sobre segurança e permissões, incluindo permissões específicas de RFT, consulte. [Acesso e segurança para modelos Amazon Nova](rft-access-security.md)
+ (Opcional) Criptografe dados de entrada e saída, seu trabalho de RFT ou solicitações de inferência feitas em modelos personalizados. Para obter mais informações, consulte [Criptografia de modelos personalizados](https://docs.aws.amazon.com/bedrock/latest/userguide/encryption-custom-job.html).
## Crie seu trabalho de RFT
Escolha a guia correspondente ao método de sua preferência e siga as etapas:
------
#### [ Console ]
Para enviar uma tarefa de RFT no console, execute as seguintes etapas:
1. Abra o console Amazon Bedrock e navegue até **Modelos personalizados** em **Tune**.
1. Escolha **Criar** e, em seguida, **Criar tarefa de ajuste fino de reforço**.
1. Na seção **Detalhes do modelo**, escolha **Amazon Nova 2 Lite** como seu modelo básico.
1. Na seção **Detalhes da personalização**, insira o nome da personalização.
1. Na seção **Dados de treinamento**, escolha sua fonte de dados. Selecione entre seus registros de invocação disponíveis armazenados no Amazon S3, selecione a localização do Amazon S3 do seu arquivo de conjunto de dados de treinamento ou carregue um arquivo diretamente do seu dispositivo.
**nota**
Seu conjunto de dados de treinamento deve estar no formato de dados de conclusão do OpenAI Chat. Se você fornecer registros de invocação no formato de invocação ou conversão do Amazon Bedrock, o Amazon Bedrock os converterá automaticamente para o formato de conclusão de bate-papo.
1. Na seção **Função de recompensa**, configure seu mecanismo de recompensa:
+ **Modelo como juiz (RLAIF)** - Selecione um modelo base hospedado no Bedrock como juiz e configure as instruções para avaliação. Use isso para tarefas subjetivas, como moderação de conteúdo.
**nota**
A opção **Model as judge** do console converte automaticamente sua configuração em uma função Lambda durante o treinamento.
+ **Código personalizado (RLVR)** - Crie funções de recompensa personalizadas usando código Python executado por meio de funções Lambda. Use isso para tarefas objetivas, como geração de código.
Para obter mais informações, consulte [Configurando funções de recompensa para modelos Amazon Nova](reward-functions.md).
1. (Opcional) Na seção **Hiperparâmetros**, ajuste os parâmetros de treinamento ou use valores padrão.
1. Na seção **Dados de saída**, insira o local do Amazon S3 onde o Amazon Bedrock deve salvar as saídas do trabalho.
1. Na seção **Configuração da função**, escolha uma função existente na lista suspensa ou insira um nome para a função de serviço a ser criada.
1. (Opcional) Na seção **Configuração adicional**, configure os dados de validação apontando para um bucket do Amazon S3, configurações de criptografia KMS e tags de trabalho e modelo.
1. Escolha **Criar tarefa de ajuste fino de reforço para começar a tarefa**.
------
#### [ API ]
Envie uma CreateModelCustomizationJob solicitação com `customizationType` set to`REINFORCEMENT_FINE_TUNING`.
**Campos obrigatórios:** `roleArn``baseModelIdentifier`,`customModelName`,`jobName`,,`trainingDataConfig`,`outputDataConfig`, `rftConfig`
**Exemplo de solicitação:**
```
{
"roleArn": "arn:aws:iam::123456789012:role/BedrockRFTRole",
"baseModelIdentifier": "amazon.nova-2.0",
"customModelName": "my-rft-model",
"jobName": "my-rft-job",
"customizationType": "REINFORCEMENT_FINE_TUNING",
"trainingDataConfig": {
"s3Uri": "s3://my-bucket/training-data.jsonl"
},
"customizationConfig": {
"rftConfig" : {
"graderConfig": {
"lambdaGrader": {
"lambdaArn": "arn:aws:lambda:us-east-1:123456789012:function:function-name"
}
},
"hyperParameters": {
"batchSize": 64,
"epochCount": 2,
"evalInterval": 10,
"inferenceMaxTokens": 8192,
"learningRate": 0.00001,
"maxPromptLength": 4096,
"reasoningEffort": "high",
"trainingSamplePerPrompt": 4
}
}
},
"outputDataConfig": {
"s3Uri": "s3://my-bucket/rft-output/"
}
}
```
**Solicitação de amostra da API Python:**
```
import boto3
bedrock = boto3.client(service_name='bedrock')
# Set parameters
customizationType = "REINFORCEMENT_FINE_TUNING"
baseModelIdentifier = "arn:aws:bedrock:us-east-1::foundation-model/amazon.nova-2-lite-v1:0:256k"
roleArn = "${your-customization-role-arn}"
jobName = "MyFineTuningJob"
customModelName = "MyCustomModel"
customizationConfig = {
'rftConfig' : {
'graderConfig': {
'lambdaGrader': {
'lambdaArn': 'arn:aws:lambda:us-east-1:123456789012:function:function-name'
}
},
'hyperParameters': {
'batchSize': 64,
'epochCount': 2,
'evalInterval': 10,
'inferenceMaxTokens': 8192,
'learningRate':0.00001,
'maxPromptLength': 4096,
'reasoningEffort': 'high',
'trainingSamplePerPrompt':4
}
}
}
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,
customizationConfig=customizationConfig,
trainingDataConfig=trainingDataConfig,
outputDataConfig=outputDataConfig,
customizationType=customizationType
)
jobArn = response_ft['jobArn']
```
------
## Monitore seu trabalho de treinamento em RFT
O Amazon Bedrock fornece monitoramento em tempo real com gráficos e métricas visuais durante o treinamento de RFT. Essas métricas ajudam você a entender se o modelo converge adequadamente e se a função de recompensa orienta efetivamente o processo de aprendizado.
### Rastreamento do status do trabalho
Você pode monitorar o status do seu trabalho de RFT por meio das fases de validação e treinamento no console do Amazon Bedrock.
**Indicadores de conclusão:**
+ O status do trabalho muda para **Concluído** quando o treinamento é concluído com êxito
+ O modelo ARN personalizado fica disponível para implantação
+ As métricas de treinamento atingem limites de convergência
### Métricas de treinamento em tempo real
O Amazon Bedrock fornece monitoramento em tempo real durante o treinamento de RFT com gráficos visuais exibindo métricas de treinamento e validação.
#### Principais métricas de treinamento
+ **Perda de treinamento** - mede o quão bem o modelo está aprendendo com os dados de treinamento
+ **Estatísticas de recompensa de treinamento** - Mostra as pontuações de recompensa atribuídas por suas funções de recompensa
+ **Margem de recompensa** - mede a diferença entre recompensas de resposta boa e ruim
+ **Precisão nos conjuntos de treinamento e validação** - Mostra o desempenho do modelo nos dados de treinamento e retidos
**Categorias métricas detalhadas**
+ **Métricas de recompensa** — `critic/rewards/mean``critic/rewards/max`,, `critic/rewards/min` (distribuição de recompensas) e `val-score/rewards/mean@1` (recompensas de validação)
+ **Comportamento do modelo** — `actor/entropy` (variação da política; quanto maior, mais exploratório)
+ **Saúde do treinamento** — `actor/pg_loss` (perda do gradiente da política), `actor/pg_clipfrac` (frequência de atualizações recortadas) e `actor/grad_norm` (magnitude do gradiente)
+ **Características de resposta** —`prompt_length/mean`,`prompt_length/max`, `prompt_length/min` (estatísticas do token de entrada),`response_length/mean`,`response_length/max`, `response_length/min` (estatísticas do token de saída) e `response/aborted_ratio` (taxa de geração incompleta; 0 é igual a tudo concluído)
+ **Desempenho** — `perf/throughput` (produtividade do treinamento), `perf/time_per_step` (tempo por etapa do treinamento) e `timing_per_token_ms/*` (tempos de processamento por token)
+ **Uso de recursos** —`perf/max_memory_allocated_gb`, `perf/max_memory_reserved_gb` (memória da GPU) e `perf/cpu_memory_used_gb` (memória da CPU)
#### Visualização do progresso do treinamento
O console exibe gráficos interativos que são atualizados em tempo real à medida que seu trabalho de RFT progride. Essas visualizações podem ajudar você a:
+ Rastreie a convergência em direção ao desempenho ideal
+ Identifique possíveis problemas de treinamento com antecedência
+ Determine os pontos de parada ideais
+ Compare o desempenho em diferentes épocas
## Configurar inferência
Após a conclusão do trabalho, implante o modelo RFT para inferência sob demanda ou use o Provisioned Throughput para obter um desempenho consistente. Para configurar a inferência, consulte[Configurar a inferência para um modelo personalizado](model-customization-use.md).
Use **Test in Playground** para avaliar e comparar as respostas com o modelo básico. Para avaliar seu modelo RFT completo, consulte. [Avalie seu modelo de RFT](rft-evaluate-model.md)