Modelos e plataformas de IA

Um Guia Completo para Fine-Tuning de Modelos de Linguagem Grande

Publicado em 25 de março de 2024

Atualizado em 22 de maio de 2026

Por

Aayush Mittal Mittal

Adicione Unite.AI às suas fontes preferidas no Google

Modelos de linguagem grande (LLMs) como GPT-4, LaMDA, PaLM e outros conquistaram o mundo com sua capacidade notável de entender e gerar texto semelhante ao humano em uma ampla gama de tópicos. Esses modelos são pré-treinados em conjuntos de dados massivos que compreendem bilhões de palavras da internet, livros e outras fontes.

Essa fase de pré-treinamento infunde nos modelos um conhecimento geral extensivo sobre linguagem, tópicos, habilidades de raciocínio e até certos vieses presentes nos dados de treinamento. No entanto, apesar de sua incrível amplitude, esses LLMs pré-treinados carecem de especialização para domínios ou tarefas específicas.

Aqui é onde entra o fine-tuning – o processo de adaptar um LLM pré-treinado para excelar em uma aplicação ou caso de uso particular. Ao treinar o modelo ainda mais em um conjunto de dados menor e específico da tarefa, podemos ajustar suas capacidades para alinhar com as nuances e requisitos desse domínio.

O fine-tuning é análogo à transferência do conhecimento amplo de um generalista altamente educado para criar um especialista em matéria específica. Neste guia, exploraremos os quês, porquês e como do fine-tuning de LLMs.

Fine-tuning de Modelos de Linguagem Grande

O que é Fine-Tuning?

Em sua essência, fine-tuning envolve pegar um modelo grande pré-treinado e atualizar seus parâmetros usando uma segunda fase de treinamento em um conjunto de dados personalizado para a tarefa ou domínio alvo. Isso permite que o modelo aprenda e internalize as nuances, padrões e objetivos específicos daquela área mais estreita.

Enquanto o pré-treinamento captura a compreensão geral da linguagem de um vasto e diversificado corpus de texto, o fine-tuning especializa essa competência geral. É semelhante a transformar um homem renascentista em um especialista da indústria.

Os pesos do modelo pré-treinado, que codificam seu conhecimento geral, são usados como o ponto de partida ou inicialização para o processo de fine-tuning. O modelo é então treinado ainda mais, mas desta vez em 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, enquanto ainda nos beneficiamos das capacidades pré-treinadas como base.

Por que Fine-Tuning LLMs?

Há várias razões principais pelas quais você pode querer fine-tuning um modelo de linguagem grande:

Customização de Domínio: Cada campo, desde jurídico até medicina e engenharia de software, tem suas próprias convenções linguísticas nuanciadas, jargões e contextos. O fine-tuning permite personalizar um modelo geral para entender e produzir texto adaptado ao domínio específico.
Especialização de Tarefa: LLMs podem ser fine-tuned para várias tarefas de processamento de linguagem natural, como resumo de texto, tradução automática, resposta a perguntas, etc. Essa especialização aumenta o desempenho na tarefa alvo.
Conformidade de Dados: Indústrias altamente regulamentadas, como saúde e finanças, têm requisitos rigorosos de privacidade de dados. O fine-tuning permite treinar LLMs em dados organizacionais proprietários, protegendo informações sensíveis.
Dados Rotulados Limitados: Obter conjuntos de dados grandes e rotulados para treinar modelos do zero pode ser desafiador. O fine-tuning permite alcançar um desempenho forte na tarefa com exemplos supervisionados limitados, aproveitando as capacidades pré-treinadas do modelo.
Atualização do Modelo: À medida que novos dados se tornam disponíveis ao longo do tempo em um domínio, você pode fine-tuning os modelos ainda mais para incorporar os conhecimentos e capacidades mais recentes.
Mitigação de Vieses: LLMs podem capturar vieses sociais dos dados de pré-treinamento amplos. O fine-tuning em conjuntos de dados curados pode ajudar a reduzir e corrigir esses vieses indesejáveis.

Em essência, o fine-tuning ponteia a lacuna entre um modelo geral, amplo, e os requisitos focados de uma aplicação especializada. Ele melhora a precisão, segurança e relevância das saídas do modelo para casos de uso direcionados.

