Um guia completo para ajuste fino de modelos de linguagem grande

Modelos de grande linguagem (LLMs) como GPT-4, LaMDA, PaLM e outros conquistaram o mundo com sua notável capacidade de compreender e gerar textos semelhantes aos humanos sobre uma vasta gama de tópicos. Esses modelos são pré-treinados em enormes conjuntos de dados que compreendem bilhões de palavras da Internet, livros e outras fontes.

Esta fase de pré-treinamento imbui os modelos de amplo conhecimento geral sobre linguagem, tópicos, habilidades de raciocínio e até mesmo certos preconceitos presentes nos dados de treinamento. No entanto, apesar da sua incrível amplitude, estes LLMs pré-treinados carecem de conhecimentos especializados para domínios ou tarefas específicas.

É aqui que entra o ajuste fino – o processo de adaptação de um LLM pré-treinado para se destacar em um aplicativo ou caso de uso específico. Ao treinar ainda mais o modelo em um conjunto de dados menor e específico para tarefas, podemos ajustar seus recursos para alinhá-los com as nuances e requisitos desse domínio.

O ajuste fino é análogo à transferência do amplo conhecimento de um generalista altamente qualificado para criar um especialista no assunto especializado em um determinado campo. Neste guia, exploraremos o que é, por que e como fazer o ajuste fino de LLMs.

Ajustando modelos de linguagem grande

O que é ajuste fino?

Em seu núcleo, afinação envolve pegar um grande modelo pré-treinado e atualizar seus parâmetros usando uma segunda fase de treinamento em um conjunto de dados adaptado à sua tarefa ou domínio alvo. Isso permite que o modelo aprenda e internalize as nuances, padrões e objetivos específicos dessa área mais restrita.

Embora o pré-treinamento capte uma ampla compreensão do idioma a partir de um enorme e diversificado corpus de texto, o ajuste fino especializa essa competência geral. É o mesmo que pegar um homem da Renascença e transformá-lo em um especialista do setor.

Os pesos do modelo pré-treinado, que codificam seu conhecimento geral, são utilizados como ponto de partida ou inicialização para o processo de ajuste fino. O modelo é então treinado ainda mais, mas desta vez com exemplos diretamente relevantes para a aplicação final.

Ao expor o modelo a essa distribuição de dados especializada e ajustar os parâmetros do modelo de acordo, tornamos o LLM mais preciso e eficaz para o caso de uso alvo, ao mesmo tempo que nos beneficiamos dos amplos recursos pré-treinados como base.

Por que ajustar LLMs?

Existem vários motivos principais pelos quais você pode querer ajustar um modelo de linguagem grande:

1. Personalização de Domínio: Cada campo, do jurídico à medicina e à engenharia de software, tem suas próprias convenções de linguagem, jargões e contextos diferenciados. O ajuste fino permite personalizar um modelo geral para compreender e produzir texto adaptado ao domínio específico.
2. Especialização em Tarefas: LLMs podem ser ajustados para várias tarefas de processamento de linguagem natural, como resumo de texto, tradução automática, resposta a perguntas e assim por diante. Esta especialização aumenta o desempenho na tarefa alvo.
3. Conformidade de dados: setores altamente regulamentados, como saúde e finanças, têm requisitos rígidos de privacidade de dados. O ajuste fino permite treinar LLMs em dados organizacionais proprietários, ao mesmo tempo que protege informações confidenciais.
4. Dados rotulados limitados: Obter grandes conjuntos de dados rotulados para modelos de treinamento do zero pode ser um desafio. O ajuste fino permite alcançar um forte desempenho de tarefas a partir de exemplos supervisionados limitados, aproveitando os recursos do modelo pré-treinado.
5. Atualização de modelo: à medida que novos dados são disponibilizados ao longo do tempo em um domínio, você pode ajustar ainda mais os modelos para incorporar os conhecimentos e capacidades mais recentes.
6. Mitigando preconceitos: Os LLMs podem captar preconceitos sociais a partir de amplos dados pré-treinamento. O ajuste fino em conjuntos de dados selecionados pode ajudar a reduzir e corrigir esses preconceitos indesejáveis.

