Otimização de política proximal (PPO)

A otimização de política proximal (PPO) é o processo de usar vários modelos de machine learning para treinar e classificar um modelo. Os seguintes modelos fazem parte do processo de PPO:

Treinamento de atores ou modelo de política: um modelo de ajuste fino supervisionado (SFT) que é ajustado e atualizado a cada época. As atualizações são feitas por meio de amostragem de prompts, geração de conclusões e atualização de pesos usando um objetivo substituto recortado. Isso limita alterações de lucratividade de log por token, de modo que cada etapa da política seja proximal em relação à anterior, enquanto a estabilidade do treinamento é preservada.
Modelo de geração de ator: um modelo que gera conclusões ou respostas de prompts a serem julgadas pelo modelo de recompensa e pelo modelo crítico. Os pesos desse modelo são atualizados a partir do treinamento de ator ou do modelo de política a cada época.
Modelo de recompensa: um modelo com pesos congelados usado para pontuar o modelo de geração de atores.
Modelo crítico: um modelo com pesos não congelados que é usado para pontuar o modelo de geração de atores. Essa pontuação geralmente é vista como uma estimativa da recompensa total que o ator recebe ao gerar os tokens restantes.
Modelo âncora: um modelo SFT com pesos congelados que é usado para calcular a divergência KL entre o modelo do trem de atores e o modelo básico. O modelo-âncora garante que as atualizações do modelo de ator não sejam muito drásticas em comparação com o modelo básico. Alterações drásticas podem gerar instabilidade ou degradação de performance.

Os dados de treinamento devem estar no formato JSONL, onde cada linha contém um único objeto JSON que representa um exemplo de treinamento. Exemplo:


{
    "turns": ["string", "string", ...], // Required
    "turns_to_mask": [integer, integer, ...], // Required
    "reward_category": "string", // Required
    "meta_data": {} // Optional
}

turnsé uma matriz de matrizes de cadeias de conversação que representam a sequência de diálogo. Essa linha contém solicitações do sistema, mensagens do usuário e respostas do bot. As mensagens do usuário geralmente terminam com “Bot:” para indicar onde a saída do modelo começa. Por exemplo, .[["System prompt"], ["User: Question Bot:"], ["Bot response"]]
turns_to_maské uma matriz de índices baseados em 0 que identificam quais curvas não devem receber atualizações de gradiente. As curvas mascaradas são normalmente solicitações do sistema e turnos do usuário. Por exemplo, [0, 1, 3] mascara o prompt do sistema e as mensagens do usuário (a primeira e a terceira mensagens).
reward_categoryé uma sequência de caracteres que identifica quais aspectos do desempenho do modelo devem ser avaliados. É usado para selecionar a categoria apropriada do modelo de recompensa durante o treinamento. A categoria de recompensa está disponível para as seguintes categorias de recompensa: default mathcoding,if,rag,, rai e.
meta_dataé um objeto opcional que contém informações adicionais contextuais ou verdadeiras. Isso pode incluir identificadores, informações de origem ou contexto da conversa. A estrutura é flexível com base nas necessidades do seu conjunto de dados.

Aqui está um exemplo de registro:


{
    "turns": ["You are a helpful AI assistant.",
        "User: What is ML? Bot:",
        "Machine learning is...", "User: Examples? Bot:",
        "Email spam filtering is..."
    ],
    "turns_to_mask": [0, 1, 3],
    "reward_category": "default",
    "meta_data": {
        "messages": [{
                "role": "system",
                "content": "You are a helpful AI assistant."
            },
            {
                "role": "user",
                "content": "What is ML?"
            },
            {
                "role": "assistant",
                "content": "Machine learning is..."
            },
            {
                "role": "user",
                "content": "Examples?"
            },
            {
                "role": "assistant",
                "content": "Email spam filtering is..."
            }
        ]
    }
}

A estrutura de modelagem de recompensas implementa a otimização multidimensional em objetivos categóricos distintos para facilitar a convergência robusta do modelo. A categoria de recompensa deve ser selecionada com base na tarefa para a qual o modelo deve ser otimizado.

Recomendamos as seguintes diretrizes para selecionar a estrutura certa para suas tarefas:

