Os LLMs desbloquearam inúmeras novas oportunidades para aplicações de IA. Se você sempre quis ajustar seu próprio modelo, este guia mostrará como fazer isso facilmente e sem escrever nenhum código. Usando ferramentas como Axolotl e DPO, percorreremos o processo passo a passo.
O que é um LLM?
Um Large Language Model (LLM) é um poderoso modelo de IA treinado em grandes quantidades de dados de texto – dezenas de trilhões de caracteres – para prever o próximo conjunto de palavras em uma sequência. Isso só foi possível nos últimos 2 a 3 anos com os avanços feitos na computação GPU, que permitiram treinar modelos tão grandes em questão de poucas semanas.
Você provavelmente já interagiu com LLMs por meio de produtos como ChatGPT ou Claude e experimentou em primeira mão sua capacidade de compreender e gerar respostas semelhantes às humanas.
Por que ajustar um LLM?
Não podemos simplesmente usar o GPT-4o para tudo? Bem, embora seja o modelo mais poderoso que temos no momento em que escrevemos este artigo, nem sempre é a escolha mais prática. O ajuste fino de um modelo menor, variando de 3 a 14 bilhões de parâmetros, pode produzir resultados comparáveis por uma pequena fração do custo. Além disso, o ajuste fino permite que você possua sua propriedade intelectual e reduz sua dependência de terceiros.
Compreendendo os modelos Base, Instruct e Chat
Antes de mergulhar no ajuste fino, é essencial compreender os diferentes tipos de LLMs existentes:
- Modelos básicos: são pré-treinados em grandes quantidades de texto não estruturado, como livros ou dados da Internet. Embora tenham uma compreensão intrínseca da linguagem, não estão otimizados para inferência e produzirão resultados incoerentes. Os modelos básicos são desenvolvidos para servir como ponto de partida para o desenvolvimento de modelos mais especializados.
- Modelos de instrução: construídos sobre modelos básicos, os modelos de instrução são ajustados usando dados estruturados, como pares de resposta rápida. Eles são projetados para seguir instruções específicas ou responder perguntas.
- Modelos de bate-papo: também construídos em modelos básicos, mas diferentemente dos modelos de instrução, os modelos de bate-papo são treinados em dados de conversação, permitindo-lhes interagir em diálogos alternados.
O que é aprendizagem por reforço e DPO?
Aprendizado por Reforço (RL) é uma técnica onde os modelos aprendem recebendo feedback sobre suas ações. É aplicado a modelos de instrução ou chat para refinar ainda mais a qualidade de seus resultados. Normalmente, o RL não é feito sobre modelos básicos, pois usa uma taxa de aprendizado muito mais baixa, o que não moverá o ponteiro o suficiente.
DPO é uma forma de RL onde o modelo é treinado usando pares de respostas boas e ruins para o mesmo prompt/conversa. Ao apresentar esses pares, o modelo aprende a privilegiar os bons exemplos e evitar os maus.
Quando usar DPO
O DPO é particularmente útil quando você deseja ajustar o estilo ou comportamento do seu modelo, por exemplo:
- Ajustes de estilo: modifique a extensão das respostas, o nível de detalhe ou o grau de confiança expresso pelo modelo.
- Medidas de segurança: treine o modelo para recusar responder a solicitações potencialmente inseguras ou inadequadas.
No entanto, o DPO não é adequado para ensinar ao modelo novos conhecimentos ou factos. Para tanto, as técnicas de Supervised Fine-Tuning (SFT) ou Retrieval-Augmented Generation (RAG) são mais apropriadas.
Criando um conjunto de dados DPO
Em um ambiente de produção, você normalmente geraria um conjunto de dados DPO usando feedback de seus usuários, por exemplo:
- Feedback do usuário: implementação de um mecanismo de aprovação/rejeição nas respostas.
- Escolhas Comparativas: Apresentar aos usuários dois resultados diferentes e pedir-lhes que escolham o melhor.
Se não tiver dados do usuário, você também pode criar um conjunto de dados sintético aproveitando LLMs maiores e mais capazes. Por exemplo, você pode gerar respostas ruins usando um modelo menor e depois usar o GPT-4o para corrigi-las.
Para simplificar, usaremos um conjunto de dados pronto do HuggingFace: olivermolenschot/alpaca_messages_dpo_test. Se você inspecionar o conjunto de dados, notará que ele contém prompts com respostas escolhidas e rejeitadas – esses são os bons e os maus exemplos. Esses dados foram criados sinteticamente usando GPT-3.5-turbo e GPT-4.
Geralmente, você precisará de no mínimo 500 a 1.000 pares de dados para ter um treinamento eficaz sem overfitting. Os maiores conjuntos de dados DPO contêm de 15.000 a 20.000 pares.
Instrução de ajuste fino Qwen2.5 3B com Axolotl
Usaremos o Axolotl para ajustar o modelo Qwen2.5 3B Instruct, que atualmente está no topo do Tabela de classificação OpenLLM para sua classe de tamanho. Com o Axolotl, você pode ajustar um modelo sem escrever uma única linha de código – apenas um arquivo de configuração YAML. Abaixo está o config.yml que usaremos:
base_model: Qwen/Qwen2.5-3B-Instruct
strict: false
# Axolotl will automatically map the dataset from HuggingFace to the prompt template of Qwen 2.5
chat_template: qwen_25
rl: dpo
datasets:
- path: olivermolenschot/alpaca_messages_dpo_test
type: chat_template.default
field_messages: conversation
field_chosen: chosen
field_rejected: rejected
message_field_role: role
message_field_content: content
# We pick a directory inside /workspace since that's typically where cloud hosts mount the volume
output_dir: /workspace/dpo-output
# Qwen 2.5 supports up to 32,768 tokens with a max generation of 8,192 tokens
sequence_len: 8192
# Sample packing does not currently work with DPO. Pad to sequence length is added to avoid a Torch bug
sample_packing: false
pad_to_sequence_len: true
# Add your WanDB account if you want to get nice reporting on your training performance
wandb_project:
wandb_entity:
wandb_watch:
wandb_name:
wandb_log_model:
# Can make training more efficient by batching multiple rows together
gradient_accumulation_steps: 1
micro_batch_size: 1
# Do one pass on the dataset. Can set to a higher number like 2 or 3 to do multiple
num_epochs: 1
# Optimizers don't make much of a difference when training LLMs. Adam is the standard
optimizer: adamw_torch
# DPO requires a smaller learning rate than regular SFT
lr_scheduler: constant
learning_rate: 0.00005
# Train in bf16 precision since the base model is also bf16
bf16: auto
# Reduces memory requirements
gradient_checkpointing: true
# Makes training faster (only suported on Ampere, Ada, or Hopper GPUs)
flash_attention: true
# Can save multiple times per epoch to get multiple checkpoint candidates to compare
saves_per_epoch: 1
logging_steps: 1
warmup_steps: 0Configurando o ambiente em nuvem
Para realizar o treinamento, usaremos um serviço de hospedagem em nuvem como Runpod ou Vultr. Aqui está o que você precisa:
- Imagem Docker: Clone a imagem Winglian/axolotl-cloud:main Docker fornecida pela equipe Axolotl.
- *Requisitos de hardware: Uma GPU VRAM de 80 GB (como um nó PCIe 1×A100) será mais que suficiente para este tamanho de modelo.
- Armazenamento: 200 GB de volume de armazenamento para acomodar todos os arquivos que precisamos.
- Versão CUDA: Sua versão CUDA deve ser pelo menos 12.1.
*Este tipo de treinamento é considerado um ajuste completo do LLM e, portanto, exige muito VRAM. Se quiser realizar um treinamento localmente, sem depender de hosts em nuvem, você pode tentar usar o QLoRA, que é uma forma de ajuste fino supervisionado. Embora seja teoricamente possível combinar DPO e QLoRA, isso raramente é feito.
Passos para iniciar o treinamento
- Defina o diretório de cache HuggingFace:
export HF_HOME=/workspace/hfIsso garante que o modelo original seja baixado para nosso armazenamento de volume, que é persistente.
- Criar arquivo de configuração: salve o arquivo config.yml que criamos anteriormente em /workspace/config.yml.
- Iniciar o treinamento:
python -m axolotl.cli.train /workspace/config.ymlE pronto! Seu treinamento deve começar. Após o Axolotl baixar o modelo e os dados de treinamento, você deverá ver uma saída semelhante a esta:
(2024-12-02 11:22:34,798) (DEBUG) (axolotl.train.train:98) (PID:3813) (RANK:0) loading model
(2024-12-02 11:23:17,925) (INFO) (axolotl.train.train:178) (PID:3813) (RANK:0) Starting trainer...O treinamento deve levar apenas alguns minutos para ser concluído, pois se trata de um pequeno conjunto de dados de apenas 264 linhas. O modelo ajustado será salvo em /espaço de trabalho/saída dpo.
Carregando o modelo para HuggingFace
Você pode fazer upload do seu modelo para o HuggingFace usando a CLI:
- Instale a CLI do HuggingFace Hub:
pip install huggingface_hub(cli)- Carregue o modelo:
huggingface-cli upload /workspace/dpo-output yourname/yourrepoSubstitua yourname/yourrepo pelo seu nome de usuário e nome de repositório reais do HuggingFace.
Avaliando seu modelo ajustado
Para avaliação, é recomendado hospedar os modelos originais e ajustados usando uma ferramenta como Inferência de geração de texto (TGI). Em seguida, execute inferência em ambos os modelos com configuração de temperatura 0 (para garantir resultados determinísticos) e compare manualmente as respostas dos dois modelos.
Esta abordagem prática fornece melhores insights do que depender apenas de métricas de perda de avaliação de treinamento, que podem não capturar as nuances da geração de linguagem em LLMs.
Conclusão
O ajuste fino de um LLM usando DPO permite personalizar modelos para melhor atender às necessidades da sua aplicação, ao mesmo tempo que mantém os custos gerenciáveis. Seguindo as etapas descritas neste artigo, você pode aproveitar o poder das ferramentas e conjuntos de dados de código aberto para criar um modelo que se alinhe aos seus requisitos específicos. Esteja você procurando ajustar o estilo de respostas ou implementar medidas de segurança, o DPO oferece uma abordagem prática para refinar seu LLM.
Feliz ajuste fino!
Deixe um comentário