Como fazer o ajuste fino de um LLM [e quando usar RAG ou prompts em vez disso]

Fazer o ajuste fino (fine-tuning) de um grande modelo de linguagem (LLM) significa refinar um LLM pré-treinado com um conjunto de dados pequeno e específico para a tarefa, de modo que ele gere resultados que você não conseguiria obter apenas com prompts.

O ajuste fino envolve coletar exemplos de pares de entrada/saída que mostram o comportamento desejado, executar rodadas de treinamento que aproximam os pesos do modelo desses exemplos e comparar o resultado com as saídas do modelo original. Métodos com eficiência de parâmetros, como o LoRA, tornam esse processo barato o suficiente para rodar em uma única GPU.

Se você não estiver satisfeito com as saídas do LLM, refine primeiro seus prompts e a geração aumentada por recuperação (RAG). O ajuste fino muda a forma como o LLM se comporta. Quando você precisa que ele use informações recentes ou proprietárias, prompts e RAG costumam ser uma escolha melhor.

Veja a seguir como fazer o ajuste fino de um LLM passo a passo, os principais métodos de ajuste fino (LoRA e QLoRA) e os desafios e erros que podem comprometer o processo.

O que é o ajuste fino de LLMs e qual é a diferença em relação ao pré-treinamento de LLMs

O pré-treinamento de LLMs desenvolve do zero a capacidade linguística geral de um modelo a partir de um vasto corpus, enquanto o ajuste fino de LLMs adapta um modelo pré-treinado com um pequeno conjunto de dados para uma tarefa específica.

O pré-treinamento de LLMs é a fase que consome muitos recursos e produz um modelo base. O modelo aprende com um amplo corpus de texto, o que lhe dá domínio geral de gramática, fatos e raciocínio, mas nenhuma especialização na sua tarefa.

O ajuste fino de LLMs dá continuidade ao treinamento do modelo base com um conjunto de dados pequeno e selecionado, para que ele produza as saídas desejadas em uma tarefa ou caso de uso específico. Pense em um formato consistente, uma voz ou tom de marca, padrões específicos de um domínio ou chamadas confiáveis de ferramentas e funções.

Quando fazer o ajuste fino de LLMs e quando usar prompts ou RAG

Para melhorar o desempenho do LLM, suba a escada degrau por degrau: prompts -> RAG -> ajuste fino.

Refine seus prompts com instruções mais detalhadas e use RAG para fornecer ao modelo informações atualizadas. Recorra ao ajuste fino apenas quando as melhorias nos prompts e na recuperação não derem resultado.

Quando prompts melhores superam o ajuste fino e quando não são suficientes

Os prompts são a alavanca mais rápida e barata. Em muitos casos, prompts mais precisos e detalhados alcançam as mudanças de comportamento desejadas.

Mas prompts mais longos deixam o trabalho mais lento e mais caro, e não conseguem superar as limitações existentes do modelo.

Sinais de que os prompts podem ter chegado ao limite:

• Novos casos extremos continuam quebrando a saída: por exemplo, o modelo retorna texto corrido quando você precisa de JSON ou sai do tom, e você remenda o prompt a cada novo caso.
• O prompt de sistema não para de crescer: o prompt chega a centenas ou milhares de linhas e fica difícil de gerenciar.
• Você paga por isso em cada chamada: o prompt é reenviado e reprocessado a cada solicitação, então o custo em tokens e a latência aumentam.
• As alterações deixam de fazer diferença: novas instruções não melhoram as saídas.

Mesmo assim, tente primeiro as correções mais baratas no nível do prompt. Use exemplos few-shot para mostrar o padrão ao modelo (pares de entrada/saída), encadeamento de prompts para dividir tarefas difíceis em etapas menores ou hooks de chamada de função para delegar consultas exatas ou cálculos.

Quando o RAG faz mais sentido do que o ajuste fino do modelo

O RAG muda o que o LLM sabe, enquanto o ajuste fino de LLMs muda a forma como ele se comporta. Se a lacuna é de conhecimento, especialmente de um conhecimento que muda com frequência ou que está nos seus próprios documentos, a resposta é o RAG. Se a lacuna é de comportamento, faça o ajuste fino.

O ajuste fino também altera o que um modelo sabe, mas os fatos que ele absorve ficam congelados no momento do treinamento e se desatualizam rapidamente em áreas que evoluem depressa. Além disso, as informações ficam incorporadas aos pesos do modelo, que não guardam nenhum registro de sua origem.

