# Treinamento para modelos do Amazon Nova
Treinamento

O treinamento de modelos do Amazon Nova nas tarefas de treinamento do SageMaker é compatível com o ajuste fino supervisionado (SFT) e o ajuste fino por reforço (RFT). Cada técnica atende a diferentes necessidades de personalização e pode ser aplicada a diferentes versões de modelos do Amazon Nova.

**Topics**
+ [

# Ajustar o Nova 2.0
](nova-fine-tune-2.md)
+ [

# Ajuste fino por reforço (RFT) com modelos do Amazon Nova
](nova-reinforcement-fine-tuning.md)

# Ajustar o Nova 2.0
Ajuste fino supervisionado (SFT)

## Pré-requisitos
Pré-requisitos

Antes de iniciar uma tarefa de treinamento, observe o seguinte:
+ Os buckets do Amazon S3 para armazenar seus dados de entrada e as saídas das tarefas de treinamento. Você pode usar um bucket para ambos ou buckets separados para cada tipo de dados. Seus buckets devem estar na mesma Região da AWS onde você cria todos os outros recursos para treinamento. Para ter mais informações, consulte [Criar um bucket de uso geral](https://docs.aws.amazon.com//AmazonS3/latest/userguide/create-bucket-overview.html).
+ Um perfil do IAM com permissões para executar uma tarefa de treinamento. Você deve anexar uma política do IAM com `AmazonSageMakerFullAccess`. Para obter mais informações, consulte [Como usar os perfis de execução do SageMaker AI](https://docs.aws.amazon.com//sagemaker/latest/dg/sagemaker-roles.html).
+ Fórmulas básicas do Amazon Nova, consulte [Obter fórmulas do Amazon Nova](nova-model-recipes.md#nova-model-get-recipes).

## O que é SFT?


O ajuste fino supervisionado (SFT) treina um modelo de linguagem usando pares de entrada-saída rotulados. O modelo aprende com exemplos de demonstração que consistem em prompts e respostas, refinando suas capacidades para se alinhar a tarefas específicas, instruções ou comportamentos desejados.

## Preparação de dados


### Visão geral


Os dados do Nova 2.0 SFT usam o mesmo formato de API Converse do Nova 1.0, com a adição de campos de conteúdo de raciocínio opcionais. Para obter as especificações completas do formato, consulte:
+ Conteúdo de raciocínio: [ReasoningContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ReasoningContentBlock.html)
+ Esquema da API Converse: [API Converse](https://docs.aws.amazon.com/bedrock/latest/userguide/conversation-inference-call.html)
+ Restrições do conjunto de dados: [Restrições do conjunto de dados](https://docs.aws.amazon.com/nova/latest/userguide/fine-tune-prepare-data-understanding.html)

### Recursos compatíveis

+ **Tipos de entrada**: texto, imagem ou vídeo em blocos de conteúdo do usuário
+ **Conteúdo do assistente**: respostas somente em texto e conteúdo de raciocínio
+ **Composição do conjunto de dados**: deve ser homogênea. Escolha uma destas opções:
  + Turnos somente com texto
  + Turnos de texto e imagem
  + Turnos de texto e vídeo (compatível com compreensão do documento)

**Importante**  
Você não pode misturar imagens e vídeos no mesmo conjunto de dados ou em turnos diferentes.

### Limitações atuais

+ **Conteúdo de raciocínio multimodal**: embora o formato Converse ofereça suporte a conteúdo de raciocínio baseado em imagem, o Nova 2.0 SFT é compatível somente com conteúdo de raciocínio baseado em texto no campo reasoningText.
+ **Conjuntos de validação**: você não pode fornecer um conjunto de dados de validação para SFT com o Nova 2.0. Se você fornecer um conjunto de dados de validação, ele será ignorado durante o treinamento. Essa limitação se aplica tanto aos envios de trabalhos programáticos quanto baseados na interface do usuário.

### Formatos de mídia compatíveis

+ **Imagens**: PNG, JPEG, GIF
+ **Vídeos**: MOV, MKV, MP4

### Exemplos de formato de dados


------
#### [ Text-only (Nova 1.0 compatible) ]

```
{  
  "schemaVersion": "bedrock-conversation-2024",  
  "system": [  
    {  
      "text": "You are a digital assistant with a friendly personality"  
    }  
  ],  
  "messages": [  
    {  
      "role": "user",  
      "content": [  
        {  
          "text": "What country is right next to Australia?"  
        }  
      ]  
    },  
    {  
      "role": "assistant",  
      "content": [  
        {  
          "text": "The closest country is New Zealand"  
        }  
      ]  
    }  
  ]  
}
```

------
#### [ Text with reasoning (Nova 2.0) ]

```
{  
  "schemaVersion": "bedrock-conversation-2024",  
  "system": [  
    {  
      "text": "You are a digital assistant with a friendly personality"  
    }  
  ],  
  "messages": [  
    {  
      "role": "user",  
      "content": [  
        {  
          "text": "What country is right next to Australia?"  
        }  
      ]  
    },  
    {  
      "role": "assistant",  
      "content": [  
        {  
          "reasoningContent": {  
            "reasoningText": {  
              "text": "I need to use my world knowledge of geography to answer this question"  
            }  
          }  
        },  
        {  
          "text": "The closest country to Australia is New Zealand, located to the southeast across the Tasman Sea."  
        }  
      ]  
    }  
  ]  
}
```

------
#### [ Image \$1 text input ]

```
{  
  "schemaVersion": "bedrock-conversation-2024",  
  "system": [  
    {  
      "text": "You are a helpful assistant."  
    }  
  ],  
  "messages": [  
    {  
      "role": "user",  
      "content": [  
        {  
          "image": {  
            "format": "jpeg",  
            "source": {  
              "s3Location": {  
                "uri": "s3://your-bucket/your-path/your-image.jpg",  
                "bucketOwner": "your-aws-account-id"  
              }  
            }  
          }  
        },  
        {  
          "text": "Which country is highlighted in the image?"  
        }  
      ]  
    },  
    {  
      "role": "assistant",  
      "content": [  
        {  
          "reasoningContent": {  
            "reasoningText": {  
              "text": "I will determine the highlighted country by examining its location on the map and using my geographical knowledge"  
            }  
          }  
        },  
        {  
          "text": "The highlighted country is New Zealand"  
        }  
      ]  
    }  
  ]  
}
```

------
#### [ Video \$1 text input ]

```
{  
  "schemaVersion": "bedrock-conversation-2024",  
  "system": [  
    {  
      "text": "You are a helpful assistant."  
    }  
  ],  
  "messages": [  
    {  
      "role": "user",  
      "content": [  
        {  
          "video": {  
            "format": "mp4",  
            "source": {  
              "s3Location": {  
                "uri": "s3://your-bucket/your-path/your-video.mp4",  
                "bucketOwner": "your-aws-account-id"  
              }  
            }  
          }  
        },  
        {  
          "text": "What is shown in this video?"  
        }  
      ]  
    },  
    {  
      "role": "assistant",  
      "content": [  
        {  
          "reasoningContent": {  
            "reasoningText": {  
              "text": "I will analyze the video content to identify key elements"  
            }  
          }  
        },  
        {  
          "text": "The video shows a map with New Zealand highlighted"  
        }  
      ]  
    }  
  ]  
}
```

------

## Chamada de ferramentas


O Nova 2.0 SFT é compatível com modelos de treinamento em padrões de chamada de ferramentas, permitindo que seu modelo aprenda quando e como invocar ferramentas ou funções externas.

### Formato de dados para chamada de ferramentas


Os dados de treinamento de chamada de ferramentas incluem uma seção `toolConfig` que define as ferramentas disponíveis, além de turnos de conversa que demonstram os padrões de uso da ferramenta.

**Exemplo de entrada**

```
{  
  "schemaVersion": "bedrock-conversation-2024",  
  "system": [  
    {  
      "text": "You are an expert in composing function calls."  
    }  
  ],  
  "toolConfig": {  
    "tools": [  
      {  
        "toolSpec": {  
          "name": "getItemCost",  
          "description": "Retrieve the cost of an item from the catalog",  
          "inputSchema": {  
            "json": {  
              "type": "object",  
              "properties": {  
                "item_name": {  
                  "type": "string",  
                  "description": "The name of the item to retrieve cost for"  
                },  
                "item_id": {  
                  "type": "string",  
                  "description": "The ASIN of item to retrieve cost for"  
                }  
              },  
              "required": [  
                "item_id"  
              ]  
            }  
          }  
        }  
      },  
      {  
        "toolSpec": {  
          "name": "getItemAvailability",  
          "description": "Retrieve whether an item is available in a given location",  
          "inputSchema": {  
            "json": {  
              "type": "object",  
              "properties": {  
                "zipcode": {  
                  "type": "string",  
                  "description": "The zipcode of the location to check in"  
                },  
                "quantity": {  
                  "type": "integer",  
                  "description": "The number of items to check availability for"  
                },  
                "item_id": {  
                  "type": "string",  
                  "description": "The ASIN of item to check availability for"  
                }  
              },  
              "required": [  
                "item_id", "zipcode"  
              ]  
            }  
          }  
        }  
      }  
    ]  
  },  
  "messages": [  
    {  
      "role": "user",  
      "content": [  
        {  
          "text": "I need to check whether there are twenty pieces of the following item available. Here is the item ASIN on Amazon: id-123. Please check for the zipcode 94086"  
        }  
      ]  
    },  
    {  
      "role": "assistant",  
      "content": [  
        {  
          "reasoningContent": {  
            "reasoningText": {  
              "text": "The user wants to check how many pieces of the item with ASIN id-123 are available in the zipcode 94086"  
            }  
          }  
        },  
        {  
          "toolUse": {  
            "toolUseId": "getItemAvailability_0",  
            "name": "getItemAvailability",  
            "input": {  
              "zipcode": "94086",  
              "quantity": 20,  
              "item_id": "id-123"  
            }  
          }  
        }  
      ]  
    },  
    {  
      "role": "user",  
      "content": [  
        {  
          "toolResult": {  
            "toolUseId": "getItemAvailability_0",  
            "content": [  
              {  
                "text": "[{\"name\": \"getItemAvailability\", \"results\": {\"availability\": true}}]"  
              }  
            ]  
          }  
        }  
      ]  
    },  
    {  
      "role": "assistant",  
      "content": [  
        {  
          "text": "Yes, there are twenty pieces of item id-123 available at 94086. Would you like to place an order or know the total cost?"  
        }  
      ]  
    }  
  ]  
}
```

### Requisitos de chamada de ferramentas


Ao criar dados de treinamento de chamada de ferramentas, siga estes requisitos:


| Requisito | Descrição | 
| --- | --- | 
| Posicionamento do ToolUse | O ToolUse deve aparecer somente nos turnos do assistente | 
| Posicionamento do ToolResult | O ToolResult deve aparecer somente nos turnos do usuário | 
| Formato do ToolResult | O ToolResult deve ser somente texto ou JSON; outras modalidades não são compatíveis com os modelos Nova | 
| Formato do inputSchema | O inputSchema dentro no toolSpec deve ser um objeto de esquema JSON válido | 
| Correspondência do toolUseId | Cada ToolResult deve fazer referência a um toolUseId válido de um assistente ToolUse anterior, com cada toolUseId usado exatamente uma vez por conversa | 

### Observações importantes

+ Garanta que suas definições de ferramentas sejam consistentes em todas as amostras de treinamento
+ O modelo aprende padrões de invocação de ferramentas das demonstrações que você fornece
+ Inclua diversos exemplos de quando usar cada ferramenta e de quando não usá-las

## Compreensão do documento


O Nova 2.0 SFT é compatível com o treinamento em tarefas baseadas em documentos, permitindo que seu modelo aprenda a analisar e responder a perguntas sobre documentos PDF.

### Formato de dados para compreensão do documento


Os dados de treinamento de compreensão de documentos incluem referências de documentos nos blocos de conteúdo do usuário, com o modelo aprendendo a extrair e raciocinar sobre o conteúdo do documento.

**Exemplo de entrada**

```
{  
{  
  "schemaVersion": "bedrock-conversation-2024",  
  "messages": [  
    {  
      "role": "user",  
      "content": [  
        {  
          "text": "What are the ways in which a customer can experience issues during checkout on Amazon?"  
        },  
        {  
          "document": {  
            "format": "pdf",  
            "source": {  
              "s3Location": {  
                "uri": "s3://my-bucket-name/path/to/documents/customer_service_debugging.pdf",  
                "bucketOwner": "123456789012"  
              }  
            }  
          }  
        }  
      ]  
    },  
    {  
      "role": "assistant",  
      "content": [  
        {
          "reasoningContent": {  
            "reasoningText": {  
              "text": "I need to find the relevant section in the document to answer the question."  
            }  
          }
        },
        {  
          "text": "Customers can experience issues with 1. Data entry, 2. Payment methods, 3. Connectivity while placing the order. Which one would you like to dive into?"  
        }   
      ]
    }  
  ]  
}
}
```

### Limitações de compreensão de documentos



| Limitação | Detalhes | 
| --- | --- | 
| Formato compatível | Somente arquivos PDF | 
| Tamanho máximo do documento | 10 MB | 
| Combinação de modalidades | Um exemplo pode ter documentos e texto, mas não pode ter documentos combinados com outras modalidades (imagens, vídeos) | 

### Práticas recomendadas da compreensão de documentos

+ Certifique-se de que os documentos estejam claramente formatados e que o texto possa ser extraído
+ Forneça diversos exemplos que abrangem diferentes tipos de documentos e formatos de perguntas
+ Inclua conteúdo de raciocínio para ajudar o modelo a aprender padrões de análise de documentos

## Compreensão de vídeos


O Nova 2.0 SFT é compatível com o treinamento em tarefas baseadas em vídeo, permitindo que seu modelo aprenda a analisar e responder a perguntas sobre conteúdo de vídeo.

### Formato de dados para a compreensão de vídeos


Os dados de treinamento de compreensão de vídeos incluem referências de vídeo nos blocos de conteúdo do usuário, com o modelo aprendendo a extrair informações e raciocinar sobre o conteúdo do vídeo.

**Exemplo de entrada**

```
  
{  
  "schemaVersion": "bedrock-conversation-2024",  
  "messages": [  
    {  
      "role": "user",  
      "content": [  
        {  
          "text": "What are the ways in which a customer can experience issues during checkout on Amazon?"  
        },  
        {  
          "video": {  
            "format": "mp4",  
            "source": {  
              "s3Location": {  
                "uri": "s3://my-bucket-name/path/to/videos/customer_service_debugging.mp4",  
                "bucketOwner": "123456789012"  
              }  
            }  
          }  
        }  
      ]  
    },  
    {  
      "role": "assistant",  
      "content": [  
        {
          "reasoningContent": {  
            "reasoningText": {  
              "text": "I need to find the relevant section in the video to answer the question."  
            }  
          }
        },
        {  
          "text": "Customers can experience issues with 1. Data entry, 2. Payment methods, 3. Connectivity while placing the order. Which one would you like to dive into?"  
        }   
      ]  
    }  
  ]  
}
```

### Limitações de compreensão de vídeo



| Limitação | Detalhes | 
| --- | --- | 
| Tamanho máximo do vídeo | 50 MB | 
| Duração máxima do vídeo | 15 minutos | 
| Vídeos por exemplo | É permitido somente um vídeo por exemplo. Inexistência de suporte para vários vídeos no mesmo exemplo | 
| Combinação de modalidades | Um exemplo pode ter vídeo e texto, mas não pode ter vídeo combinado com outras modalidades (imagens, documentos) | 

### Formatos de vídeo compatíveis

+ MOV
+ MKV
+ MP4

### Práticas recomendadas de compreensão de vídeos

+ Mantenha os vídeos concisos e focados no conteúdo relevante para sua tarefa
+ Certifique-se de que a qualidade do vídeo seja suficiente para que o modelo extraia informações significativas
+ Forneça perguntas claras que façam referência a aspectos específicos do conteúdo do vídeo
+ Inclua diversos exemplos que abrangem diferentes tipos de vídeo e formatos de perguntas

## Modos de raciocínio vs não raciocínio


### Compreensão do conteúdo de raciocínio


O conteúdo de raciocínio (também chamado de encadeamento de pensamentos) captura as etapas intermediárias do pensamento do modelo antes de gerar uma resposta final. Na vez do `assistant`, use o campo `reasoningContent` para incluir esses rastros de raciocínio.

**Como a perda é calculada**
+ **Com conteúdo de raciocínio**: a perda de treinamento inclui tokens de raciocínio e tokens de saída final
+ **Conteúdo sem raciocínio**: a perda de treinamento é calculada apenas com base nos tokens de saída final

Você pode incluir `reasoningContent` em vários turnos do assistente em conversas de vários turnos.

**Diretrizes de formatação**
+ Use texto simples para o conteúdo de raciocínio
+ Evite tags de marcação como `<thinking>` e `</thinking>`, a menos que sejam especificamente exigidas por sua tarefa
+ Garanta que o conteúdo do raciocínio seja claro e relevante para o processo de solução de problemas

### Quando habilitar o modo de raciocínio


Defina `reasoning_enabled: true` em sua configuração de treinamento quando:
+ Seus dados de treinamento tiverem tokens de raciocínio
+ Você quiser que o modelo gere tokens de pensamento antes de produzir as saídas finais
+ Você precisar melhorar o desempenho em tarefas complexas de raciocínio

É permitido treinar o Nova em um conjunto de dados sem raciocínio com `reasoning_enabled = true`. No entanto, isso pode fazer com que o modelo perca suas capacidades de raciocínio, pois o Nova aprende principalmente a gerar as respostas presentes nos dados sem aplicar o raciocínio. Se você deseja treinar o Nova em um conjunto de dados sem raciocínio, mas ainda espera tê-lo durante a inferência, você pode desabilitar o raciocínio durante o treinamento (`reasoning_enabled = false`), mas habilitá-lo para inferência. Embora essa abordagem permita que o raciocínio seja usado no momento da inferência, ela não garante um melhor desempenho em comparação com a inferência sem raciocínio. No geral, habilite o raciocínio para o treinamento e a inferência ao usar conjuntos de dados de raciocínio, e desabilite-o para ambos ao usar conjuntos de dados sem raciocínio.

Defina `reasoning_enabled: false` quando:
+ Seus dados de treinamento não tiverem tokens de raciocínio
+ Você estiver treinando em tarefas simples que não se beneficiam de etapas de raciocínio explícito
+ Você quiser otimizar a velocidade e reduzir o uso de tokens

### Geração de dados de raciocínio


Se seu conjunto de dados não tiver rastros de raciocínio, você poderá criá-los usando um modelo capaz de raciocinar, como o Nova Premier. Forneça seus pares de entrada-saída ao modelo e capture seu processo de raciocínio para criar um conjunto de dados com raciocínio aumentado.

### Uso de tokens de raciocínio para treinamento


Ao treinar com o modo de raciocínio habilitado, o modelo aprende a separar o raciocínio interno da resposta final. O processo de treinamento:
+ Organiza os dados como triplos: entrada, raciocínio e resposta
+ Otimiza usando a perda de previsão padrão do próximo token tanto dos tokens de raciocínio quanto dos tokens de resposta
+ Incentiva o modelo a raciocinar internamente antes de gerar respostas

### Conteúdo de raciocínio eficaz


O conteúdo de raciocínio de alta qualidade deve incluir:
+ Pensamentos e análises intermediários
+ Deduções lógicas e etapas de inferência
+ Abordagens de solução de problemas passo a passo
+ Conexões explícitas entre as etapas e conclusões

Isso ajuda o modelo a desenvolver a capacidade de “pensar antes de responder”.

## Diretrizes de preparação de conjuntos de dados


### Tamanho e qualidade

+ **Tamanho recomendado**: 2 mil a 10 mil exemplos
+ **Mínimo de exemplos**: 200
+ **Prioridade**: qualidade acima da quantidade. Garanta exemplos precisos e com anotação de qualidade
+ **Alinhamento de aplicações**: o conjunto de dados deve refletir de perto seus casos de uso de produção

### Diversidade


Inclua diversos exemplos que:
+ Abranjam toda a gama de entradas esperadas
+ Representem diferentes níveis de dificuldade
+ Incluam variações e casos de borda
+ Evitem o sobreajuste a padrões limitados

### Formatação de saída


Especifique claramente o formato de saída desejado nas respostas do assistente:
+ estruturas JSON
+ Tabelas
+ Formato CSV
+ Formatos personalizados específicos para sua aplicação

### Conversas em vários turnos


Para conjuntos de dados de várias turnos, lembre-se:
+ A perda é calculada somente nos turnos do assistente, não nos turnos do usuário
+ Cada resposta do assistente deve ser formatada corretamente
+ Mantenha a consistência nos turnos das conversas

### Lista de verificação de qualidade

+ Tamanho suficiente do conjunto de dados (2 mil a 10 mil exemplos)
+ Diversos exemplos que abrangem todos os casos de uso
+ Formatação de saída clara e consistente
+ Rótulos e anotações precisos
+ Representativo dos cenários de produção
+ Livre de contradições ou ambiguidades

### Carregar seus dados


Os conjuntos de dados devem ser enviados para um bucket que possa ser acessado pelas tarefas de treinamento do SageMaker. Para obter mais informações sobre como configurar as permissões corretas, consulte [Pré-requisitos](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-model-general-prerequisites.html).

## Início de uma tarefa de treinamento


### Seleção de hiperparâmetros e atualização da fórmula


A configuração do Nova 2.0 é basicamente a mesma do Nova 1.0. Depois que os dados de entrada forem enviados para o S3, use a fórmula das [Fórmulas do SageMaker HyperPod](https://github.com/aws/sagemaker-hyperpod-recipes/tree/main/recipes_collection/recipes/fine-tuning/nova) na pasta Ajuste fino. Para o Nova 2.0, confira a seguir alguns dos principais hiperparâmetros que você pode atualizar com base no caso de uso. O que se segue é um exemplo da fórmula de SFT PEFT do Nova 2.0. Para o URI da imagem do contêiner, use `708977205387.dkr.ecr.us-east-1.amazonaws.com/nova-fine-tune-repo:SM-TJ-SFT-V2-latest` para executar um trabalho de ajuste fino de SFT.

Use a v2.254.1 do SageMaker AI PySDK para obter compatibilidade total com o treinamento do Nova. A atualização do SDK para a v3.0 resultará em alterações disruptivas. A compatibilidade com a v3 do SageMaker AI PySDK estará disponível em breve.

**Exemplo de entrada **

```
!pip install sagemaker==2.254.1
```

```
run:  
  name: {peft_recipe_job_name}  
  model_type: amazon.nova-2-lite-v1:0:256k  
  model_name_or_path: {peft_model_name_or_path}  
  data_s3_path: {train_dataset_s3_path} # SageMaker HyperPod (SMHP) only and not compatible with SageMaker Training jobs. Note replace my-bucket-name with your real bucket name for SMHP job  
  replicas: 4                      # Number of compute instances for training, allowed values are 4, 8, 16, 32  
  output_s3_path: ""               # Output artifact path (Hyperpod job-specific; not compatible with standard SageMaker Training jobs). Note replace my-bucket-name with your real bucket name for SMHP job  
  
training_config:  
  max_steps: 10                   # Maximum training steps. Minimal is 4.  
  save_steps: 10                      # How many training steps the checkpoint will be saved. Should be less than or equal to max_steps  
  save_top_k: 1                    # Keep top K best checkpoints. Note supported only for SageMaker HyperPod jobs. Minimal is 1.  
  max_length: 32768                # Sequence length (options: 8192, 16384, 32768 [default], 65536)  
  global_batch_size: 32            # Global batch size (options: 32, 64, 128)  
  reasoning_enabled: true          # If data has reasoningContent, set to true; otherwise False  
  
  lr_scheduler:  
    warmup_steps: 15               # Learning rate warmup steps. Recommend 15% of max_steps  
    min_lr: 1e-6                   # Minimum learning rate, must be between 0.0 and 1.0  
  
  optim_config:                    # Optimizer settings  
    lr: 1e-5                       # Learning rate, must be between 0.0 and 1.0  
    weight_decay: 0.0              # L2 regularization strength, must be between 0.0 and 1.0  
    adam_beta1: 0.9                # Exponential decay rate for first-moment estimates, must be between 0.0 and 1.0  
    adam_beta2: 0.95               # Exponential decay rate for second-moment estimates, must be between 0.0 and 1.0  
  
  peft:                            # Parameter-efficient fine-tuning (LoRA)  
    peft_scheme: "lora"            # Enable LoRA for PEFT  
    lora_tuning:  
      alpha: 64                    # Scaling factor for LoRA weights ( options: 32, 64, 96, 128, 160, 192),  
      lora_plus_lr_ratio: 64.0
```

A fórmula também contém basicamente os mesmos hiperparâmetros do Nova 1.0. Os principais hiperparâmetros são:
+ `max_steps`: número de etapas para as quais você deseja executar o trabalho. Geralmente, para uma época (uma execução em todo o conjunto de dados), o número de etapas = número de amostras de dados/tamanho global do lote. Quanto maior o número de etapas e menor o tamanho do lote global, mais tempo o trabalho levará para ser executado.
+ `reasoning_enabled`: controla o modo de raciocínio para seu conjunto de dados. Opções:
  + `true`: habilita o modo de raciocínio (equivalente ao raciocínio elevado)
  + `false`: desabilita o modo de raciocínio

  Observação: para o SFT, não há controle granular sobre os níveis de esforço de raciocínio. A configuração `reasoning_enabled: true` habilita a capacidade total de raciocínio.
+ `peft.peft_scheme`: definir como “lora” habilita o ajuste fino baseado em PEFT. Defini-lo como nulo (sem aspas) habilita o ajuste fino de full-rank.

### Iniciar a tarefa de treinamento


```
from sagemaker.pytorch import PyTorch  
  
# define OutputDataConfig path  
if default_prefix:  
    output_path = f"s3://{bucket_name}/{default_prefix}/{sm_training_job_name}"  
else:  
    output_path = f"s3://{bucket_name}/{sm_training_job_name}"  

output_kms_key = "<KMS key arn to encrypt trained model in Amazon-owned S3 bucket>" # optional, leave blank for Amazon managed encryption
  
recipe_overrides = {  
    "run": {  
        "replicas": instance_count,  # Required  
        "output_s3_path": output_path  
    },  
}  
  
estimator = PyTorch(  
    output_path=output_path,  
    base_job_name=sm_training_job_name,  
    role=role,  
    disable_profiler=True,  
    debugger_hook_config=False,  
    instance_count=instance_count,  
    instance_type=instance_type,  
    training_recipe=training_recipe,  
    recipe_overrides=recipe_overrides,  
    max_run=432000,  
    sagemaker_session=sagemaker_session,  
    image_uri=image_uri,
    output_kms_key=output_kms_key,
    tags=[  
        {'Key': 'model_name_or_path', 'Value': model_name_or_path},  
    ]  
)  
  
print(f"\nsm_training_job_name:\n{sm_training_job_name}\n")  
print(f"output_path:\n{output_path}")
```

```
from sagemaker.inputs import TrainingInput  
  
train_input = TrainingInput(  
    s3_data=train_dataset_s3_path,  
    distribution="FullyReplicated",  
    s3_data_type="Converse",  
)  
  
estimator.fit(inputs={"validation": val_input}, wait=False)
```

**nota**  
A aprovação de um conjunto de dados de validação não é compatível com o ajuste fino supervisionado do Nova 2.0.

Para começar a tarefa:
+ Atualize a fórmula com seus caminhos e hiperparâmetros do conjunto de dados
+ Execute as células especificadas no caderno para enviar a tarefa de treinamento

O caderno gerencia o envio de tarefas e fornece o rastreamento de status.

# Ajuste fino por reforço (RFT) com modelos do Amazon Nova
Ajuste fino por reforço (RFT)

## Visão geral


**O que é o RFT?**

O ajuste fino por reforço (RFT) melhora o desempenho do modelo treinando com sinais de feedback (pontuações mensuráveis ou recompensas que indicam o desempenho do modelo) em vez de com respostas corretas exatas. Ao contrário do ajuste fino supervisionado que aprende com pares de entrada e saída, o RFT usa funções de recompensa para avaliar as respostas do modelo e otimiza de forma iterativa o modelo para maximizar essas recompensas. Essa abordagem se destaca quando a definição exata da saída correta é difícil, mas a avaliação da qualidade da resposta é confiável.

**Quando usar o RFT**

Use o RFT quando você puder definir critérios de sucesso claros e mensuráveis, mas tiver dificuldade em fornecer resultados exatos e corretos para o treinamento. É ideal para:
+ Tarefas em que a qualidade é subjetiva ou multifacetada (escrita criativa, otimização de código, raciocínio complexo)
+ Cenários com várias soluções válidas em que algumas são claramente melhores do que outras
+ Aplicações que exigem aprimoramento iterativo, personalização ou adesão a regras de negócios complexas
+ Casos em que coletar exemplos rotulados de alta qualidade é caro ou impraticável

**Melhores casos de uso**

O RFT se destaca em domínios em que a qualidade da saída pode ser avaliada objetivamente, mas as respostas ideais são difíceis de definir de antemão:
+ Resolução de problemas matemáticos e geração de código
+ Raciocínio científico e análise de dados estruturados
+ Tarefas que exigem raciocínio passo a passo ou solução de problemas em vários turnos
+ Aplicações que equilibram vários objetivos (precisão, eficiência, estilo)
+ Cenários em que o sucesso pode ser verificado de forma programática por meio de resultados de execução ou métricas de desempenho

**Modelos compatíveis**

Nova Lite 2.0

## Visão geral do formato de dados


Os dados de treinamento do RFT devem seguir o [formato](https://platform.openai.com/docs/api-reference/fine-tuning/reinforcement-input) de ajuste fino por reforço da OpenAI. Cada exemplo de treinamento é um objeto JSON que contém:
+ Uma matriz de `messages` com turnos de conversação usando os perfis `system` e `user`
+ Um campo `reference_answer` contendo o resultado esperado ou os critérios de avaliação para o cálculo da recompensa

**Limitações atuais**
+ Somente texto

### Exemplos de formato de dados


Cada exemplo deve estar em uma única linha no arquivo JSONL, com um objeto JSON por linha.

------
#### [ Chemistry problem ]

```
{
  "id": "chem-01",
  "messages": [
    {
      "role": "system",
      "content": "You are a helpful chemistry assistant"
    },
    {
      "role": "user",
      "content": "Calculate the molecular weight of caffeine (C8H10N4O2)"
    }
  ],
  "reference_answer": {
    "molecular_weight": 194.19,
    "unit": "g/mol",
    "calculation": "8(12.01) + 10(1.008) + 4(14.01) + 2(16.00) = 194.19"
  }
}
```

------
#### [ Math problem ]

```
{
  "id": "sample-001",  // Optional
  "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"]
  }
}
```

------
#### [ Code problem ]

```
{
  "id": "code-002",
  "messages": [
    {
      "role": "system",
      "content": "You are a helpful programming assistant"
    },
    {
      "role": "user",
      "content": "Write a Python function that reverses a string without using built-in reverse methods"
    }
  ],
  "reference_answer": {
    "code": "def reverse_string(s):  \n    result = ''  \n    for i in range(len(s) - 1, -1, -1):  \n        result += s[i]  \n    return result",
    "test_cases": [
      {
        "input": "hello",
        "expected_output": "olleh"
      },
      {
        "input": "",
        "expected_output": ""
      },
      {
        "input": "a",
        "expected_output": "a"
      },
      {
        "input": "Python123",
        "expected_output": "321nohtyP"
      }
    ],
    "all_tests_pass": true
  }
}
```

------

O campo `reference_answer` 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. Ele não se limita a resultados estruturados. Ele pode conter qualquer formato que ajude sua função de recompensa a avaliar a qualidade.

## Recomendações de tamanho do conjunto de dados


**Ponto de partida**
+ Mínimo de 100 exemplos de treinamento
+ Mínimo de 100 exemplos de avaliação

**Abordagem que prioriza a avaliação**

Antes de investir em treinamento de RFT em grande escala, avalie o desempenho básico do seu modelo:
+ **Alto desempenho (>95% de recompensa)**: o RFT pode ser desnecessário, pois seu modelo já tem um bom desempenho
+ **Desempenho muito baixo (0% de recompensa)**: mude primeiro para o SFT para estabelecer os recursos básicos
+ **Desempenho moderado**: o RFT provavelmente é apropriado

Começar com um pequeno conjunto de dados permite que você:
+ Valide que sua função de recompensa está livre de bugs
+ Confirme que o RFT é a abordagem certa para o seu caso de uso
+ Identifique e corrija problemas com antecedência
+ Teste o fluxo de trabalho antes de aumentar a escala verticalmente

Depois de validado, você pode expandir para conjuntos de dados maiores para melhorar ainda mais o desempenho.

## Características dos dados de treinamento efetivos


**Clareza e consistência**

Bons exemplos de RFT exigem dados de entrada claros e inequívocos que permitam o cálculo preciso da recompensa em diferentes saídas do modelo. Evite ruídos em seus dados, incluindo:
+ Formatação inconsistente
+ Rótulos ou instruções contraditórios
+ Prompts ambíguos
+ Respostas de referência conflitantes

Qualquer ambiguidade induzirá o processo de treinamento ao erro, fazendo com que o modelo aprenda comportamentos indesejados.

**Diversidade**

Seu conjunto de dados deve capturar toda a diversidade de casos de uso de produção para garantir um desempenho robusto no mundo real. Inclusão:
+ Diferentes formatos de entrada e casos de borda
+ Mapear padrões reais de uso em produção de logs e analytics de usuários
+ Amostra de todos os tipos de usuários, regiões geográficas e variações sazonais
+ Incluir níveis de dificuldade de problemas simples a complexos

**Considerações sobre a função de recompensa**

Projete sua função de recompensa para um treinamento eficiente:
+ Execute em segundos (não em minutos)
+ Paralelize de forma eficaz com o Lambda
+ Retorne pontuações consistentes e confiáveis
+ Lide com diferentes tipos de saídas de modelo de forma resiliente

As funções de recompensa rápidas e escaláveis permitem uma iteração rápida e uma experimentação econômica.

## Propriedades adicionais


O formato de dados de RFT é compatível com campos personalizados além dos requisitos principais do esquema (`messages` e `reference_answer`). Essa flexibilidade permite que você adicione quaisquer dados adicionais de que sua função de recompensa precise para uma avaliação adequada.

**nota**  
Você não precisa configurar isso em sua fórmula. O formato de dados é inerentemente compatível com campos adicionais. Basta incluí-los em seus dados de treinamento JSON e eles serão passados para sua função de recompensa no campo `metadata`.

**Propriedades comuns adicionais**

Campos de metadados de exemplo:
+ `task_id`: identificador único de rastreamento
+ `difficulty_level`: indicador de complexidade do problema
+ `domain`: área ou categoria do assunto
+ `expected_reasoning_steps`: número de etapas na solução

**Exemplo com propriedades adicionais**

```
{
  "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
}
```

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.

## Configuração do treinamento


**Exemplo de fórmula**

```
# Note:
# This recipe can run on p5.48xlarge and p5en.48xlarge instance types.
run:
  name: "my-rft-run"                           # Unique run name (appears in logs/artifacts).
  model_type: amazon.nova-2-lite-v1:0:256k
  model_name_or_path: nova-lite-2/prod
  data_s3_path: s3://<bucket>/<data file>      # Training dataset in JSONL;
  replicas: 4
  reward_lambda_arn: arn:aws:lambda:<region>:<account-id>:function:<function-name>

  ## MLFlow configs
  mlflow_tracking_uri: "" # Required for MLFlow
  mlflow_experiment_name: "my-rft-experiment" # Optional for MLFlow. Note: leave this field non-empty
  mlflow_run_name: "my-rft-run" # Optional for MLFlow. Note: leave this field non-empty

## SMTJ GRPO Training specific configs
training_config:
  max_length: 8192                              # Context window (tokens) for inputs+prompt;
  global_batch_size: 16                         # Total samples per optimizer step across all replicas (16/32/64/128/256).
  reasoning_effort: high                        # Enables reasoning mode high / low / or null for non-reasoning

  rollout:                                      # How responses are generated for GRPO/advantage calc.
    advantage_strategy:
      number_generation: 2                      # N samples per prompt to estimate advantages (variance vs cost).
    generator:
      max_new_tokens: 6000                      # Cap on tokens generated per sample
      set_random_seed: true                     # Seed generation for reproducibility across runs.
      temperature: 1                            # Softmax temperature;
      top_k: 1                                  # Sample only from top-K logits
    rewards:
      preset_reward_function: null              # Usage of preset reward functions [exact_match]
      api_endpoint:
        lambda_arn: arn:aws:lambda:<region>:<account-id>:function:<function-name>
        lambda_concurrency_limit: 12             # Max concurrent Lambda invocations (throughput vs. throttling).

  trainer:
    max_steps: 2                                 # Steps to train for. One Step = global_batch_size
    save_steps: 5
    test_steps: 1

    # RL parameters
    ent_coeff: 0.0                              # A bonus added to the policy loss that rewards higher-output entropy.
    kl_loss_coef: 0.001                         # Weight on the KL penalty between the actor (trainable policy) and a frozen reference model

    optim_config:                    # Optimizer settings
        lr: 5e-5                       # Learning rate
        weight_decay: 0.0              # L2 regularization strength (0.0–1.0)
        adam_beta1: 0.9
        adam_beta2: 0.95

    peft:                            # Parameter-efficient fine-tuning (LoRA)
        peft_scheme: "lora"            # Enable LoRA for PEFT
        lora_tuning:
            alpha: 32
            lora_plus_lr_ratio: 64.0     # LoRA+ learning rate scaling factor (0.0–100.0)
```

## Treinamento de RFT usando o LLM como avaliador


### Visão geral


Os grandes modelos de linguagem (LLMs) estão sendo cada vez mais usados como avaliadores em fluxos de trabalho de ajuste fino por reforço (RFT), fornecendo sinais de recompensa automatizados que orientam a otimização do modelo. Nessa abordagem, um LLM avalia os resultados do modelo em relação a critérios específicos, seja avaliando a exatidão, a qualidade, a aderência ao estilo ou a equivalência semântica, e atribui recompensas que impulsionam o processo de aprendizado por reforço.

Isso é particularmente valioso para tarefas em que as funções de recompensa tradicionais são difíceis de definir de forma programática, como determinar se representações diferentes (como “1/3”, “0,333” e “um terço”) são semanticamente equivalentes, ou avaliar qualidades subjetivas, como coerência e relevância. Ao usar avaliadores baseados em LLM como funções de recompensa, você pode escalar o RFT para domínios complexos sem exigir anotações humanas extensivas, permitindo uma iteração rápida e a melhoria contínua de seus modelos em diversos casos de uso, além dos problemas tradicionais de alinhamento.

### Seleção do modo de raciocínio


**Modos disponíveis**
+ none: sem raciocínio (omita o campo reasoning\$1effort)
+ low: sobrecarga mínima de raciocínio
+ high: capacidade máxima de raciocínio (padrão quando reasoning\$1effort é especificado)

**nota**  
Não há a opção medium para o RFT. Se o campo reasoning\$1effort estiver ausente da sua configuração, o raciocínio será desabilitado. Quando o raciocínio está habilitado, você deve definir `max_new_tokens` como 32.768 para acomodar saídas de raciocínio estendidas.

**Quando usar cada modo**

Use o raciocínio high para:
+ Tarefas analíticas complexas
+ Resolução de problemas matemáticos
+ Dedução lógica de várias etapas
+ Tarefas em que o pensamento passo a passo agrega valor

Use raciocínio none (omita reasoning\$1effort) ou low para:
+ Consultas factuais simples
+ Classificações diretas
+ Velocidade e otimização de custos
+ Respostas diretas a perguntas

**Compensações de custo e desempenho**

Os modos de raciocínio mais altos aumentam:
+ O tempo e o custo do treinamento
+ A latência e o custo da inferência
+ A capacidade de modelar para tarefas complexas de raciocínio

### Validação do seu LLM como avaliador


Antes de implantar um LLM como avaliador na produção, valide se as avaliações do modelo do avaliador estão alinhadas com a avaliação humana. Isso envolve:
+ Avaliar as taxas de concordância entre o LLM como avaliador e os avaliadores humanos em amostras representativas de sua tarefa
+ Garantir que a concordância do LLM com humanos atinja ou supere as taxas de concordância entre humanos
+ Identificar possíveis vieses no modelo do avaliador
+ Criar confiança de que o sinal de recompensa guia seu modelo na direção pretendida

Essa etapa de validação ajuda a garantir que o processo de avaliação automatizado produza modelos que atendam aos seus critérios de qualidade de produção.

### Configuração do Lambda para o LLM como avaliador


Usar um LLM como avaliador é uma extensão do uso das funções do Lambda para aprendizado por reforço com recompensas verificáveis (RLVR). Dentro da função do Lambda, você faz uma chamada para um dos modelos hospedados no Amazon Bedrock.

**Requisitos de configuração importantes:**


| Configuração | Requisito | Detalhes | 
| --- | --- | --- | 
| Throughput do Amazon Bedrock | Cota suficiente | Certifique-se de que sua cota de throughput para o modelo do Amazon Bedrock usado seja suficiente para sua workload de treinamento | 
| tempo limite do Lambda | Tempo limite estendido | Configure o tempo limite da função do Lambda em até o máximo de 15 minutos. A configuração padrão é de 3 segundos, o que é insuficiente para as respostas dos modelos do Amazon Bedrock | 
| Simultaneidade do Lambda | Aumento da simultaneidade | O Lambda é invocado paralelamente durante o treinamento. Aumente a simultaneidade para maximizar o throughput disponível | 
| Configuração de fórmula | Correspondência das configurações do Lambda | O limite de simultaneidade deve ser configurado em sua fórmula | 

## Criação e execução de tarefas


**Início de uma tarefa de treinamento**

Use o modelo do caderno de tarefas de treinamento do SageMaker: [https://docs.aws.amazon.com/sagemaker/latest/dg/nova-fine-tuning-training-job.html#nova-model-training-jobs-notebook](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-fine-tuning-training-job.html#nova-model-training-jobs-notebook)

**Requisitos de instância**

O contêiner é compatível com o treinamento de full-rank e LoRA:
+ **Treinamento LoRA**: 2/4/6/8 × instâncias p5.48xlarge ou p5en.48xlarge
+ **Treinamento de full-rank**: 2/4/6/8 × instâncias p5.48xlarge (obrigatório)

## Monitoramento do treinamento


Os logs de treinamento incluem métricas abrangentes em cada etapa. Principais categorias métricas:

**Métricas de recompensa**
+ `critic/rewards/mean`, `critic/rewards/max`, `critic/rewards/min`: distribuição de recompensas
+ `val-score/rewards/mean@1`: recompensas de validação

**Comportamento do modelo**
+ `actor/entropy`: variação da política (maior = mais exploratória)

**Integridade do treinamento**
+ `actor/pg_loss`: perda de gradiente de política
+ `actor/pg_clipfrac`: frequência de atualizações cortadas
+ `actor/grad_norm`: magnitude do gradiente

**Características das respostas**
+ `prompt_length/mean`, `prompt_length/max`, `prompt_length/min`: estatísticas dos tokens de entrada
+ `response_length/mean`, `response_length/max`, `response_length/min`: estatísticas dos tokens de saída
+ `response/aborted_ratio`: taxa de geração incompleta (0 = tudo concluído)

**desempenho**
+ `perf/throughput`: throughput do treinamento
+ `perf/time_per_step`: tempo por etapa de treinamento
+ `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
+ `perf/cpu_memory_used_gb`: memória da CPU

## Uso de modelos ajustados


Após a conclusão do treinamento, o ponto de verificação final do modelo é salvo no local de saída especificado. O caminho do ponto de verificação está disponível em:
+ Logs de treinamento
+ Arquivo `manifest.json` no local de saída do Amazon S3 (definido por `output_s3_uri` em seu caderno)

## Limitações e práticas recomendadas


**Limitações**
+ **Tempo limite do Lambda**: as funções de recompensa devem ser concluídas em até 15 minutos (evita processos descontrolados e gerencia custos)
+ **Somente um único turno**: conversas em vários turnos não são compatíveis
+ **Requisitos de dados**: precisa de diversidade suficiente; tem dificuldades com recompensas esparsas (<5% de exemplos positivos)
+ **Custo computacional**: mais caro do que o ajuste fino supervisionado
+ **Nenhum dado multimodal**: somente o tipo de dados de texto é compatível

**Práticas recomendadas**

**Comece devagar**
+ Comece com 100 a 200 exemplos
+ Valide a exatidão da função de recompensa
+ Escale gradualmente com base nos resultados

**Avaliação pré-treinamento**
+ Teste o desempenho do modelo de linha de base antes do RFT
+ Se as recompensas forem consistentemente de 0%, use o SFT primeiro para estabelecer as capacidades básicas
+ Se as recompensas forem >95%, o RFT poderá ser desnecessário

**Monitorar o treinamento**
+ Acompanhe as pontuações médias e a distribuição das recompensas
+ Observe o sobreajuste (as recompensas de treinamento aumentam enquanto as recompensas de validação diminuem)
+ Procure padrões de atenção:
  + Recompensas se estabilizando abaixo de 0,15
  + Aumento da variação da recompensa ao longo do tempo
  + Queda no desempenho de validação

**Otimizar as funções de recompensa**
+ Execute em segundos (não em minutos)
+ Minimize as chamadas de API externas
+ Use algoritmos eficientes
+ Implemente o tratamento adequado de erros
+ Aproveite as vantagens da escalabilidade paralela do Lambda

**Estratégia de iteração**

Se as recompensas não estiverem melhorando:
+ Ajuste o design da função de recompensa
+ Aprimore a diversidade do conjunto de dados
+ Adicione mais exemplos representativos
+ Verifique se os sinais de recompensa são claros e consistentes

## Recursos avançados: Nova Forge


Para usuários que precisam de recursos avançados além das limitações padrão do RFT, o Nova Forge está disponível como uma oferta de serviço de assinatura paga:
+ Compatível com conversa de vários turnos
+ Funções de recompensa com mais de 15 minutos de tempo de execução
+ Algoritmos adicionais e opções de ajuste
+ Modificações personalizadas das fórmulas de treinamento
+ Técnicas de IA de última geração

O Nova Forge é executado no SageMaker HyperPod e foi projetado para ajudar clientes empresariais a criar seus próprios modelos de fronteira.

## Comandos e dicas úteis


Uma coleção de [scripts de observabilidade](https://github.com/aws-samples/amazon-nova-samples/tree/main/customization/SageMakerUilts/SageMakerJobsMonitoring) está disponível para ajudar a monitorar o status e o progresso das tarefas de treinamento.

Os scripts disponíveis são:
+ Habilitar notificações por e-mail para atualizações do status da tarefa de treinamento
+ Obter estimativas de tempo de treinamento com base nas configurações da tarefa
+ Obter estimativas da duração do treinamento para tarefas em andamento

**Instalação**

**nota**  
Certifique-se de atualizar suas credenciais da AWS antes de usar qualquer um dos scripts a seguir.

```
pip install boto3
git clone https://github.com/aws-samples/amazon-nova-samples.git
cd amazon-nova-samples/customization/SageMakerUilts/SageMakerJobsMonitoring/
```

**Uso básico**

```
# Enabling email notifications for training job status updates
python enable_sagemaker_job_notifs.py --email test@amazon.com test2@gmail.com --region us-east-1 --platform SMTJ

Creating resources........
Please check your email for a subscription confirmation email, and click 'Confirm subscription' to start receiving job status email notifications!
You'll receive the confirmation email within a few minutes.
```

```
# Obtaining training time estimates based on job configurations
python get_training_time_estimate.py
```

```
# Obtaining approximations for how long training is expected to take for in-progress jobs
python get-training-job-progress.py --region us-east-1 --job-name my-training-job --num-dataset-samples 1000
```

Consulte [aqui](https://github.com/aws-samples/amazon-nova-samples/blob/main/customization/SageMakerUilts/SageMakerJobsMonitoring/README.md) para obter mais detalhes e exemplos.