Guia de Introdução ao Ajuste Fino de LLMs

Já sabemos que o ajuste fino é o processo de pegar um modelo pré-treinado e atualizar seus parâmetros treinando-o com um conjunto de dados específico para sua tarefa. Então, vamos exemplificar esse conceito com o ajuste fino de um modelo real.

Imagine que estamos trabalhando com o GPT-2, mas percebemos que ele é muito ruim para inferir os sentimentos de tweets.

Uma pergunta natural que vem à mente é: podemos fazer algo para melhorar seu desempenho?

Para que o desempenho melhore, podemos aproveitar o ajuste fino treinando nosso modelo GPT-2 pré-treinado a partir do modelo da Hugging Face com um conjunto de dados contendo tweets e seus sentimentos correspondentes. Veja um exemplo básico de ajuste fino de um modelo para classificação de sequências:

Etapa 1: escolher um modelo pré-treinado e um conjunto de dados

Para fazer o ajuste fino de um modelo, sempre precisamos ter em mente um modelo pré-treinado. No nosso caso, vamos fazer um ajuste fino simples usando o GPT-2.

Captura de tela do hub de conjuntos de dados da Hugging Face. Seleção do modelo GPT2 da OpenAI.

Lembre-se sempre de selecionar uma arquitetura de modelo adequada para a tarefa.

Etapa 2: carregar os dados a serem usados

Agora que temos nosso modelo, precisamos de dados de qualidade para trabalhar, e é exatamente aí que a biblioteca datasets entra em ação.

No meu caso, vou usar a biblioteca datasets da Hugging Face para importar um conjunto de dados contendo tweets segmentados por sentimento (positivos, neutros ou negativos).

from datasets import load_dataset

dataset = load_dataset("mteb/tweet_sentiment_extraction")
df = pd.DataFrame(dataset['train'])

Ao verificar o conjunto de dados que acabamos de baixar, vemos que é um conjunto de dados que contém um subconjunto de treinamento e outro de teste. Ao converter o subconjunto de treinamento em um DataFrame, ele fica assim:

Conjunto de dados a ser usado.

Etapa 3: tokenizador

Agora que já temos o conjunto de dados, precisamos de um tokenizador a fim de prepará-lo para ser analisado pelo nosso modelo.

Como os LLMs trabalham com tokens, precisamos de um tokenizador para processar o conjunto de dados. Para processar o conjunto de dados em uma única etapa, use o método map de Datasets para aplicar uma função de pré-processamento em todo o conjunto de dados.

É por isso que a segunda etapa é carregar um tokenizador pré-treinado e tokenizar o conjunto de dados para que ele possa ser usado para o ajuste fino.

from transformers import GPT2Tokenizer

# Loading the dataset to train our model
dataset = load_dataset("mteb/tweet_sentiment_extraction")

tokenizer = GPT2Tokenizer.from_pretrained("gpt2")
tokenizer.pad_token = tokenizer.eos_token
def tokenize_function(examples):
   return tokenizer(examples["text"], padding="max_length", truncation=True)

tokenized_datasets = dataset.map(tokenize_function, batched=True)

BÔNUS: para melhorar os requisitos de processamento, podemos criar um subconjunto menor do conjunto de dados completo para ajustar o modelo. O conjunto de treinamento será usado para ajuste fino do modelo, enquanto o conjunto de teste será usado para avaliá-lo.

small_train_dataset = tokenized_datasets["train"].shuffle(seed=42).select(range(1000))
small_eval_dataset = tokenized_datasets["test"].shuffle(seed=42).select(range(1000))

Etapa 4: inicializar o modelo básico

Comece carregando o modelo e especifique o número de rótulos esperados. No cartão do conjunto de dados de sentimento dos tweets, você sabe que há três rótulos:

from transformers import GPT2ForSequenceClassification

model = GPT2ForSequenceClassification.from_pretrained("gpt2", num_labels=3)

Etapa 5: avaliar o método

A biblioteca Transformers disponibiliza a classe Trainer, otimizada para treinamento. No entanto, esse método não inclui uma forma de avaliar o modelo. É por isso que, antes de iniciar o treinamento, precisamos passar ao Trainer uma função para avaliar o desempenho do modelo.

import evaluate

metric = evaluate.load("accuracy")

def compute_metrics(eval_pred):
   logits, labels = eval_pred
   predictions = np.argmax(logits, axis=-1)
   return metric.compute(predictions=predictions, references=labels)

Etapa 6: fazer o ajuste fino usando o método Trainer

A última etapa é configurar os argumentos de treinamento e iniciar o processo de treinamento. A biblioteca Transformers contém a classe Trainer, que disponibiliza uma ampla gama de opções e recursos de treinamento, como registro em log, acúmulo de gradiente e precisão mista. Primeiro, definimos os argumentos de treinamento juntamente com a estratégia de avaliação. Quando tudo estiver definido, é possível treinar o modelo com facilidade usando o comando train().

from transformers import TrainingArguments, Trainer

training_args = TrainingArguments(
   output_dir="test_trainer",
   #evaluation_strategy="epoch",
   per_device_train_batch_size=1,  # Reduce batch size here
   per_device_eval_batch_size=1,    # Optionally, reduce for evaluation as well
   gradient_accumulation_steps=4
   )


trainer = Trainer(
   model=model,
   args=training_args,
   train_dataset=small_train_dataset,
   eval_dataset=small_eval_dataset,
   compute_metrics=compute_metrics,

)

trainer.train()

Após o treinamento, avalie o desempenho do modelo com um conjunto de validação ou teste. Novamente, a classe Trainer já contém um método de avaliação que cuida disso.

import evaluate

trainer.evaluate()

