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 fino de reforço (RFT) com modelos Amazon Nova

Visão geral do

O que é RFT?

O ajuste fino de reforço (RFT) melhora o desempenho do modelo treinando em sinais de feedback — pontuações mensuráveis ou recompensas que indicam o desempenho do modelo — em vez de 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 iterativamente o modelo para maximizar essas recompensas. Essa abordagem é excelente quando definir a saída exata correta é um desafio, mas você pode medir com segurança a qualidade da resposta.

Quando usar o RFT

Use o RFT quando puder definir critérios de sucesso claros e mensuráveis, mas tiver dificuldade em fornecer resultados exatos e corretos para o treinamento. É ideal para:

Melhores casos de uso

O RFT se destaca em domínios em que a qualidade da saída pode ser medida objetivamente, mas as respostas ideais são difíceis de definir com antecedência:

Modelos compatíveis

Nova Lite 2.0

Visão geral do formato de dados

Os dados de treinamento do RFT devem seguir o formato OpenAI Reinforcement Fine-Tuning. Cada exemplo de treinamento é um objeto JSON contendo:

Limitações atuais

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 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.

Recomendações de tamanho do conjunto de dados

Ponto de partida

Abordagem que prioriza a avaliação

Antes de investir em treinamento de RFT em grande escala, avalie o desempenho básico do seu modelo:

Começar com um pequeno conjunto de dados permite que você:

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:

Qualquer ambigüidade enganará o processo de treinamento e fará com que o modelo aprenda comportamentos não intencionais.

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:

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

Crie sua função de recompensa para um treinamento eficiente:

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 RFT oferece suporte a campos personalizados além dos requisitos principais do esquema (messagesereference_answer). Essa flexibilidade permite que você adicione quaisquer dados adicionais que sua função de recompensa precise para uma avaliação adequada.

Propriedades adicionais comuns

Exemplos de campos de metadados:

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

Receita de amostra

# 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: ""  
  
## 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 reward functions built into Verl [exact_match, code_executions, math_answers]  
      api_endpoint:  
        lambda_arn: ""  
        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  
    save_top_k: 5  
      
    # 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: 7e-7                       # 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 LLM como juiz

Visão geral do

Modelos de linguagem grande (LLMs) estão sendo cada vez mais usados como juízes em fluxos de trabalho de ajuste fino de 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 correçã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 programaticamente, como determinar se representações diferentes (como “1/3", “0,333" e “um terço”) são semanticamente equivalentes ou avaliar qualidades diferenciadas, como coerência e relevância. Ao usar juízes 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

Quando usar cada modo

Use um bom raciocínio para:

Use nenhum (omita reasoning_effort) ou baixo raciocínio para:

Compensações de custo e desempenho

Os modos de raciocínio mais altos aumentam:

Validando seu juiz de LLM

Antes de implantar um LLM-as-a-judge em produção, valide se as avaliações do modelo do juiz estão alinhadas com o julgamento humano. Isso envolve:

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 Lambda para juiz de LLM

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

Requisitos de configuração importantes:

Criação e execução de trabalhos

Começando um trabalho de treinamento

Use o modelo de caderno SageMaker AI Training Job: 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 oferece suporte ao treinamento Full-Rank e LoRa:

Treinamento de monitoramento

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

Métricas de recompensa

Comportamento do modelo

Treinamento em saúde

Características da resposta

Desempenho

Uso de recursos

Usando 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:

Limitações e melhores práticas

Limitações

Práticas recomendadas

Comece pequeno

Avaliação pré-treinamento

Monitore o treinamento

Otimize as funções de recompensa

Estratégia de iteração

Se as recompensas não estiverem melhorando:

Capacidades avançadas: Nova Forge

Para usuários que precisam de recursos avançados além das limitações padrão de RFT, o Nova Forge está disponível como uma oferta de serviço de assinatura paga:

O Nova Forge funciona com SageMaker IA HyperPod e foi projetado para ajudar clientes corporativos a criar seus próprios modelos de fronteira.

Comandos e dicas úteis

Uma coleção de scripts de observabilidade está disponível para ajudar a monitorar o status e o progresso dos trabalhos de treinamento.

Os scripts disponíveis são:

Instalação

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 para obter mais detalhes e exemplos.