Atualizar os documentos de origem usados por uma camada de recuperação é mais rápido e barato, e ela pode citar as fontes exatas que usou. Isso a torna uma escolha melhor quando você precisa de informações atualizadas e bem fundamentadas.

A desvantagem do RAG? É uma camada extra para construir e manter, e ela adiciona latência.

Na prática, muitas vezes você vai precisar dos dois. Sistemas em produção combinam modelos com ajuste fino e RAG, usando um para garantir comportamento consistente e o outro para obter fatos atuais.

Armadilhas, riscos e desafios comuns do ajuste fino

Mesmo quando o ajuste fino é a ferramenta certa, ele envolve custos e riscos:

• Custo e tempo: reunir dados de treinamento limpos e representativos e arcar com a computação do treinamento sai caro.
• Esquecimento catastrófico: treinado com um conjunto de dados restrito, um modelo pode perder habilidades gerais e desenvolver novos modos de falha, cometendo erros que o modelo base não cometia.
• Sobreajuste (overfitting): com dados insuficientes ou repetitivos demais, o modelo memoriza seus exemplos de treinamento em vez de aprender padrões, então tem bom desempenho nas amostras de treinamento, mas um desempenho fraco com entradas reais.
• Desatualização: o conhecimento incorporado aos pesos envelhece rápido, então você precisa retreinar o modelo com dados novos.
• Obsolescência: quando um modelo mais poderoso é lançado, muitas vezes ele supera de cara o seu modelo ajustado, e você precisa refazer o trabalho.
• Desafios de avaliação e reprodução: é difícil provar que o modelo ajustado supera o modelo base. Além disso, duas execuções de treinamento em GPU com as mesmas configurações podem gerar modelos ligeiramente diferentes.
• Governança de dados: treinar com dados proprietários ou sensíveis levanta questões de privacidade e licenciamento; mais tarde, um modelo pode expor fragmentos dos dados usados em seu treinamento.

Os principais métodos de ajuste fino

Os principais tipos de ajuste fino de LLMs diferem na quantidade do modelo que alteram: o ajuste fino completo retreina o modelo inteiro, enquanto os métodos de ajuste fino com eficiência de parâmetros (PEFT), como LoRA e QLoRA, atualizam apenas parte dos pesos. Os métodos PEFT consomem uma fração da memória exigida pelo ajuste fino completo e, com as configurações certas, podem alcançar os mesmos resultados.

O ajuste fino completo atualiza todos os pesos do modelo. É o método mais caro e o que traz o maior risco de esquecimento catastrófico. Reserve-o para grandes mudanças de comportamento quando você tiver os dados e a capacidade computacional para sustentá-lo.

A alternativa é o ajuste fino com eficiência de parâmetros, ou PEFT. Trata-se de um termo genérico para métodos que congelam a maior parte do modelo e treinam apenas um pequeno conjunto de parâmetros. Ele usa muito menos memória e é menos propenso ao esquecimento, já que o modelo base permanece intacto.

Com ranks baixos, o PEFT aprende menos do que um ajuste fino completo, mas aumentar o rank e ajustar a taxa de aprendizado elimina a maior parte da diferença em tarefas de ajuste por instruções.

Entre os métodos PEFT estão:

• LoRA (Low-Rank Adaptation): o ponto de partida mais comum. Ele congela os pesos originais e treina um pequeno conjunto de parâmetros de adaptadores adicionados, muitas vezes menos de 1% do total, por isso roda em uma única GPU de consumo.
• QLoRA (Quantized Low-Rank Adaptation): comprime o modelo base para precisão de 4 bits antes de aplicar o LoRA, o que permite fazer o ajuste fino de um modelo grande em uma única GPU.

Além desses, usamos métodos de ajuste por instruções e de ajuste por preferências, desde o RLHF (Reinforcement Learning from Human Feedback, aprendizado por reforço com feedback humano) até alternativas mais leves, como Direct Preference Optimization (DPO) e Odds Ratio Preference Optimization (ORPO), para moldar a forma como um modelo segue instruções e se alinha às preferências humanas.

Como fazer o ajuste fino de um LLM passo a passo

Depois de concluir que o ajuste fino de um LLM é a decisão certa, este é o fluxo de trabalho.

Expandir

Etapa 1: defina a tarefa e como você vai medir o sucesso

Decida qual comportamento você quer do LLM e como vai saber que o alcançou.

Defina a tarefa específica que você quer que o modelo ajustado execute, por exemplo, classificar tickets de suporte, resumir contratos em um formato fixo ou gerar código no estilo da sua empresa.