Essas são as etapas mais básicas para fazer o ajuste fino de qualquer LLM. Lembre-se de que o ajuste fino de um LLM exige muita capacidade de computação, e talvez seu computador local não tenha capacidade suficiente para isso.

Você pode aprender a fazer o ajuste fino de LLMs mais avançados diretamente na interface da OpenAI seguindo este tutorial sobre Como fazer o ajuste fino do GPT 3.5.

Melhores práticas de ajuste fino

Para garantir o sucesso do ajuste fino, leve em consideração as práticas recomendadas a seguir:

Qualidade e quantidade de dados

A qualidade do conjunto de dados de ajuste fino afeta consideravelmente o desempenho do modelo. Todos sabemos:

"Se entra lixo, sai lixo".

Portanto, sempre garanta que os dados sejam limpos, pertinentes e grandes o bastante.

Ajuste dos hiperparâmetros

O ajuste fino geralmente é um processo longo que precisa ser repetido. Sempre analise várias configurações de taxas de aprendizado, tamanhos de lote e número de épocas de treinamento para identificar a melhor configuração para o projeto.

Ajustes precisos são essenciais para garantir que o modelo aprenda de forma eficiente e se adapte bem a dados não vistos, evitando a armadilha do sobreajuste.

Avaliação frequente

Avalie com regularidade o progresso do modelo durante o treinamento para acompanhar sua eficácia e implementar as modificações necessárias. Isso envolve a avaliação do desempenho do modelo usando um conjunto de dados de validação distinto durante o período de treinamento.

Essa avaliação é essencial para identificar o desempenho do modelo na tarefa em questão e a possibilidade de sobreajuste ao conjunto de dados de treinamento. Com base nos resultados da fase de validação, podem ser feitos ajustes conforme necessário para otimizar o desempenho.

Como evitar armadilhas no ajuste fino do LLM

Às vezes, o ajuste fino pode levar a resultados abaixo do ideal. Tenha cuidado com as seguintes armadilhas:

Sobreajuste

O uso de um conjunto de dados pequeno para treinamento ou um número excessivo de épocas pode gerar sobreajuste. Isso geralmente é caracterizado pelo fato de o modelo mostrar alta precisão com o conjunto de dados de treinamento, mas não conseguir generalizar com novos dados.

Subajuste

Por outro lado, um treinamento insuficiente ou uma baixa taxa de aprendizado pode resultar em subajuste, quando o modelo não consegue aprender a tarefa adequadamente.

Esquecimento catastrófico

No processo de ajuste fino para uma tarefa específica, há o risco de o modelo perder o conhecimento amplo que adquiriu inicialmente. Esse problema, conhecido como esquecimento catastrófico, pode diminuir a capacidade do modelo de apresentar um bom desempenho em uma variedade de tarefas usando o processamento de linguagem natural.

Vazamento de dados

Sempre mantenha conjuntos de dados de treinamento e validação separados e sem sobreposição, pois isso pode gerar métricas de alto desempenho enganosas.

Ajuste fino x RAG

O RAG combina os pontos fortes dos modelos baseados em recuperação e dos modelos generativos. No RAG, um componente de recuperação pesquisa um grande banco de dados ou base de conhecimento para encontrar informações pertinentes com base na consulta de entrada. Essas informações recuperadas são então usadas por um modelo generativo para produzir uma resposta mais precisa e pertinente ao contexto. Alguns dos principais benefícios do RAG são:

• Integração dinâmica de conhecimentos: inclui informações de fontes externas em tempo real, tornando-o adequado para tarefas que exigem conhecimentos atualizados ou específicos.
• Relevância contextual: aprimora as respostas do modelo generativo ao fornecer mais contexto sobre os documentos recuperados.
• Versatilidade: Capaz de lidar com uma gama mais ampla de consultas, inclusive aquelas que exigem informações específicas ou raras com as quais o modelo talvez não tenha sido treinado.

Escolha entre ajuste fino e RAG

Ao decidir se você deve usar o ajuste fino ou o RAG, leve em consideração os seguintes fatores:

• Tipo de tarefa: em tarefas que se beneficiam de modelos altamente especializados (ex.: aplicativos específicos de domínio), o ajuste fino costuma ser a abordagem preferida. O RAG é ideal para tarefas que exigem a integração de conhecimentos externos ou a recuperação de informações em tempo real.
• Disponibilidade de dados: o ajuste fino requer uma quantidade substancial de dados rotulados específicos para a tarefa. Se esses dados forem escassos, o componente de recuperação do RAG pode compensar disponibilizando informações pertinentes de fontes externas.
• Restrições de recursos: o ajuste fino pode fazer uso intenso de recursos de computação, enquanto o RAG aproveita os bancos de dados já existentes para complementar o modelo generativo, com a possibilidade de reduzir a necessidade de treinamento extensivo.

Conclusão

Embarcar na jornada de ajuste fino de grandes modelos de linguagem abre um mundo de possibilidades para aplicações da IA.

Ao compreender e aplicar os conceitos, as práticas e as precauções descritas, é possível adaptar com eficácia esses modelos sofisticados para atender a necessidades específicas, liberando todo o seu potencial no processo.

Para continuar aprendendo sobre o ajuste fino, recomendo enfaticamente que você faça alguns ajustes finos mais avançados. Você pode começar pelo curso Conceitos de LLM do DataCamp, que abrange muitas das principais metodologias de treinamento e as pesquisas mais recentes. Mais alguns bons recursos que você pode seguir são:

• Guia Passo a Passo para Usar e Fazer o Ajuste Fino do Mistral 7B.
• Ajuste Fino do Llama 2: Guia Passo a Passo para Personalização do Grande Modelo de Linguagem
• Sessão de programação conjunta: ajuste fino do seu próprio modelo do Llama 2
• Ajuste Fino do Stable Diffusion XL com o DreamBooth e o LoRA