default: Um otimizador de uso geral para tarefas conversacionais padrão e interações básicas. Usado para conversas e discussões gerais, tarefas básicas de redação, respostas simples a perguntas e consultas de conhecimento não especializado.

Exemplo:
```
{
    "turns": ["Write a summary of climate change"],
    "turns_to_mask": [0],
    "reward_category": "default"
}
```
math: Um otimizador especializado para cálculos matemáticos e tarefas de raciocínio numérico. Usado para resolução de problemas matemáticos, cálculos aritméticos, equações algébricas, problemas geométricos e análise estatística.

Exemplo:
```
{
    "turns": ["Calculate the derivative of x²"],
    "turns_to_mask": [0],
    "reward_category": "math"
}
```
coding: Uma categoria dedicada para consultas relacionadas à programação e ao desenvolvimento de software. Usado para implementação de código, assistência à depuração, design de algoritmos, documentação técnica e questões de arquitetura do sistema.

Exemplo:
```
{
    "turns": ["Write a function to check if a string is palindrome"],
    "turns_to_mask": [0],
    "reward_category": "coding"
}
```
if: Uma categoria para tarefas que exigem execução e step-by-step orientação processuais precisas. Usado para procedimentos de várias etapas, instruções sequenciais, decomposição complexa de tarefas e documentação de processos.

Exemplo:
```
{
    "turns": ["Provide steps to deploy a web application"],
    "turns_to_mask": [0],
    "reward_category": "if"
}
```

rag: uma categoria de recompensa para tarefas que exigem respostas a consultas com base especificamente nas informações contextuais recuperadas. Usado quando as respostas devem ser derivadas diretamente dos materiais de referência fornecidos, sintetizando o conteúdo factual sem ir além do escopo das informações recuperadas, garantindo que as respostas sejam fundamentadas no contexto fornecido e não no conhecimento geral.

Exemplo:


{
            "turns": ["The Synthesis Report integrates findings from all six IPCC assessment cycles, revealing that global surface temperature has increased 1.1°C from 1850-1900 to 2011-2020, with human activities unequivocally identified as the cause of this warming. Alarmingly, current policies put the world on track for 3.2°C warming by 2100. The document identifies 5 key climate system "tipping points" approaching and emphasizes that greenhouse gas emissions must decline 43% by 2030 (compared to 2019 levels) to limit warming to 1.5°C. Climate-related risks will escalate with every increment of warming, with loss and damage disproportionately affecting vulnerable populations. Despite some progress, climate adaptation remains uneven with significant gaps, and financial flows continue to fall below levels needed for mitigation goals.",
            "What were the key findings of the latest IPCC climate report?"],
            "turns_to_mask": [0, 0],
            "reward_category": "rag"
            }

rai: uma categoria de recompensa para tarefas que exigem a aplicação de princípios responsáveis de IA, como justiça, transparência e ética. Usado para avaliar possíveis preconceitos em sistemas de IA, garantir considerações de privacidade, abordar dilemas éticos e promover princípios de design inclusivos.

Exemplo:
```
{
            "turns": ["Identify potential bias concerns when developing a loan approval algorithm and suggest mitigation strategies"],
            "turns_to_mask": [0],
            "reward_category": "rai"
            }
```

Turnos de mascaramento

Em conjuntos de dados de treinamento, o turns_to_mask parâmetro é crucial para controlar quais turnos de conversação recebem atualizações de gradiente durante o treinamento. Essa matriz de índices determina quais partes do diálogo o modelo deve aprender a gerar versus quais partes devem ser tratadas apenas como contexto. O mascaramento adequado garante que o modelo aprenda os padrões de resposta apropriados, evitando o treinamento nas instruções do sistema ou nas entradas do usuário que poderiam prejudicar o desempenho.

Recomendamos a seguinte orientação para mascarar:

