Os LLMs desbloquearam inúmeras novas oportunidades para aplicativos de IA. Se você já quis ajustar seu próprio modelo, este guia mostrará como fazê-lo com facilidade e sem escrever nenhum código. Usando ferramentas como Axolotl e DPO, passaremos pelo processo passo a passo.
O que é um LLM?
Um grande modelo de linguagem (LLM) é um poderoso modelo de IA treinado em vastas quantidades de dados de texto – em intervalos 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-3 anos, com os avanços que foram feitos no computação da GPU, que permitiram que modelos tão grandes fossem treinados em questão de algumas semanas.
Você provavelmente interagiu com o LLMS por meio de produtos como ChatGPT ou Claude antes e já experimentou em primeira mão sua capacidade de entender e gerar respostas semelhantes a humanos.
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 a 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.
Entendendo os modelos de base, instruções e bate -papo
Antes de mergulhar no ajuste fino, é essencial entender os diferentes tipos de LLMs que existem:
- 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, eles não são otimizados para inferência e produzirão saídas 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 os modelos básicos, os modelos de instrução são ajustados usando dados estruturados, como pares de resposta à rápida resposta. Eles foram projetados para seguir instruções específicas ou responder a perguntas.
- Modelos de bate-papo: também construídos com modelos básicos, mas, diferentemente dos modelos de instrução, os modelos de bate-papo são treinados em dados de conversação, permitindo que eles se envolvam no diálogo de entrada e partida.
O que é aprendizado de reforço e DPO?
A aprendizagem de reforço (RL) é uma técnica em que os modelos aprendem recebendo feedback sobre suas ações. É aplicado para instruir ou bate -papo para refinar ainda mais a qualidade de seus resultados. Normalmente, o RL não é feito sobre os modelos básicos, pois usa uma taxa de aprendizado muito menor, que não moverá a agulha o suficiente.
O DPO é uma forma de RL em que o modelo é treinado usando pares de respostas boas e ruins para o mesmo prompt/conversa. Ao apresentar esses pares, o modelo aprende a favorecer os bons exemplos e evitar os ruins.
Quando usar o DPO
O DPO é particularmente útil quando você deseja ajustar o estilo ou o comportamento do seu modelo, por exemplo:
- Ajustes de estilo: modifique o comprimento 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 a resposta de instruções potencialmente inseguras ou inadequadas.
No entanto, o DPO não é adequado para ensinar o modelo de novos conhecimentos ou fatos. Para esse fim, as técnicas de ajuste fino supervisionado (SFT) ou geração de recuperação (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: Implementando um mecanismo de polegar para cima/polegares nas respostas.
- Escolhas comparativas: Apresentando os usuários duas saídas diferentes e pedindo que eles escolham o melhor.
Se você não tem dados do usuário, também pode criar um conjunto de dados sintéticos, 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 da HuggingFace: olivermolenschot/alpaca_messages_dpo_test. Se você inspecionar o conjunto de dados, notará que ele contém instruções com respostas escolhidas e rejeitadas – esses são os exemplos bons e ruins. Esses dados foram criados sinteticamente usando GPT-3.5-turbo e GPT-4.
Geralmente, você precisará entre 500 e 1.000 pares de dados, no mínimo, para ter um treinamento eficaz sem ajustar demais. Os maiores conjuntos de dados DPO contêm até 15.000 a 20.000 pares.
Qwen2.5 3b de ajuste fino com axolotl
Usaremos axolotl para ajustar o modelo QWEN2.5 3B, que atualmente está no topo do Openllm Liderboard 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 da 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 da nuvem
Para executar o treinamento, usaremos um serviço de hospedagem em nuvem como Runpod ou Vultr. Aqui está o que você precisará:
- Docker Imagem: Clone the winglian/axolotl-cloud: Imagem principal do docker fornecida pela equipe Axolotl.
- *Requisitos de hardware: uma GPU VRAM de 80 GB (como um nó 1 × A100 PCIE) será mais do que suficiente para esse tamanho de um modelo.
- Armazenamento: 200 GB de armazenamento de volume para acomodar todos os arquivos de que precisamos.
- Versão CUDA: Sua versão CUDA deve ter pelo menos 12.1.
*Esse tipo de treinamento é considerado uma ajuste completa do LLM e, portanto, é muito intensiva em VRAM. Se você deseja executar um treinamento localmente, sem confiar nos hosts da 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.
Etapas para começar a treinar
- Defina o diretório de cache do HuggingFace:
export HF_HOME=/workspace/hfIsso garante que o modelo original download para o nosso armazenamento de volume, que é persistente.
- Criar arquivo de configuração: salve o arquivo config.yml que criamos anteriormente para /workspace/config.yml.
- Comece a treinar:
python -m axolotl.cli.train /workspace/config.ymlE pronto! Seu treinamento deve começar. Após o Axolotl Downloas o modelo e os dados do trens, você deve ver a saída semelhante a isso:
(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 este é um pequeno conjunto de dados de apenas 264 linhas. O modelo de ajuste fino será salvo para /Workspace/DPO-Output.
Enviando o modelo para Huggingface
Você pode fazer upload do seu modelo para Huggingface usando a CLI:
- Instale a cli hub de huss hugging:
pip install huggingface_hub(cli)- Carregue o modelo:
huggingface-cli upload /workspace/dpo-output yourname/yourrepoSubstitua o seu nome/YourRepo pelo seu nome de usuário e nome de repositório do HuggingFace real.
Avaliando seu modelo de ajuste fino
Para avaliação, é recomendável hospedar os modelos originais e ajustados usando uma ferramenta como Inferência de geração de texto (TGI). Em seguida, execute a inferência em ambos os modelos com uma configuração de temperatura de 0 (para garantir saídas determinísticas) e comparar manualmente as respostas dos dois modelos.
Essa 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 idiomas no LLMS.
Conclusão
O ajuste fino de um LLM usando o DPO permite que você personalize os modelos para melhor atender às necessidades do seu aplicativo, mantendo 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 alinha com seus requisitos específicos. Se você deseja ajustar o estilo das respostas ou implementar medidas de segurança, o DPO fornece uma abordagem prática para refinar seu LLM.
Feliz ajuste fino!