Fine-tuning de Modelos de Linguagem Grande

O diagrama fornecido descreve o processo de implementação e utilização de modelos de linguagem grande (LLMs) para aplicações empresariais. Inicialmente, um modelo pré-treinado como o T5 é alimentado com dados estruturados e não estruturados da empresa, que podem vir em vários formatos, como CSV ou JSON. Esses dados passam por processos de fine-tuning supervisionados, não supervisionados ou de transferência, melhorando a relevância do modelo para as necessidades específicas da empresa.

Uma vez que o modelo é fine-tuned com os dados da empresa, seus pesos são atualizados de acordo. O modelo treinado então itera por ciclos de treinamento adicionais, melhorando continuamente suas respostas ao longo do tempo com novos dados da empresa. O processo é iterativo e dinâmico, com o modelo aprendendo e se retraindo para se adaptar a padrões de dados em evolução.

A saída desse modelo treinado — tokens e embeddings que representam palavras — é então implantada para várias aplicações empresariais. Essas aplicações podem variar desde chatbots até saúde, cada uma exigindo que o modelo entenda e responda a consultas específicas da indústria. Na área financeira, as aplicações incluem detecção de fraude e análise de ameaças; na saúde, os modelos podem ajudar com consultas de pacientes e diagnósticos.

A capacidade do modelo treinado de processar e responder a novos dados da empresa ao longo do tempo assegura que sua utilidade seja sustentada e cresça. Como resultado, os usuários empresariais podem interagir com o modelo por meio de aplicações, fazendo perguntas e recebendo respostas informadas que refletem o treinamento e o fine-tuning do modelo em dados específicos do domínio.

Essa infraestrutura suporta uma ampla gama de aplicações empresariais, demonstrando a versatilidade e adaptabilidade dos LLMs quando implementados e mantidos corretamente dentro de um contexto empresarial.

Abordagens de Fine-Tuning

Existem duas estratégias principais quando se trata de fine-tuning de modelos de linguagem grande:

1) Fine-Tuning Completo do Modelo

Na abordagem de fine-tuning 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 rotulados específico da tarefa, e o processo de treinamento padrão otimiza o modelo inteiro 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 fine-tuning 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 é necessário manter uma cópia separada do modelo fine-tuned para cada tarefa.
Há o risco de “esquecimento catastrófico”, onde o fine-tuning causa a perda de algumas capacidades gerais aprendidas durante o pré-treinamento.

Apesar dessas limitações, o fine-tuning completo permanece uma técnica poderosa e amplamente usada quando os recursos permitem e a tarefa alvo diverge significativamente da linguagem geral.

2) Métodos Eficientes de Fine-Tuning

Para superar os desafios computacionais do fine-tuning completo, os pesquisadores desenvolveram estratégias eficientes que atualizam apenas uma pequena subconjunto dos parâmetros do modelo durante o fine-tuning. Essas técnicas parametricamente eficientes equilibram a especialização e a redução dos requisitos de recursos.

Alguns métodos eficientes de fine-tuning populares incluem:

Prefix-Tuning: 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. Apenas esses prefixos são atualizados durante o fine-tuning.

LoRA (Adaptação de Baixa Ordem): LoRA injeta matrizes de baixa ordem treináveis em cada camada do modelo pré-treinado durante o fine-tuning. Essas pequenas ajustes de ordem baixa ajudam a especializar o modelo com muito menos parâmetros treináveis do que o fine-tuning completo.

Claro, posso fornecer uma explicação detalhada da LoRA (Adaptação de Baixa Ordem) juntamente com a formulação matemática e exemplos de código. A LoRA é uma técnica popular de fine-tuning eficiente (PEFT) que ganhou destaque significativo no campo de adaptação de modelos de linguagem grande (LLM).

O que é LoRA?

A LoRA é um método de fine-tuning que introduz um pequeno número de parâmetros treináveis no modelo pré-treinado, permitindo uma adaptação eficiente para tarefas downstream, preservando a maior parte do conhecimento original do modelo. Em vez de fine-tuning todos os parâmetros do LLM, a LoRA injeta matrizes de baixa ordem específicas da tarefa nas camadas do modelo, permitindo economia significativa de computação e memória durante o processo de fine-tuning.

Formulação Matemática