Sempre mascare o índice 0 - Os prompts do sistema nunca devem receber atualizações de gradiente.
Sempre mascare os turnos do usuário - Evite que o modelo aprenda a gerar entradas do usuário.
Consistência de padrões - Use padrões de mascaramento idênticos para estruturas de conversação semelhantes, como (0, 1, 3, 5) para diálogos de vários turnos.
Treinamento seletivo - mascare as respostas iniciais dos bots para focar o treinamento em respostas finais aprimoradas.
Chain-of-thought preservação - Somente o sistema de máscara e o usuário ativam ao treinar em sequências de raciocínio.
Filtragem de qualidade - mascare as respostas do assistente de baixa qualidade para evitar a degradação do desempenho.
Otimização de contexto - garanta que turnos mascarados não removam o contexto essencial necessário para respostas subsequentes.

A chave para um mascaramento eficaz é monitorar as métricas de treinamento e o desempenho de validação para identificar se sua estratégia de mascaramento preserva o contexto necessário e, ao mesmo tempo, focar as atualizações de gradiente nas saídas desejadas do modelo.

Habilitar a perda de divergência de KL

Para permitir a perda de divergência de KL, o servidor âncora precisa estar habilitado para calcular a divergência da política atual em relação à distribuição original. O tipo de perda de KL precisa ser especificado e os coeficientes precisam ser um valor diferente de zero. Valores de coeficiente mais altos ajudam o modelo a não se desviar muito da política original, o que resulta em menores alterações no desempenho geral. Valores de coeficiente mais baixos permitem maiores desvios da política anterior, levando a um melhor desempenho das métricas-alvo, mas impactando o desempenho geral.


ppo_anchor:
  max_length: 8192
  trainer:
    num_nodes: ${recipes.run.cm_replicas}
  model:
    global_batch_size: 32
    
ppo_actor_train:
  model:
    ######## Use KL in actor loss ########
    kl_loss_type: low_var_kl 
    kl_loss_coeff: 0.1 

    ######## Use KL in reward model ######
    kl_reward_penalty_coeff: 0.1

Taxa de aprendizado

A taxa de aprendizado dos modelos crítico e político pode ser ajustada, com 3e-6 sendo a escolha balanceada padrão. Taxas de aprendizado mais altas geralmente levam a instabilidades de treinamento, que podem ser identificadas por meio de picos de divergência de KL e comportamento político errático. Taxas de aprendizado mais baixas podem causar problemas de convergência e aprendizado lento, indicados por recompensas estagnadas e atualizações mínimas de políticas. O monitoramento regular da divergência de KL, da pontuação de recompensa e da perda de valor ajuda a determinar se a taxa de aprendizado deve ser ajustada durante o treinamento.


ppo_critic:
  model:
    optim:
      lr: 3e-6

ppo_actor_train:
  model:
    optim:
      lr: 3e-06

Tamanho global do lote

O tamanho global do lote afeta significativamente o desempenho do PPO no Amazon Nova, com lotes maiores geralmente melhorando a estabilidade do treinamento e a estimativa do gradiente, ao mesmo tempo em que permitem um processamento paralelo mais eficiente. No entanto, lotes muito grandes podem levar a retornos decrescentes e podem ser limitados pela memória disponível, exigindo um equilíbrio cuidadoso com a taxa de aprendizado e outros hiperparâmetros.


ppo_actor_train:
  model:
    global_batch_size: 160

Os parâmetros do Amazon Nova que estão disponíveis para ajuste com o PPO incluem:

Executar configuração
- actor_train_replicas: o número de instâncias de computação a serem usadas para o modelo de treinamento de atores. Os valores disponíveis variam de acordo com o modelo escolhido. O Amazon Nova Micro suporta 1 ou 2 réplicas. O Amazon Nova Lite oferece suporte a 1, 2 ou 4 réplicas. O Amazon Nova Pro oferece suporte a 3, 6 ou 12 réplicas.
- rm_replicas: o número de instâncias de computação usadas para o modelo de recompensa. Recomendamos que você use uma réplica para qualquer tamanho de modelo.
- cm_replicas: o número de instâncias computacionais usadas para o modelo crítico. Recomendamos que você use uma réplica para qualquer tamanho de modelo.
- actor_generation_replicas: o número de instâncias de computação usadas para a geração do ator. Os valores disponíveis variam de acordo com o modelo escolhido. O Amazon Nova Micro suporta 1 réplica. O Amazon Nova Lite oferece suporte a 1 ou 2 réplicas. O Amazon Nova Pro suporta 1 ou 2 réplicas.
- am_replicas: o número de instâncias de computação usadas para o modelo âncora. Recomendamos que você use uma réplica para qualquer tamanho de modelo.
Configuração do treinamento de atores (configuração de política)
- max_steps: O número máximo de etapas para ajustar ou treinar o modelo de treinamento de atores. Aqui, uma etapa é definida como implantação, seguida pelo treinamento do modelo de treinamento de atores com o global_batch_size número de amostras. Uma época é definida comoglobal_batch_size * trajectory_buffer_scale.
  
  O valor escolhido aqui variará com base no seu caso de uso e na complexidade do conjunto de dados. Recomendamos começar com 65 épocas ou 520 etapas, que é o número de épocas multiplicado pelo valor do. trajectory_buffer_scale No entanto, algumas tarefas exigem um tempo maior de treinamento de PPO para obter o mesmo desempenho.
  
  Para o PPO, as métricas de treinamento, como a pontuação saturante do modelo de recompensa e a duração média da ação no console ml-flow, podem ajudar a identificar os pontos ideais para avaliação.