Em essência, o ajuste fino preenche a lacuna entre um modelo geral e amplo e os requisitos específicos de uma aplicação especializada. Ele aumenta a precisão, a segurança e a relevância dos resultados do modelo para casos de uso direcionados.

Ajustando modelos de linguagem grande

Abordagens de ajuste fino

Existem duas estratégias principais quando se trata de ajustar grandes modelos de linguagem:

1) Ajuste fino do modelo completo

Na abordagem de ajuste fino completo, todos os parâmetros (pesos e vieses) do modelo pré-treinado são atualizados durante a segunda fase de treinamento. O modelo é exposto ao conjunto de dados rotulado específico da tarefa e o processo de treinamento padrão otimiza todo o modelo para essa distribuição de dados.

Isso permite que o modelo faça ajustes mais abrangentes e se adapte holisticamente à tarefa ou domínio alvo. No entanto, o ajuste fino completo tem algumas desvantagens:

• Requer recursos computacionais significativos e tempo para treinar, semelhante à fase de pré-treinamento.
• Os requisitos de armazenamento são altos, pois você precisa manter uma cópia separada e ajustada do modelo para cada tarefa.
• Existe o risco de “esquecimento catastrófico”, onde o ajuste fino faz com que o modelo perca algumas capacidades gerais aprendidas durante o pré-treinamento.

Apesar destas limitações, o ajuste fino completo continua a ser uma técnica poderosa e amplamente utilizada quando os recursos permitem e a tarefa alvo diverge significativamente da linguagem geral.

2) Métodos eficientes de ajuste fino

Para superar os desafios computacionais do ajuste fino completo, os pesquisadores desenvolveram estratégias eficientes que atualizam apenas um pequeno subconjunto dos parâmetros do modelo durante o ajuste fino. Estas técnicas parametricamente eficientes estabelecem um equilíbrio entre especialização e redução dos requisitos de recursos.

Alguns métodos populares de ajuste fino eficientes incluem:

Ajuste de prefixo: Aqui, um pequeno número de vetores ou “prefixos” específicos da tarefa são introduzidos e treinados para condicionar a atenção do modelo pré-treinado para a tarefa alvo. Somente esses prefixos são atualizados durante o ajuste fino.

LoRA (adaptação de baixa classificação): LoRA injeta matrizes treináveis ​​de baixa classificação em cada camada do modelo pré-treinado durante o ajuste fino. Esses pequenos ajustes de classificação ajudam a especializar o modelo com muito menos parâmetros treináveis ​​do que o ajuste fino completo.

Claro, posso fornecer uma explicação detalhada do LoRA (Low-Rank Adaptation) junto com a formulação matemática e exemplos de código. LoRA é uma técnica popular de ajuste fino com eficiência de parâmetros (PEFT) que ganhou força significativa no campo de adaptação de modelos de linguagem grande (LLM).

O que é LoRA?

LoRA é um método de ajuste fino que introduz um pequeno número de parâmetros treináveis ​​ao LLM pré-treinado, permitindo uma adaptação eficiente às tarefas posteriores, preservando a maior parte do conhecimento do modelo original. Em vez de ajustar todos os parâmetros do LLM, o LoRA injeta matrizes de baixa classificação específicas da tarefa nas camadas do modelo, permitindo economias computacionais e de memória significativas durante o processo de ajuste fino.

Formulação Matemática

LoRA (Low-Rank Adaptation) é um método de ajuste fino para grandes modelos de linguagem (LLMs) que introduz uma atualização de baixa classificação nas matrizes de peso. Para uma matriz de peso 0∈W0 ∈Rd×k, LoRA adiciona uma matriz de classificação baixa $BA$, com A∈Rr×k e B∈Rd×r, Onde $r$ é a classificação. Esta abordagem reduz significativamente o número de parâmetros treináveis, permitindo uma adaptação eficiente às tarefas posteriores com recursos computacionais mínimos. A matriz de pesos atualizada é dada por W=W0 +B⋅A.

