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

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 de antemão:

Modelos compatíveis

Amazon NovaLite 2.0

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:

Exemplo: problema matemático

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

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ê valide que sua função de recompensa está livre de bugs, confirme que a RFT é a abordagem certa para seu caso de uso, identifique e corrija problemas com antecedência e teste o fluxo de trabalho antes de aumentar a escala.

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, solicitações ambíguas e respostas de referência conflitantes. 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. Inclua diferentes formatos de entrada e casos extremos, mapeie os padrões reais de uso da produção a partir de registros e análises de usuários, faça amostras de todos os tipos de usuários, regiões geográficas e variações sazonais e inclua níveis de dificuldade de problemas simples a complexos.

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

Crie sua função de recompensa para um treinamento eficiente. Ele deve ser executado em segundos (não minutos), paralelizar de forma eficazAWS Lambda, retornar pontuações consistentes e confiáveis e lidar com diferentes tipos de saídas do modelo com elegância. 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

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
}

Implementando funções de recompensa

As funções de recompensa são implementadas como funções Lambda que avaliam as respostas do modelo e retornam pontuações numéricas. A função Lambda recebe mensagens e verdades fundamentais no formato OpenAI e deve retornar pontuações como um dicionário.

permissões do IAM

Certifique-se de que sua função de execução de SageMaker IA tenha InvokeFunction permissões para a função Lambda.

{
  "Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "lambda:InvokeFunction",
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:my-reward-function-lambda"
    }
  ]
}

Diretrizes para projeto

Ao escrever funções de recompensa, faça o seguinte:

Formato da interface

Sua função de recompensa deve aceitar e devolver dados no formato a seguir.

Estrutura de entrada

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

Estrutura de saída

[{
  "id": "123",
  "aggregate_reward_score": 0.85,
  "metrics_list": [
    {
      "name": "accuracy",
      "value": 0.9,
      "type": "Reward"
    },
    {
      "name": "policy_compliance",
      "value": 0.8,
      "type": "Metric"
    }
  ]
}]

Exemplo de função Lambda

from typing import List
import json
from dataclasses import asdict, dataclass

@dataclass
class RewardOutput:
    """Reward service output."""
    id: str
    aggregate_reward_score: float

def lambda_handler(event, context):
    """Main lambda handler"""
    return lambda_grader(event)

def lambda_grader(samples: list[dict]) -> list[dict]:
    """Core grader function"""
    scores: List[RewardOutput] = []
    for sample in samples:
        idx = sample["id"]
        ground_truth = sample.get("metadata", {}).get("reference_answer")
        
        if "messages" not in sample:
            print(f"Messages is None/empty for id: {idx}")
            ro = RewardOutput(id=idx, aggregate_reward_score=0.0)
            scores.append(ro)
            continue
        
        if ground_truth is None:
            print(f"No answer found in ground truth for id: {idx}")
            ro = RewardOutput(id=idx, aggregate_reward_score=0.0)
            scores.append(ro)
            continue
        
        # Get model's response (last turn is assistant turn)
        last_message = sample["messages"][-1]
        assert last_message["role"] == "assistant", "Last message must be from assistant"
        model_text = last_message["content"]
        
        ground_truth_text = _extract_ground_truth_text(ground_truth)
        
        if model_text.lower() == ground_truth_text.lower():
            score = 1.0
        else:
            score = 0.0
        
        ro = RewardOutput(id=idx, aggregate_reward_score=score)
        scores.append(ro)
    
    return [asdict(score) for score in scores]

def _extract_ground_truth_text(ground_truth) -> str:
    """Turn the ground_truth field into a plain string."""
    if isinstance(ground_truth, str):
        return ground_truth
    
    if isinstance(ground_truth, dict):
        if "explanation" in ground_truth and isinstance(ground_truth["explanation"], str):
            return ground_truth["explanation"]
        if "answer" in ground_truth and isinstance(ground_truth["answer"], str):
            return ground_truth["answer"]
        return json.dumps(ground_truth, ensure_ascii=False)
    
    return str(ground_truth)

Configuração do treinamento

Use o modelo de caderno SageMaker AI Training Job para iniciar um trabalho de treinamento. Para obter mais informações, consulte Criar um trabalho de treinamento.

Contêiner de treinamento

708977205387.dkr.ecr.us-east-1.amazonaws.com/nova-fine-tune-repo:SM-TJ-RFT-latest

Requisitos de instância

O contêiner oferece suporte ao treinamento Full Rank e LoRa:

Seleção do modo de raciocínio

Modos disponíveis

Quando usar cada modo

Use o high raciocínio para tarefas analíticas complexas, resolução de problemas matemáticos, dedução lógica em várias etapas e tarefas em que o pensamento agrega valor. step-by-step

Use none (omitareasoning_effort) ou low raciocine para consultas factuais simples, classificações diretas, otimização de velocidade e custo e respostas diretas a perguntas.

Compensações de custo e desempenho

Modos de raciocínio mais altos aumentam o tempo e o custo do treinamento, a latência e o custo da inferência e a capacidade de modelar para tarefas complexas de raciocínio.

Treinamento de monitoramento

Os registros de treinamento incluem métricas abrangentes em cada etapa. As principais categorias métricas incluem o seguinte:

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 nos registros de treinamento e no manifest.json arquivo no local de saída do Amazon S3 (definido em seu output_s3_uri notebook).

Limitações e melhores práticas

Limitações

Práticas recomendadas