- actor_model_max_length: o tamanho máximo dos dados de entrada que são enviados ao componente de geração do ator para gerar conclusões.
- reward_model_max_length: o tamanho máximo dos dados de entrada que são enviados ao servidor de recompensas para concluir a pontuação.
- trajectory_buffer_scale: esse buffer representa o número de lançamentos gerados usando o modelo antigo de treinamento de atores (política) antes de atualizar os pesos e gerar os novos lançamentos. Os valores suportados são 1, 2, 4, 8 e 16.
  
  Se trajectory_buffer_scale for 1, então o treinamento é sobre política. Isso significa que os lançamentos são gerados com os pesos de modelo mais atualizados, mas a produtividade é prejudicada. Se for 16, o modelo está um pouco fora da política, mas a taxa de transferência é maior. Recomendamos começar com 8 para cada modelo.
- kl_reward_penalty_coeff: Esse é o termo de divergência de KL que garante que as atualizações não sejam muito drásticas e que a política não seja elaborada a partir do modelo básico ou do SFT.
- kl_loss_coeff: Esse valor controla o quanto a penalidade de divergência de KL influencia o objetivo geral do treinamento no PPO.
- kl_loss_type: esse valor especifica como calcular a divergência entre as distribuições da política atual e de referência. Os kl_loss_types disponíveis são kl (divergência KL padrão), mse (erro quadrático médio), (diferença absoluta entre probabilidades logarítmicas) e abs low_var_kl (aproximação KL de baixa variância).
- model.clip_ratio: a taxa de clipe do ator (ε) no PPO é um hiperparâmetro que limita o quanto a política pode mudar durante cada atualização.
- model.optim.lr: A taxa de aprendizado usada para treinamento de perda de modelo substituto no modelo de ator.
- model.lam: Parte do processo de estimativa de vantagens. Um λ mais alto dá mais peso às recompensas de longo prazo, mas com maior variância, enquanto um λ mais baixo se concentra mais em recompensas imediatas com menor variação, mas com mais viés.
- model.ent_coeff: A perda de entropia no PPO incentiva a exploração ao penalizar a política quando ela se torna muito determinística (ou seja, sempre escolhendo as mesmas ações com alta confiança).
Configuração do modelo de recompensa
- global_batch_size: O tamanho do lote para marcar as conclusões usando o modelo de recompensa. Se ppo_actor_train.model.global_batch_size for maior queppo_reward.model.global_batch_size, eles serão processados em vários lotes. Observe que ppo_actor_train.model.global_batch_size % ppo_reward.model.global_batch_size deve ser igual a 0.
- max_length: a duração máxima do contexto do modelo de recompensa. Isso deve ser o mesmo queppo_actor_train.model.max_length.
Configuração do modelo crítico
- global_batch_size: O tamanho do lote do valor do modelo crítico. O modelo crítico fornecerá estimativas de valor para cada token nas respostas fornecidas pelo modelo do ator. O tamanho do lote é usado tanto para inferência quanto para treinamento.
  
  Observe que ppo_actor_train.model.global_batch_size % ppo_critic.model.global_batch_size deve ser igual a 0 ppo_actor_train.model.global_batch_size * ppo_actor_train.model.trajectory_buffer_size % ppo_critic.model.global_batch_size == 0 e.