Esta atualização de classificação baixa pode ser interpretada como uma modificação da matriz de peso original $W_{0}$ adicionando uma matriz de classificação baixa $BA$. A principal vantagem desta formulação é que, em vez de atualizar todos os parâmetros $d \times k$ em $W_{0}$, LoRA só precisa otimizar os parâmetros $r \times (d + k)$ em $A$ e $B $, reduzindo significativamente o número de parâmetros treináveis.

Aqui está um exemplo em Python usando o peft biblioteca para aplicar LoRA a um LLM pré-treinado para classificação de texto:

</div>
<div>
<div class="code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><code class="language-python" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><span class="token" data-darkreader-inline-color="">from</span> transformers <span class="token" data-darkreader-inline-color="">import</span> AutoModelForSequenceClassification
</code></div>
<div class="code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><code class="language-python" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><span class="token" data-darkreader-inline-color="">from</span> peft <span class="token" data-darkreader-inline-color="">import</span> get_peft_model<span class="token" data-darkreader-inline-color="">,</span> LoraConfig<span class="token" data-darkreader-inline-color="">,</span> TaskType
</code></div>
<div data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""></div>
<div class="code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><code class="language-python" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><span class="token" data-darkreader-inline-color=""># Load pre-trained model</span>
</code></div>
<div class="code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><code class="language-python" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color="">model <span class="token" data-darkreader-inline-color="">=</span> AutoModelForSequenceClassification<span class="token" data-darkreader-inline-color="">.</span>from_pretrained<span class="token" data-darkreader-inline-color="">(</span><span class="token" data-darkreader-inline-color="">"bert-base-uncased"</span><span class="token" data-darkreader-inline-color="">,</span> num_labels<span class="token" data-darkreader-inline-color="">=</span><span class="token" data-darkreader-inline-color="">2</span><span class="token" data-darkreader-inline-color="">)</span>
</code></div>
<div data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""></div>
<div class="code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><code class="language-python" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><span class="token" data-darkreader-inline-color=""># Define LoRA configuration</span>
</code></div>
<div class="code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><code class="language-python" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color="">peft_config <span class="token" data-darkreader-inline-color="">=</span> LoraConfig<span class="token" data-darkreader-inline-color="">(</span>task_type<span class="token" data-darkreader-inline-color="">=</span>TaskType<span class="token" data-darkreader-inline-color="">.</span>SEQ_CLS<span class="token" data-darkreader-inline-color="">, </span>r<span class="token" data-darkreader-inline-color="">=</span><span class="token" data-darkreader-inline-color="">8</span><span class="token" data-darkreader-inline-color="">,</span>  <span class="token" data-darkreader-inline-color=""># Rank of the low-rank update</span>
lora_alpha<span class="token" data-darkreader-inline-color="">=</span><span class="token" data-darkreader-inline-color="">16</span><span class="token" data-darkreader-inline-color="">,</span></code><code class="language-python" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><span class="token" data-darkreader-inline-color=""># Scaling factor for the low-rank update</span>
</code></div>
<div class="code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><code class="language-python" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color="">    target_modules<span class="token" data-darkreader-inline-color="">=</span><span class="token" data-darkreader-inline-color="">[</span><span class="token" data-darkreader-inline-color="">"q_lin"</span><span class="token" data-darkreader-inline-color="">,</span> <span class="token" data-darkreader-inline-color="">"v_lin"</span><span class="token" data-darkreader-inline-color="">]</span><span class="token" data-darkreader-inline-color="">,</span>  <span class="token" data-darkreader-inline-color=""># Apply LoRA to the query and value layers</span>
<span class="token" data-darkreader-inline-color="">)</span>
</code></div>
<div data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""></div>
<div class="code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><code class="language-python" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><span class="token" data-darkreader-inline-color=""># Create the LoRA-enabled model</span>
</code></div>
<div class="code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><code class="language-python" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color="">model <span class="token" data-darkreader-inline-color="">=</span> get_peft_model<span class="token" data-darkreader-inline-color="">(</span>model<span class="token" data-darkreader-inline-color="">,</span> peft_config<span class="token" data-darkreader-inline-color="">)</span>
</code></div>
<div class="code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><code class="language-python" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><span class="token" data-darkreader-inline-color=""># Fine-tune the model with LoRA</span>
</code></div>
<div data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""></div>
<div class="code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><code class="language-python" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><span class="token" data-darkreader-inline-color=""># ... (training code omitted for brevity)</span></code></div>
</div>
<div data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color="">