Em seguida, defina o que é sucesso. Entre as opções comuns estão:

• Validade da saída: por exemplo, o resultado é interpretado como JSON válido ou corresponde à estrutura Markdown de que você precisa?
• Pontuações automatizadas: use métricas como BLEU ou ROUGE, que comparam o texto gerado com respostas de referência, ou a acurácia da tarefa em um conjunto rotulado.
• Avaliações humanas: uma rubrica com notas ou de aprovado/reprovado para qualidades que um script avalia mal, como tom ou utilidade.
• Confiabilidade em entradas difíceis: o modelo lida bem com as entradas incomuns que confundiam o modelo base?

Etapa 2: prepare seu conjunto de dados

A qualidade dos dados determina o sucesso do ajuste fino, então dedique esforço para reunir o conjunto de dados de ajuste fino certo.

Formate seus dados como pares de instrução/resposta, em JSONL, em que cada linha contém a entrada (mais qualquer contexto) e a saída exata que você quer receber.

Por exemplo, confira conjuntos de dados públicos de instruções gerais, como o Alpaca-cleaned ou o Dolly, da Databricks, ou o banking77, específico para uma tarefa, que inclui mais de 13.000 consultas reais de suporte rotuladas em 77 intenções.

Para uma tarefa específica, de algumas centenas a alguns milhares de exemplos limpos e variados podem mudar o comportamento, desde que os exemplos reflitam entradas reais de produção, incluindo os casos extremos, e tenham formatação consistente.

Ainda não tem pares de entrada/saída? Monte o conjunto a partir dos dados que você já tem, como tickets de suporte e suas melhores respostas, ou documentos e seus resumos.

Se você tiver apenas as saídas, use um modelo mais poderoso para gerar uma entrada plausível para cada uma, ou escreva à mão um pequeno conjunto inicial e expanda-o com um modelo "professor" maior; depois, mantenha os melhores pares.

Para terminar, divida os dados em conjuntos de treinamento, validação e teste, para poder medir o desempenho em exemplos que o modelo não viu.

Etapa 3: escolha um modelo base e um método

Comece com um modelo de código aberto pequeno, de 3 a 7 bilhões de parâmetros, e um método de ajuste fino com eficiência de parâmetros, como LoRA ou QLoRA.

Famílias abertas como Llama, Mistral e Qwen oferecem uma base sólida que você pode hospedar por conta própria, e os métodos PEFT mantêm baixa a exigência de hardware: o QLoRA quantiza o modelo base para 4 bits, então o ajuste fino de um modelo de 7B exige apenas uma placa de consumo de 16 a 24 GB. O ajuste fino completo do mesmo modelo precisa de muitas vezes essa quantidade de memória.

Etapa 4: defina os hiperparâmetros de treinamento

Estes são os principais parâmetros de ajuste fino de LLMs e os intervalos iniciais sugeridos:

• A taxa de aprendizado controla o tamanho de cada atualização dos pesos. Um estudo de 2024 de Biderman et al. constatou que as melhores taxas do LoRA ficavam cerca de dez vezes acima das do ajuste fino completo, normalmente de 5e-5 a 5e-4, contra 1e-5 a 5e-5. O estudo recomenda testar valores de 1e-5 a 5e-4 e usar o maior valor que mantenha o treinamento estável.
• Tamanho do lote é a quantidade de exemplos com que o modelo aprende antes de cada atualização de pesos. Em uma única GPU, use um lote pequeno por dispositivo, de 1 a 8, e acumulação de gradiente para chegar a um lote efetivo de aproximadamente 16 a 64.
• Número de épocas é o número de vezes que o modelo vê o conjunto de dados completo. Ao treinar o modelo para realizar tarefas específicas, de 1 a 3 épocas é uma boa regra geral, mas execuções com LoRA costumam precisar de mais.
• Rank do LoRA (r) define a capacidade do adaptador, ou seja, o quanto ele consegue aprender. Comece com 8 a 32 para tarefas mais simples e aumente para as mais difíceis: no estudo sobre LoRA de Biderman et al. citado acima, o ajuste por instrução de um modelo de 7B em código precisou de rank 256 para se igualar ao ajuste fino completo, enquanto o rank 64 chegou perto em matemática.
• Comprimento máximo da sequência é a entrada mais longa que a execução vai processar. Defina um valor que cubra seus exemplos mais longos, até o limite da janela de contexto do modelo, pois qualquer entrada mais longa será truncada.
• Aquecimento e agendamento controlam como a taxa de aprendizado aumenta e se altera ao longo da execução. Um aquecimento curto e um decaimento por cosseno são os padrões habituais. No entanto, o estudo de Pareja et al. com modelos pequenos constatou que eliminar o aquecimento não prejudicou as pontuações finais.

