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

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 (STF) 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 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 for possível definir critérios de sucesso claros e mensuráveis, mas for difícil fornecer resultados exatos e corretos para treinamento. O RFT é ideal para:

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:

Modelos compatíveis

Nova Lite 2.0

Visão geral do formato de dados

Os dados de treinamento do RFT devem seguir o formato de ajuste fino por reforço da OpenAI. Cada exemplo de treinamento é um objeto JSON que contém:

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

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

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

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

Propriedades comuns adicionais

Campos de metadados de exemplo:

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, p5e.48xlarge, and p5en.48xlarge instance types.
run:
  name: "my-rft-run"                           # Unique run name (appears in logs and 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 format.
  replicas: 4                                   # Number of total training instances.
  generation_replicas: 2                        # Number of total instances dedicated to response generation.
  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 RFT training configs
training_config:
  max_length: 8192                              # Context window (tokens) for inputs and prompt.
  global_batch_size: 32                         # Total samples per optimizer step across all replicas (16/32/64/128/256).
  reasoning_effort: high                        # Reasoning mode: high, low, or null for non-reasoning.

  data:
    shuffle: true                               # Shuffle training data each epoch.

  rollout:                                      # Controls how responses are generated for advantage calculation.
    rollout_strategy:
      type: off_policy_async                    # Asynchronous rollout for higher throughput.
      age_tolerance: 2                          # Maximum policy age before regeneration.
    advantage_strategy:
      number_generation: 4                      # Samples per prompt to estimate advantages (higher = lower variance but higher 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 for sampling.
    rewards:
      preset_reward_function: null              # Preset reward functions: exact_match or null for custom.
      api_endpoint:
        lambda_arn: arn:aws:lambda:<region>:<account-id>:function:<function-name>
        lambda_concurrency_limit: 12             # Max concurrent Lambda invocations (throughput vs. throttling).
        lambda_batch_size: 128                  # Number of samples per Lambda invocation.

  trainer:
    max_steps: 2                                # Steps to train for. One step = global_batch_size samples.
    save_steps: 5                               # Save a checkpoint every N steps.
    test_steps: 1                               # Run validation every N reference model updates.
    refit_freq: 4                               # Frequency of reference model updates.
    clip_ratio_high: 0.2                        # PPO clip ratio for policy updates.
    loss_scale: 1.0                             # Scaling factor for the policy loss.

    # RL parameters
    ent_coeff: 0.0                              # Entropy bonus added to the policy loss (higher = more exploration).
    kl_loss_coef: 0.0                           # Weight on the KL penalty between the current and reference policy.

    optim_config:                               # Optimizer settings.
        lr: 1e-6                                # Learning rate.
        weight_decay: 0.0                       # L2 regularization strength (0.0 to 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: 64                           # LoRA scaling factor.
            lora_plus_lr_ratio: 64.0            # LoRA+ learning rate scaling factor (0.0 to 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

Quando usar cada modo

Use o raciocínio high para:

Use raciocínio none (omita reasoning_effort) ou low para:

Compensações de custo e desempenho

Os modos de raciocínio mais altos aumentam:

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:

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:

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

Requisitos de instância

O contêiner é compatível com o treinamento de full-rank e LoRA:

Monitoramento do treinamento

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

Métricas de recompensa

Comportamento do modelo

Integridade do treinamento

Características das respostas

desempenho

Uso de recursos

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:

Limitações e práticas recomendadas

Limitações

Práticas recomendadas

Comece devagar

Avaliação pré-treinamento

Monitorar o treinamento

Otimizar as funções de recompensa

Estratégia de iteração

Se as recompensas não estiverem melhorando:

Aprendizagem com currículo adaptativo

A aprendizagem com currículo adaptativo é um atributo opcional que seleciona dinamicamente quais prompts de treinamento devem ser apresentadas ao modelo durante o RFT. Em vez de treinar de modo uniforme em todos os prompts, o treinador usa o próprio modelo para prever a dificuldade imediata e seleciona os prompts dentro da faixa de dificuldade produtiva, na qual o modelo às vezes é bem-sucedido e às vezes não. Isso maximiza a variância de resultados dentro de cada grupo de rollout de GRPO, produzindo um sinal de vantagem maior, convergência mais rápida e mais estabilidade no treinamento por reforço ao reduzir as ruidosas atualizações baseadas em gradiente, geradas por prompts fáceis demais ou difíceis demais.

Como funciona o currículo adaptativo

Quando o currículo adaptativo está habilitado, o ciclo de treinamento adiciona uma fase de previsão e seleção antes de cada etapa do rollout:

Quando usar currículo adaptativo

O currículo adaptativo é mais eficaz nos seguintes cenários:

Configurar currículo adaptativo

Adicione o bloco adaptive_curriculum abaixo de trainer em seu roteiro para habilitar a aprendizagem de currículo adaptativo:

training_config:
  trainer:
    adaptive_curriculum:
      enable: true                               # Enable adaptive curriculum prompt selection.
      selection_pool_multiplier: 8               # Score 8 x global_batch_size candidates, keep best global_batch_size.
      prediction_mode: pass_rate                 # "pass_rate" for discrete rewards; "spread" for continuous rewards.
      exemplar_history_steps: 1                  # Previous training steps kept in the rolling exemplar history buffer.
      reinforce_coef: 0.01                       # Scale factor for the REINFORCE loss that trains the predictor (0 disables).
      predictor_prompt_column: predictor_prompt  # Dataset field with clean problem text used by the predictor.
      selection_lookahead_steps: 4               # Future training batches pre-approved per curriculum screening pass.

A tabela a seguir descreve resumidamente cada parâmetro do currículo adaptativo:

Recomendações para conjuntos de dados de longos

O currículo adaptativo funciona executando um preditor de taxa de aprovação leve em um conjunto de prompts candidatos e selecionando o lote mais produtivo para rollout. Quando o max_prompt_length é curto (alguns milhares de tokens ou menos), o preditor é executado em alguns segundos por passada de triagem e a sobrecarga do currículo é desprezível. Quando o tamanho do prompt aumenta, o tempo de inferência do preditor aumenta quadraticamente, grosso modo, (atenção é O(n²) em tamanho da sequência), assim, a triagem pode dominar o tempo da etapa nos conjuntos de dados nos quais os prompts excedem 8.000 tokens aproximadamente.

As configurações abaixo mantêm o currículo adaptativo utilizável e econômico em conjuntos de dados de contexto longo. Aplique-os juntos; eles abordam diferentes componentes do custo de triagem.

Exemplo de configuração ajustada para um conjunto de dados de contexto longo (de 24 K a 32 K prompts de token aproximadamente):

training_config:
  max_length: 32768
  global_batch_size: 32

  trainer:
    adaptive_curriculum:
      enable: true
      selection_pool_multiplier: 4        # Smaller pool keeps predictor prefill bounded.
      selection_lookahead_steps: 1        # Predictor runs once per training step.
      prediction_mode: pass_rate
      exemplar_history_steps: 1
      reinforce_coef: 0.01
      predictor_prompt_column: predictor_prompt

Preparação de dados para currículo adaptativo

Ao usar currículo adaptativo, os dados de treinamento devem incluir um campo predictor_prompt (ou o nome do campo especificado em predictor_prompt_column) contendo uma versão concisa do texto do problema. Esse campo é usado pelo preditor de taxa de aprovação para avaliar rapidamente a dificuldade imediata sem processar todo o contexto da conversa.

Exemplo de entrada JSONL com prompt de preditor:

{
  "messages": [
    {
      "role": "system",
      "content": "You are a math tutor. Show your work step by step."
    },
    {
      "role": "user",
      "content": "A train travels 120 miles in 2 hours. If it then increases speed by 50%, how far will it travel in the next 3 hours?"
    }
  ],
  "reference_answer": "270 miles",
  "predictor_prompt": "A train travels 120 miles in 2 hours. Speed increases 50%. Distance in next 3 hours?"
}

Se o campo predictor_prompt não estiver presente, o sistema reverterá ao uso do prompt inteiro do campo messages.

Exemplo completo de roteiro com currículo adaptativo

O exemplo a seguir mostra um roteiro completo de RFT LoRA com currículo adaptativo habilitado:

run:
  name: "my-rft-adaptive-curriculum"
  model_type: amazon.nova-2-lite-v1:0:256k
  model_name_or_path: nova-lite-2/prod
  data_s3_path: s3://<bucket>/<data-file>
  replicas: 4
  generation_replicas: 2
  reward_lambda_arn: arn:aws:lambda:<region>:<account-id>:function:<function-name>

training_config:
  max_length: 8192
  global_batch_size: 32
  reasoning_effort: null                        # Non-reasoning mode.

  data:
    shuffle: true

  rollout:
    rollout_strategy:
      type: off_policy_async
      age_tolerance: 2
    advantage_strategy:
      number_generation: 16                     # Higher n for better advantage estimates.
    generator:
      max_new_tokens: 6000
      temperature: 1.0
    rewards:
      preset_reward_function: exact_match       # Or null for custom Lambda reward.
      api_endpoint:
        lambda_arn: ${oc.select:run.reward_lambda_arn}   # Reuse the top-level run.reward_lambda_arn so the two stay in sync.
        lambda_concurrency_limit: 12
        lambda_batch_size: 128

  trainer:
    max_steps: 500
    save_steps: 50
    test_steps: 25
    refit_freq: 4
    clip_ratio_high: 0.2
    ent_coeff: 0.0
    kl_loss_coef: 0.0

    optim_config:
      lr: 1e-6
      weight_decay: 0.0

    peft:
      peft_scheme: "lora"
      lora_tuning:
        alpha: 64
        lora_plus_lr_ratio: 64.0

    adaptive_curriculum:
      enable: true
      selection_pool_multiplier: 8
      prediction_mode: pass_rate
      exemplar_history_steps: 1
      reinforce_coef: 0.01
      predictor_prompt_column: predictor_prompt

Monitorar currículos adaptativos

Quando o currículo adaptativo está habilitado, métricas adicionais são registradas em log em cada etapa do treinamento:

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:

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 está disponível para ajudar a monitorar o status e o progresso das tarefas 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.