Neste exemplo, carregamos um modelo BERT pré-treinado para classificação de sequência e definimos uma configuração LoRA. O r parâmetro especifica a classificação da atualização de classificação inferior e lora_alpha é um fator de escala para a atualização. O target_modules O parâmetro indica quais camadas do modelo devem receber as atualizações de classificação inferior. Depois de criar o modelo habilitado para LoRA, podemos prosseguir com o processo de ajuste fino usando o procedimento de treinamento padrão.

Camadas adaptadoras: semelhante ao LoRA, mas em vez de atualizações de baixa classificação, camadas finas de “adaptador” são inseridas em cada bloco transformador do modelo pré-treinado. Somente os parâmetros dessas novas camadas compactas são treinados.

Ajuste rápido: esta abordagem mantém o modelo pré-treinado completamente congelado. Em vez disso, incorporações “rápidas” treináveis ​​são introduzidas como entrada para ativar o conhecimento pré-treinado do modelo para a tarefa alvo.

Esses métodos eficientes podem fornecer reduções de computação de até 100 vezes em comparação com o ajuste fino completo, ao mesmo tempo em que alcançam desempenho competitivo em muitas tarefas. Eles também reduzem as necessidades de armazenamento, evitando a duplicação completa do modelo.

No entanto, o seu desempenho pode ficar aquém do ajuste fino completo para tarefas que são muito diferentes da linguagem geral ou que exigem uma especialização mais holística.

O processo de ajuste fino

Independentemente da estratégia de ajuste fino, o processo geral de especialização de um LLM segue uma estrutura geral:

1. Preparação do conjunto de dados: você precisará obter ou criar um conjunto de dados rotulado que mapeie entradas (solicitações) para saídas desejadas para sua tarefa de destino. Para tarefas de geração de texto, como resumo, este seria o texto de entrada para pares de saída resumidos.
2. Divisão do conjunto de dados: seguindo as práticas recomendadas, divida seu conjunto de dados rotulado em conjuntos de treinamento, validação e teste. Isso separa os dados para treinamento do modelo, ajuste de hiperparâmetros e avaliação final.
3. Ajuste de hiperparâmetros: parâmetros como taxa de aprendizado, tamanho do lote e cronograma de treinamento precisam ser ajustados para o ajuste mais eficaz dos seus dados. Isso geralmente envolve um pequeno conjunto de validação.
4. Treinamento de modelo: usando os hiperparâmetros ajustados, execute o processo de otimização de ajuste fino no conjunto de treinamento completo até que o desempenho do modelo no conjunto de validação pare de melhorar (parada antecipada).
5. Avaliação : Avalie o desempenho do modelo ajustado no conjunto de testes mantidos, de preferência incluindo exemplos do mundo real para o caso de uso alvo, para estimar a eficácia no mundo real.
6. Implantação e monitoramento: Uma vez satisfatório, o modelo ajustado pode ser implantado para inferência sobre novos insumos. É crucial monitorar seu desempenho e precisão ao longo do tempo para detectar desvios de conceito.

Embora isso descreva o processo geral, muitas nuances podem impactar o sucesso do ajuste fino para um LLM ou tarefa específica. Estratégias como aprendizagem curricular, ajuste fino de múltiplas tarefas e solicitações rápidas podem aumentar ainda mais o desempenho.

Além disso, métodos eficientes de ajuste fino envolvem considerações extras. Por exemplo, LoRA requer técnicas como condicionar as saídas do modelo pré-treinado por meio de uma camada de combinação. O ajuste de prompts precisa de prompts cuidadosamente projetados para ativar os comportamentos corretos.

Ajuste fino avançado: incorporando feedback humano

Embora o ajuste fino supervisionado padrão usando conjuntos de dados rotulados seja eficaz, uma fronteira interessante é treinar LLMs diretamente usando preferências humanas e feedback. Esta abordagem humana aproveita técnicas de aprendizagem por reforço:

POP (Otimização de Política Proximal): Aqui, o LLM é tratado como um agente de aprendizagem por reforço, sendo seus resultados “ações”. Um modelo de recompensa é treinado para prever classificações humanas ou índices de qualidade para esses resultados. O PPO então otimiza o LLM para gerar resultados que maximizam as pontuações do modelo de recompensa.

RLHF (Aprendizagem por Reforço com Feedback Humano): Isso amplia o PPO ao incorporar diretamente o feedback humano no processo de aprendizagem. Em vez de um modelo de recompensa fixa, as recompensas provêm de avaliações humanas iterativas sobre os resultados do LLM durante o ajuste fino.

Embora computacionalmente intensivos, esses métodos permitem moldar o comportamento do LLM com mais precisão com base nas características desejadas avaliadas por humanos, além do que pode ser capturado em um conjunto de dados estáticos.

Empresas como a Anthropic usaram o RLHF para imbuir seus modelos de linguagem como o de Claude com maior veracidade, ética e consciência de segurança, além da simples competência na tarefa.

Riscos e limitações potenciais

Embora imensamente poderosos, os LLMs de ajuste fino apresentam riscos que devem ser gerenciados com cuidado:

Amplificação de polarização: Se os dados de ajuste fino contiverem preconceitos sociais em torno de gênero, raça, idade ou outros atributos, o modelo poderá amplificar esses preconceitos indesejáveis. A curadoria de conjuntos de dados representativos e imparciais é crucial.

Deriva factual: Mesmo após o ajuste fino em dados de alta qualidade, os modelos de linguagem podem “alucinar” fatos incorretos ou resultados inconsistentes com os exemplos de treinamento durante conversas ou prompts mais longos. Métodos de recuperação de fatos podem ser necessários.

Desafios de Escalabilidade: O ajuste fino completo de modelos enormes como o GPT-3 requer imensos recursos computacionais que podem ser inviáveis ​​para muitas organizações. O ajuste fino eficiente atenua parcialmente isso, mas tem compensações.

Esquecimento catastrófico: Durante o ajuste fino completo, os modelos podem sofrer um esquecimento catastrófico, onde perdem algumas capacidades gerais aprendidas durante o pré-treinamento. O aprendizado multitarefa pode ser necessário.

Riscos de IP e privacidade: Dados proprietários usados ​​para ajuste fino podem vazar para resultados de modelos de linguagem divulgados publicamente, representando riscos. Técnicas diferenciais de mitigação de riscos de privacidade e informações são áreas ativas de pesquisa.

No geral, embora excepcionalmente útil, o ajuste fino é um processo diferenciado que exige cuidado com a qualidade dos dados, considerações de identidade, mitigação de riscos e equilíbrio entre compensações entre desempenho e eficiência com base nos requisitos do caso de uso.

O futuro: personalização do modelo de linguagem em escala

Olhando para o futuro, os avanços nas técnicas de ajuste fino e adaptação de modelos serão cruciais para desbloquear todo o potencial de grandes modelos de linguagem em diversas aplicações e domínios.

Métodos mais eficientes que permitam o ajuste fino de modelos ainda maiores, como o PaLM, com recursos limitados, poderiam democratizar o acesso. Automatizar pipelines de criação de conjuntos de dados e engenharia imediata poderia agilizar a especialização.

Técnicas auto-supervisionadas para ajuste fino a partir de dados brutos sem rótulos podem abrir novas fronteiras. E abordagens composicionais para combinar submodelos ajustados e treinados em diferentes tarefas ou dados poderiam permitir a construção de modelos altamente personalizados sob demanda.

Em última análise, à medida que os LLMs se tornam mais onipresentes, a capacidade de personalizá-los e especializá-los perfeitamente para cada caso de uso concebível será crítica. O ajuste fino e as estratégias de adaptação de modelos relacionados são etapas essenciais para concretizar a visão de grandes modelos de linguagem como assistentes de IA flexíveis, seguros e poderosos, aumentando as capacidades humanas em todos os domínios e empreendimentos.