- max_length: O tamanho máximo do contexto do modelo crítico. Isso deve ser o mesmo queppo_actor_train.model.max_length.
- model.optim.lr: A taxa de aprendizado usada para treinamento de perda de modelo substituto no modelo de ator.
Configuração do modelo de âncora
- global_batch_size: O tamanho do lote para gerar o logotipo do modelo SFT ou âncora congelado. Observe que ppo_actor_train.model.global_batch_size % ppo_anchor.model.global_batch_size deve ser igual a 0.
- max_length: a duração máxima do contexto do modelo de recompensa. Isso deve ser o mesmo queppo_actor_train.model.max_length.
Configuração do modelo de geração de atores
- actor_model_max_length: o tamanho máximo do contexto do componente de geração do modelo de ator. Isso deve ser o mesmo queppo_actor_train.model.max_length.

Receita de PPO

A seguir está uma receita para o PPO.


## Run config
run:
  name: ndry-ppo-pro
  model_type: amazon.nova-pro-v1:0:300k
  model_name_or_path: nova-pro/prod
  data_s3_path: s3://testing/train.jsonl # Your training data S3 path

  actor_train_replicas: 6 # Actor train model replicas
  rm_replicas: 1 # Reward model replicas
  cm_replicas: 1 # Critic model replicas
  actor_generation_replicas: 2 # Actor generation model replicas
  am_replicas: 1 # Anchor model replicas

## Training config for each PPO component
ppo_reward:
  max_length: 8192 # model architecture max length
  trainer:
    num_nodes: ${recipes.run.rm_replicas}
  model:
    global_batch_size: 16

ppo_critic:
  max_length: 8192
  trainer:
    num_nodes: ${recipes.run.cm_replicas}
  model:
    global_batch_size: 16
    optim:
      lr: 3e-6
      name: distributed_fused_adam
      adam_w_mode: true
      eps: 1e-06
      weight_decay: 0.0
      betas:
        - 0.9
        - 0.999

ppo_anchor:
  max_length: 8192
  trainer:
    num_nodes: ${recipes.run.am_replicas}
  model:
    global_batch_size: 16

ppo_actor_generation:
  actor_model_max_length: 8192
  trainer:
    num_nodes: ${recipes.run.actor_generation_replicas}

ppo_actor_train:
  max_length: 8192
  max_steps: 520 # Stopping criteria Desired epoch num * trajectory_buffer_scale
  actor_model_max_length: 8192 # truncate input data to max length
  reward_model_max_length: 8192 # truncate input data to max length
  trajectory_buffer_scale: 8
  trainer:
    num_nodes: ${recipes.run.actor_train_replicas}
  model:
    global_batch_size: 160
    ent_coeff: 0
    clip_ratio: 0.2
    lam: 1
    kl_loss_coeff: 0.0
    kl_loss_type: low_var_kl
    kl_reward_penalty_coeff: 0.0
    hidden_dropout: 0.0 # Dropout probability for hidden state transformer.
    attention_dropout: 0.0 # Dropout probability in the attention layer.
    ffn_dropout: 0.0 # Dropout probability in the feed-forward layer.
    optim:
      lr: 3e-06
      name: distributed_fused_adam # only this one is available for p0.
      adam_w_mode: true
      eps: 1e-08
      weight_decay: 0.0
      betas:
        - 0.9
        - 0.999

Limitações

O PPO tem as seguintes limitações:

Os pontos de verificação intermediários não são salvos para avaliação e você não pode retomar a partir de um ponto de verificação intermediário. Somente o último ponto de verificação é salvo.
Não há suporte para conjuntos de dados multimodais.
Os trabalhos de treinamento não são interrompidos automaticamente. Você precisa interromper o trabalho usando a HyperPod CLI.
MLflow o registro não é suportado.
As métricas de treinamento crítico não são suportadas no. TensorBoard
Para ajustar os hiperparâmetros, siga as orientações em Seleção de hiperparâmetros.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Otimização direta de preferências (DPO)

Iniciando um trabalho de treinamento usando a HyperPod CLI