Trate esses valores como pontos de partida para uma varredura, não como configurações fixas.

Etapa 5: treine e monitore a perda

Durante o treinamento, acompanhe as curvas de perda de treinamento e de validação para verificar se o processo está funcionando.

A perda mede o quanto as saídas do modelo se distanciam dos seus exemplos e deve cair de forma constante à medida que a execução avança. A perda de treinamento abrange os dados com que ele aprende. A perda de validação é medida nos exemplos reservados.

Se a perda de treinamento e a perda de validação caem juntas, o modelo está aprendendo a generalizar. Se a perda de treinamento continua caindo, mas a perda de validação se estabiliza ou sobe, o modelo está memorizando o conjunto de treinamento em vez de aprender o padrão (overfitting).

Expandir

Etapa 6: avalie e depois implante

Uma perda de treinamento baixa não garante saídas corretas. Por isso, avalie o modelo ajustado com base nos critérios que você definiu na Etapa 1.

Quando o modelo for aprovado, você terá duas formas de implantá-lo:

• Disponibilize o adaptador sobre o modelo base e carregue ambos em tempo de execução; assim, o adaptador continua intercambiável.
• Mescle o adaptador aos pesos do modelo base para obter um único modelo independente, mais simples de hospedar.

Use o Perplexity para dar ao seu LLM acesso a informações atualizadas

O ajuste fino é a escolha certa quando você quer adaptar o comportamento do modelo às suas necessidades.

Se o seu modelo precisa de informações atuais, especialmente informações que mudam rapidamente, você precisa de RAG ou de uma ferramenta de pesquisa de terceiros confiável.

Uma pilha de recuperação personalizada funciona melhor para conjuntos de dados proprietários, como sua wiki interna, histórico de atendimento ao cliente, contratos ou documentação de produtos.

Quando o conhecimento que você quer usar é público, não há necessidade de criar uma camada de recuperação sob medida. O Perplexity é um mecanismo de respostas que fornece respostas com citações clicáveis no próprio texto, extraídas de um índice da web em tempo real. Sua Agent API entrega essas respostas fundamentadas na web e com citações em uma única chamada, para que seu app possa recorrer a fontes atuais.

Perguntas frequentes sobre ajuste fino de LLMs

É possível fazer o ajuste fino de um LLM de graça?

Sim, é possível fazer o ajuste fino de um LLM aberto pequeno de graça. Por exemplo, o nível gratuito do Google Colab oferece GPU suficiente para executar QLoRA em um modelo de 3B a 8B, o que é mais do que suficiente para uma tarefa específica. Você começa a pagar quando precisa de mais memória, execuções mais longas ou um modelo base maior do que o nível gratuito comporta.

Você precisa ter sua própria GPU ou pode fazer o ajuste fino na nuvem?

Você não precisa ter uma GPU própria para fazer o ajuste fino de LLMs. Serviços gerenciados e provedores de GPU em nuvem alugam o hardware por hora, então uma única GPU alugada dá conta de uma execução de QLoRA em um modelo pequeno. Comprar uma GPU só compensa se você faz ajuste fino com frequência ou precisa manter todos os seus dados nas suas próprias máquinas.

Quanto tempo leva o ajuste fino de LLMs?

Para um LLM pequeno, uma execução pode terminar em alguns minutos ou em poucas horas, dependendo do tamanho do conjunto de dados e do hardware. A Oumi, por exemplo, fez o ajuste fino completo de um modelo de 0,8B em pouco mais de uma hora em sua plataforma hospedada.

Modelos maiores ou dezenas de milhares de exemplos elevam esse tempo para um dia ou mais: as execuções de LoRA da Emburse em um modelo de 7B levaram 8 horas para 5.000 exemplos e cerca de 30 horas para 50.000 em uma única GPU de 40 GB.

É possível continuar atualizando um modelo ajustado à medida que seus dados mudam?

Você pode refazer o ajuste fino com dados novos, mas cada rodada consome computação e traz o risco de esquecimento catastrófico. Para conhecimentos que mudam com frequência, RAG costuma ser a melhor solução, já que você atualiza os documentos de origem em vez de treinar o modelo novamente.