LoRA (Adaptação de Baixa Ordem) é um método de fine-tuning para modelos de linguagem grande (LLMs) que introduz uma atualização de baixa ordem nas matrizes de pesos. Para uma matriz de pesos $W_{0} \in R^{d \times k}, a LoRA adiciona uma matriz de baixa ordem B A, com A \in R^{r \times k} e B \in R^{d \times r}, onde r é a ordem. Essa abordagem reduz significativamente o número de parâmetros treináveis, permitindo uma adaptação eficiente para tarefas downstream com recursos computacionais mínimos. A matriz de pesos atualizada é dada por W = W_{0} + B \cdot A .$

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

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

&amp;lt;/div&amp;gt;
&amp;lt;div&amp;gt;
&amp;lt;div class=&quot;code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;code class=&quot;language-python&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;from&amp;lt;/span&amp;gt; transformers &amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;import&amp;lt;/span&amp;gt; AutoModelForSequenceClassification
&amp;lt;/code&amp;gt;&amp;lt;/div&amp;gt;
&amp;lt;div class=&quot;code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;code class=&quot;language-python&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;from&amp;lt;/span&amp;gt; peft &amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;import&amp;lt;/span&amp;gt; get_peft_model&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;,&amp;lt;/span&amp;gt; LoraConfig&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;,&amp;lt;/span&amp;gt; TaskType
&amp;lt;/code&amp;gt;&amp;lt;/div&amp;gt;
&amp;lt;div data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;/div&amp;gt;
&amp;lt;div class=&quot;code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;code class=&quot;language-python&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;# Carregar modelo pré-treinado&amp;lt;/span&amp;gt;
&amp;lt;/code&amp;gt;&amp;lt;/div&amp;gt;
&amp;lt;div class=&quot;code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;code class=&quot;language-python&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;model &amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;=&amp;lt;/span&amp;gt; AutoModelForSequenceClassification&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;.&amp;lt;/span&amp;gt;from_pretrained&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;(&amp;lt;/span&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&quot;bert-base-uncased&quot;&amp;lt;/span&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;,&amp;lt;/span&amp;gt; num_labels&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;=&amp;lt;/span&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;2&amp;lt;/span&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;)&amp;lt;/span&amp;gt;
&amp;lt;/code&amp;gt;&amp;lt;/div&amp;gt;
&amp;lt;div data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;/div&amp;gt;
&amp;lt;div class=&quot;code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;code class=&quot;language-python&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;# Definir configuração LoRA&amp;lt;/span&amp;gt;
&amp;lt;/code&amp;gt;&amp;lt;/div&amp;gt;
&amp;lt;div class=&quot;code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;code class=&quot;language-python&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;peft_config &amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;=&amp;lt;/span&amp;gt; LoraConfig&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;(&amp;lt;/span&amp;gt;task_type&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;=&amp;lt;/span&amp;gt;TaskType&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;.&amp;lt;/span&amp;gt;SEQ_CLS&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;, &amp;lt;/span&amp;gt;r&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;=&amp;lt;/span&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;8&amp;lt;/span&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;,&amp;lt;/span&amp;gt; &amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;# Ordem da atualização de baixa ordem&amp;lt;/span&amp;gt;
lora_alpha&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;=&amp;lt;/span&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;16&amp;lt;/span&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;,&amp;lt;/span&amp;gt;&amp;lt;/code&amp;gt;&amp;lt;code class=&quot;language-python&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;# Fator de escala para a atualização de baixa ordem&amp;lt;/span&amp;gt;
&amp;lt;/code&amp;gt;&amp;lt;/div&amp;gt;
&amp;lt;div class=&quot;code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;code class=&quot;language-python&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt; target_modules&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;=&amp;lt;/span&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;[&amp;lt;/span&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&quot;q_lin&quot;&amp;lt;/span&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;,&amp;lt;/span&amp;gt; &amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&quot;v_lin&quot;&amp;lt;/span&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;]&amp;lt;/span&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;,&amp;lt;/span&amp;gt; &amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;# Aplicar LoRA às camadas de consulta e valor&amp;lt;/span&amp;gt;
&amp;lt;/code&amp;gt;&amp;lt;/div&amp;gt;
&amp;lt;div data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;/div&amp;gt;
&amp;lt;div class=&quot;code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;code class=&quot;language-python&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;# Criar o modelo LoRA&amp;lt;/span&amp;gt;
&amp;lt;/code&amp;gt;&amp;lt;/div&amp;gt;
&amp;lt;div class=&quot;code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;code class=&quot;language-python&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;model &amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;=&amp;lt;/span&amp;gt; get_peft_model&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;(&amp;lt;/span&amp;gt;model&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;,&amp;lt;/span&amp;gt; peft_config&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;)&amp;lt;/span&amp;gt;
&amp;lt;/code&amp;gt;&amp;lt;/div&amp;gt;
&amp;lt;div class=&quot;code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;code class=&quot;language-python&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;# Fine-tuning do modelo com LoRA&amp;lt;/span&amp;gt;
&amp;lt;/code&amp;gt;&amp;lt;/div&amp;gt;
&amp;lt;div data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;/div&amp;gt;
&amp;lt;div class=&quot;code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;code class=&quot;language-python&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;# ... (código de treinamento omitido por brevidade)&amp;lt;/span&amp;gt;&amp;lt;/code&amp;gt;&amp;lt;/div&amp;gt;
&amp;lt;/div&amp;gt;
&amp;lt;div data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;

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

Camadas de Adaptador: Semelhante à LoRA, mas em vez de atualizações de baixa ordem, camadas de adaptador finas são inseridas dentro de cada bloco de transformador do modelo pré-treinado. Apenas os parâmetros dessas poucas novas camadas compactas são treinados.

Ajuste de Prompt: Essa abordagem mantém o modelo pré-treinado completamente congelado. Em vez disso, embeddings de prompt treináveis são introduzidos como entrada para ativar o conhecimento pré-treinado do modelo para a tarefa alvo.

Esses métodos eficientes podem fornecer até 100x de redução de computação em comparação com o fine-tuning completo, enquanto ainda alcançam um desempenho competitivo em muitas tarefas. Eles também reduzem as necessidades de armazenamento, evitando a duplicação completa do modelo.

No entanto, seu desempenho pode ficar atrás do fine-tuning completo para tarefas que são muito diferentes da linguagem geral ou que exigem uma especialização mais holística.

O Processo de Fine-Tuning

Independentemente da estratégia de fine-tuning, o processo geral para especializar um LLM segue um framework geral:

Preparação do Conjunto de Dados: Você precisará obter ou criar um conjunto de dados rotulado que mapeie entradas (prompt) para saídas desejadas para a tarefa alvo. Para tarefas de geração de texto, como resumo, isso seria pares de texto de entrada para resumo de saída.
Divisão do Conjunto de Dados: Seguindo as melhores práticas, divida o 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.
Ajuste de Hiperparâmetros: Parâmetros como taxa de aprendizado, tamanho do lote e cronograma de treinamento precisam ser ajustados para o fine-tuning mais eficaz nos dados. Isso geralmente envolve um pequeno conjunto de validação.
Treinamento do Modelo: Usando os hiperparâmetros ajustados, execute o processo de otimização de fine-tuning no conjunto de treinamento completo até que o desempenho do modelo no conjunto de validação pare de melhorar (parada antecipada).
Avaliação: Avalie o desempenho do modelo fine-tuned no conjunto de teste separado, idealmente composto por exemplos do mundo real para o caso de uso alvo, para estimar a eficácia no mundo real.
Implantação e Monitoramento: Uma vez satisfeito, o modelo fine-tuned pode ser implantado para inferência em novas entradas. É crucial monitorar seu desempenho e precisão ao longo do tempo para detectar a deriva de conceito.

Embora isso esboce o processo geral, muitas nuances podem impactar o sucesso do fine-tuning para um LLM ou tarefa específica. Estratégias como aprendizado de currículo, fine-tuning multi-tarefa e prompt de poucos disparos podem ainda mais aumentar o desempenho.

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

Fine-Tuning Avançado: Incorporando Feedback Humano

Enquanto o fine-tuning supervisionado padrão usando conjuntos de dados rotulados é eficaz, uma fronteira emocionante é treinar LLMs diretamente usando preferências e feedback humanos. Essa abordagem humano-no-loop aproveita técnicas de aprendizado por reforço:

PPO (Otimização de Política Próxima): Aqui, o LLM é tratado como um agente de aprendizado por reforço, com suas saídas sendo “ações”. Um modelo de recompensa é treinado para prever avaliações humanas ou pontuações de qualidade para essas saídas. O PPO então otimiza o LLM para gerar saídas que maximizam as pontuações do modelo de recompensa.

RLHF (Aprendizado por Reforço a Partir de Feedback Humano): Isso estende o PPO incorporando diretamente o feedback humano no processo de aprendizado. Em vez de um modelo de recompensa fixo, as recompensas vêm de avaliações humanas iterativas nas saídas do LLM durante o fine-tuning.

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

Empresas como a Anthropic usaram o RLHF para infundir seus modelos de linguagem, como o Claude, com melhor veracidade, ética e conscientização de segurança além da mera competência na tarefa.

Riscos e Limitações Potenciais

Embora imensamente poderosos, o fine-tuning de LLMs não está sem riscos que devem ser gerenciados com cuidado:

Amplificação de Vieses: Se os dados de fine-tuning contêm vieses sociais em torno de gênero, raça, idade ou outros atributos, o modelo pode amplificar esses vieses indesejáveis. Curar conjuntos de dados representativos e sem vieses é crucial.

Deriva Factual: Mesmo após o fine-tuning em dados de alta qualidade, os modelos de linguagem podem “alucinar” fatos ou saídas incorretas inconsistentes com os exemplos de treinamento ao longo de conversas ou prompts mais longos. Métodos de recuperação de fatos podem ser necessários.

Desafios de Escalabilidade: O fine-tuning completo de modelos enormes como o GPT-3 requer recursos computacionais imensos que podem ser inviáveis para muitas organizações. Os métodos de fine-tuning eficientes mitigam parcialmente isso, mas têm trade-offs.

Esquecimento Catastrófico: Durante o fine-tuning completo, os modelos podem experimentar esquecimento catastrófico, onde perdem algumas capacidades gerais aprendidas durante o pré-treinamento. O aprendizado multi-tarefa pode ser necessário.

Riscos de IP e Privacidade: Dados proprietários usados para fine-tuning podem vazar para saídas de modelos de linguagem públicas, apresentando riscos. Técnicas de privacidade diferencial e mitigação de riscos de informação são áreas de pesquisa ativas.

No geral, embora excepcionalmente úteis, o fine-tuning é um processo nuances que requer cuidado em torno da qualidade dos dados, considerações de identidade, mitigação de riscos e equilíbrio de trade-offs de desempenho-eficiência com base nos requisitos do caso de uso.

O Futuro: Customização de Modelo de Linguagem em Escala

Olhando para o futuro, os avanços em técnicas de fine-tuning e adaptação de modelos serão cruciais para desbloquear o potencial completo dos modelos de linguagem grande em aplicações e domínios diversos.

Métodos mais eficientes que permitam o fine-tuning de modelos ainda maiores, como o PaLM, com recursos limitados, podem democratizar o acesso. A automação de pipelines de criação de conjuntos de dados e engenharia de prompts pode simplificar a especialização.

Técnicas de auto-supervisão para fine-tuning a partir de dados brutos sem rótulos podem abrir novas fronteiras. E abordagens compostas para combinar sub-modelos fine-tuned treinados em diferentes tarefas ou dados podem permitir a construção de modelos altamente personalizados sob demanda.

Em última análise, à medida que os LLMs se tornam mais ubíquos, a capacidade de customizá-los e especializá-los de forma transparente para cada caso de uso concebível será crítica. O fine-tuning e estratégias de adaptação de modelos relacionadas são etapas fundamentais para realizar a visão de modelos de linguagem grande como assistentes de IA flexíveis, seguros e poderosos que aumentam as capacidades humanas em todos os domínios e empreendimentos.

Aayush Mittal, Mittal

Eu passei os últimos cinco anos me imergindo no fascinante mundo de Aprendizado de Máquina e Aprendizado Profundo. Minha paixão e expertise me levaram a contribuir para mais de 50 projetos de engenharia de software diversificados, com um foco particular em IA/ML. Minha curiosidade contínua também me levou em direção ao Processamento de Linguagem Natural, um campo que estou ansioso para explorar mais.

Unite.AI