# 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: + 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, 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:/// # 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:::function: ## 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:::function: 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** + none: sem raciocínio (omita o campo reasoning\_effort) + low: sobrecarga mínima de raciocínio + high: capacidade máxima de raciocínio (padrão quando reasoning\_effort é especificado) **nota** Não há a opção medium para o RFT. Se o campo reasoning\_effort 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\_effort) 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 ## 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: 1. **Previsão**: o modelo prevê a taxa de aprovação (ou variação entre as recompensas) de cada prompt candidato usando um formato de previsão com poucas tentativas. Três exemplares da etapa de treinamento anterior (um fácil, um médio e um difícil) fornecem o contexto de calibração. 1. **Seleção**: os prompts são classificados pelo quanto a dificuldade prevista se aproxima da meta de seleção (padrão: taxa de aprovação de 50%). Os melhores prompts são aprovados para rollout; os demais são descartados sem consumir computação de rollout. 1. **Treinamento**: o treinamento com GRPO padrão ocorre nos prompts selecionados. 1. **Feedback**: as taxas reais de aprovação do rollout são comparadas com as previsões. A meta da seleção é calibrada automaticamente para corrigir a tendenciosidade sistemática na previsão. Um gradiente REINFORCE treina o preditor para melhorar as futuras previsões. ### Quando usar currículo adaptativo O currículo adaptativo é mais eficaz nos seguintes cenários: + Você quer aumentar a estabilidade do treinamento por RL garantindo que cada lote de treinamento contenha prompts com significativa variância de recompensa, o que reduz as ruidosas atualizações baseadas em gradientes que podem desestabilizar a aprendizagem. + Você confirmou que o RFT básico melhora a métrica pretendida. + Você quer acelerar a convergência concentrando a computação de treinamento nos prompts mais produtivos. + O conjunto de dados é grande (mais de 5.000 prompts) e contém muitos prompts fora da faixa de dificuldade produtiva que, de outra forma, desperdiçariam computação. ### 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: | Parâmetro | Tipo | Padrão | Descrição | | --- | --- | --- | --- | | enable | Booleano | false | Se a seleção rápida de prompt do currículo adaptativo deve ou não ser habilitada. | | selection\_pool\_multiplier | Inteiro (1 a 32) | 8 | Controla quantos prompts candidatos são pontuados em relação ao tamanho do lote de treinamento. Um valor de 8 significa que 8 × global\_batch\_size prompts são pontuados e os global\_batch\_size melhores são selecionados. Valores mais altos geram uma seleção com mais qualidade, mas custam mais computação de inferência. | | prediction\_mode | String | pass\_rate | Modo de previsão para estimativa de dificuldade de prompt. Use pass\_rate em tarefas de recompensa discreta (por exemplo, verificação de correção) na qual o preditor estima a probabilidade de uma resposta correta. Use spread em tarefas de recompensa contínua na qual o preditor estima a distribuição de recompensa máxima e mínima entre os rollouts. | | exemplar\_history\_steps | Inteiro (≥1) | 1 | Número de etapas de treinamento anteriores a serem mantidas no buffer de histórico contínuo para seleção de exemplares. O preditor usa exemplares desse histórico para calibrar suas previsões com poucas tentativas. | | reinforce\_coef | Número (≥0) | 0.01 | Fator de escala para a perda REINFORCE que treina o mecanismo de previsão de taxa de aprovação. Isso permite a aprendizagem de ciclo fechado, na qual o preditor melhora sua precisão ao longo do treinamento. Defina como 0 para desabilitar o treinamento do preditor. | | predictor\_prompt\_column | String | predictor\_prompt | Nome do campo no conjunto de dados que contém o texto do problema limpo usado como prompt do preditor. Deve ser uma versão concisa do problema, sem prompts ou formatação do sistema, para que o preditor possa avaliar a dificuldade rapidamente. | | selection\_lookahead\_steps | Inteiro (1 a 16) | 4 | Número de futuros lotes de treinamento a serem pré-aprovados em uma única passada de triagem do currículo por etapa. Cada passada avalia selection\_pool\_multiplier × global\_batch\_size candidatos por etapa; valores mais altos de selection\_lookahead\_steps repetem a passada várias vezes para criar uma fila de prompts aprovados, o que reduz a sobrecarga do preditor por etapa em conjuntos de dados de prompts curtos. Para conjuntos de dados de contexto longo nos quais o preditor em si tem alto custo (consulte a seção de recomendações), defina esse valor como 1 para que o preditor seja executado apenas uma vez por etapa. | ### 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. **nota** O currículo adaptativo é compatível com um `max_prompt_length` de até 32.768 tokens (32 K). Não é possível habilitá-lo em conjuntos de dados que excedem esse tamanho; desabilite o currículo adaptativo ou reduza os prompts antes do treinamento. 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. | `max_prompt_length` típico | Configurações de currículo adaptativo recomendadas | | --- | --- | | Até 8 K tokens | Use os padrões: selection\_pool\_multiplier: 8, selection\_lookahead\_steps: 4. A sobrecarga de triagem é pequena e não requer ajuste. | | Mais de 8 K até 16 K tokens | Defina selection\_lookahead\_steps: 2. Isso reduz à metade o número de aprovações do preditor por etapa, mantendo prompts pré-aprovados suficientes na fila para evitar que faltem no rollout. | | Mais de 16 K e até 24 K tokens | Mantenha selection\_lookahead\_steps: 2 e reduza selection\_pool\_multiplier para 4. O pool menor reduz à metade o tamanho de lote do preditor com algum custo para a qualidade de seleção; juntos, eles mantêm o tempo de triagem por etapa controlado. | | Mais de 24 K até 32 K tokens | Use o selection\_pool\_multiplier: 4 com o selection\_lookahead\_steps: 1. O preditor é executado uma vez por etapa de treinamento em um grupo de tamanho mínimo. Essa é a configuração mais agressiva que é aceita; não é possível ultrapassar 32 K. | 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:/// replicas: 4 generation_replicas: 2 reward_lambda_arn: arn:aws:lambda:::function: 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: + **Taxa de aprovação prevista comparada com a taxa de aprovação real**: a taxa média de aprovação prevista para os prompts selecionados em comparação com a taxa de aprovação real observada após o rollout. Uma grande diferença indica que o preditor precisa de mais tempo de calibração. + **Meta de seleção**: a meta de seleção atual calibrada automaticamente. Começa em 0,5 e é ajustada com base na precisão da previsão. + **Contagem de filtros de maestria**: número de prompts excluídos porque o modelo já os dominou de forma consistente. **nota** As primeiras uma ou duas etapas de treinamento são executadas sem seleção adaptativa (o preditor precisa de, pelo menos, uma etapa de histórico para criar exemplares). A seleção adaptativa completa começa na etapa 3. ## 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.