Inteligência artificial
O único guia que você precisa para ajustar o Llama 3 ou qualquer outro modelo de código aberto
O ajuste fino de modelos de linguagem grande (LLMs), como o Llama 3, envolve a adaptação de um modelo pré-treinado para tarefas específicas usando um conjunto de dados específico de domínio. Esse processo aproveita o conhecimento pré-existente do modelo, tornando-o eficiente e econômico em comparação ao treinamento do zero. Neste guia, percorreremos as etapas para ajustar o Llama 3 usando QLoRA (Quantized LoRA), um método com eficiência de parâmetros que minimiza o uso de memória e os custos computacionais.
Visão geral do ajuste fino
O ajuste fino envolve várias etapas principais:
- Selecionando um modelo pré-treinado: escolha um modelo básico que se alinhe à arquitetura desejada.
- Reunindo um conjunto de dados relevante: colete e pré-processe um conjunto de dados específico para sua tarefa.
- Afinação: adapte o modelo usando o conjunto de dados para melhorar seu desempenho em tarefas específicas.
- Avaliação : Avalie o modelo ajustado usando métricas qualitativas e quantitativas.
Conceitos e Técnicas
Ajustando modelos de linguagem grande
Ajuste fino completo
Ajuste fino completo atualiza todos os parâmetros do modelo, tornando-o específico para a nova tarefa. Este método requer recursos computacionais significativos e muitas vezes é impraticável para modelos muito grandes.
Ajuste fino com eficiência de parâmetros (PEFT)
O PEFT atualiza apenas um subconjunto dos parâmetros do modelo, reduzindo os requisitos de memória e o custo computacional. Esta técnica evita o esquecimento catastrófico e mantém o conhecimento geral do modelo.
Adaptação de baixo nível (LoRA) e LoRA quantizado (QLoRA)
LoRA ajusta apenas algumas matrizes de baixa classificação, enquanto QLoRA quantiza essas matrizes para reduzir ainda mais o consumo de memória.
Métodos de ajuste fino
- Ajuste fino completo: envolve treinar todos os parâmetros do modelo no conjunto de dados específico da tarefa. Embora este método possa ser muito eficaz, também é computacionalmente caro e requer uma quantidade significativa de memória.
- Ajuste fino eficiente de parâmetros (PEFT): o PEFT atualiza apenas um subconjunto dos parâmetros do modelo, tornando-o mais eficiente em termos de memória. Técnicas como Low-Rank Adaptation (LoRA) e Quantized LoRA (QLoRA) se enquadram nesta categoria.
O que é LoRA?
Comparando métodos de ajuste fino: QLORA aprimora LoRA com quantização de precisão de 4 bits e otimizadores paginados para gerenciamento de picos de memória
LoRA é um método de ajuste fino aprimorado onde, em vez de ajustar todos os pesos do modelo pré-treinado, duas matrizes menores que se aproximam da matriz maior são ajustadas. Essas matrizes constituem o adaptador LoRA. Este adaptador ajustado é então carregado no modelo pré-treinado e usado para inferência.
Principais vantagens do LoRA:
- Eficiência de memória: LoRA reduz o consumo de memória ajustando apenas pequenas matrizes em vez de todo o modelo.
- Reutilização: O modelo original permanece inalterado e vários adaptadores LoRA podem ser usados com ele, facilitando o manuseio de múltiplas tarefas com menores requisitos de memória.
O que é LoRA Quantizado (QLoRA)?
QLoRA leva LoRA um passo adiante ao quantizar os pesos dos adaptadores LoRA para diminuir a precisão (por exemplo, 4 bits em vez de 8 bits). Isso reduz ainda mais o uso de memória e os requisitos de armazenamento, mantendo um nível comparável de eficácia.
Principais vantagens do QLoRA:
- Eficiência de memória ainda maior: Ao quantizar os pesos, o QLoRA reduz significativamente os requisitos de memória e armazenamento do modelo.
- Mantém o desempenho: Apesar da precisão reduzida, o QLoRA mantém níveis de desempenho próximos aos dos modelos de precisão total.
Adaptação Específica da Tarefa
Durante o ajuste fino, os parâmetros do modelo são ajustados com base no novo conjunto de dados, ajudando-o a compreender melhor e a gerar conteúdo relevante para a tarefa específica. Este processo retém o conhecimento geral do idioma adquirido durante o pré-treinamento, ao mesmo tempo que adapta o modelo às nuances do domínio alvo.
Ajuste fino na prática
Ajuste fino completo vs. PEFT
- Ajuste fino completo: envolve o treinamento de todo o modelo, o que pode ser caro do ponto de vista computacional e requer memória significativa.
- PEFT (LoRA e QLoRA): ajusta apenas um subconjunto de parâmetros, reduzindo os requisitos de memória e evitando esquecimentos catastróficos, tornando-o uma alternativa mais eficiente.
Etapas de implementação
- Ambiente de Configuração: Instale as bibliotecas necessárias e configure o ambiente de computação.
- Carregar e pré-processar conjunto de dados: carregue o conjunto de dados e pré-processe-o em um formato adequado ao modelo.
- Carregar modelo pré-treinado: carregue o modelo base com configurações de quantização se estiver usando QLoRA.
- tokenization: tokenize o conjunto de dados para prepará-lo para treinamento.
- Formação: ajuste o modelo usando o conjunto de dados preparado.
- Avaliação : Avalie o desempenho do modelo em tarefas específicas usando métricas qualitativas e quantitativas.
Guia Steo by Step para ajuste fino LLM
Configurando o ambiente
Usaremos um notebook Jupyter para este tutorial. Plataformas como Kaggle, que oferece uso gratuito de GPU, ou Google Colab são ideais para realizar esses experimentos.
1. Instale as bibliotecas necessárias
Primeiro, certifique-se de ter as bibliotecas necessárias instaladas:
!pip install -qqq -U bitsandbytes transformers peft accelerate datasets scipy einops evaluate trl rouge_score</div>
2. Importe bibliotecas e configure o ambiente
import os
import torch
from datasets import load_dataset
from transformers import (
AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig, TrainingArguments,
pipeline, HfArgumentParser
)
from trl import ORPOConfig, ORPOTrainer, setup_chat_format, SFTTrainer
from tqdm import tqdm
import gc
import pandas as pd
import numpy as np
from huggingface_hub import interpreter_login
# Disable Weights and Biases logging
os.environ['WANDB_DISABLED'] = "true"
interpreter_login()
3. Carregue o conjunto de dados
Usaremos o conjunto de dados DialogSum para este tutorial:
Pré-processe o conjunto de dados de acordo com os requisitos do modelo, incluindo a aplicação de modelos apropriados e garantindo que o formato dos dados seja adequado para ajuste fino. (Abraçando o rosto)â <â < (DataCamp).
dataset_name = "neil-code/dialogsum-test" dataset = load_dataset(dataset_name)
Inspecione a estrutura do conjunto de dados:
print(dataset['test'][0])
4. Crie a configuração BitsAndBytes
Para carregar o modelo no formato de 4 bits:
compute_dtype = getattr(torch, "float16")
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type='nf4',
bnb_4bit_compute_dtype=compute_dtype,
bnb_4bit_use_double_quant=False,
)
5. Carregue o modelo pré-treinado
Usando o modelo Phi-2 da Microsoft para este tutorial:
model_name = 'microsoft/phi-2'
device_map = {"": 0}
original_model = AutoModelForCausalLM.from_pretrained(
model_name,
device_map=device_map,
quantization_config=bnb_config,
trust_remote_code=True,
use_auth_token=True
)
6. Tokenização
Configure o tokenizador:
tokenizer = AutoTokenizer.from_pretrained(
model_name,
trust_remote_code=True,
padding_side="left",
add_eos_token=True,
add_bos_token=True,
use_fast=False
)
tokenizer.pad_token = tokenizer.eos_token
Ajuste fino do Llama 3 ou outros modelos
Ao ajustar modelos como o Llama 3 ou qualquer outro LLM de código aberto de última geração, há considerações e ajustes específicos necessários para garantir o desempenho ideal. Aqui estão as etapas detalhadas e os insights sobre como abordar isso para diferentes modelos, incluindo Llama 3, GPT-3 e Mistral.
5.1 Usando Lhama 3
Seleção de modelo:
- Certifique-se de ter o identificador de modelo correto no hub do modelo Hugging Face. Por exemplo, o modelo Llama 3 pode ser identificado como
meta-llama/Meta-Llama-3-8Bno rosto abraçado. - Certifique-se de solicitar acesso e fazer login em sua conta Hugging Face, se necessário, para modelos como Llama 3 (Abraçando o rosto)â <â <
Tokenização:
- Use o tokenizer apropriado para o Llama 3, garantindo que ele seja compatível com o modelo e ofereça suporte aos recursos necessários, como preenchimento e tokens especiais.
Memória e computação:
- O ajuste fino de modelos grandes como o Llama 3 requer recursos computacionais significativos. Certifique-se de que seu ambiente, como uma configuração de GPU poderosa, possa lidar com os requisitos de memória e processamento. Garanta que o ambiente possa lidar com os requisitos de memória, que podem ser mitigados usando técnicas como QLoRA para reduzir o consumo de memória (Fóruns de abraços faciais)
Exemplo:
model_name = 'meta-llama/Meta-Llama-3-8B'
device_map = {"": 0}
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.float16,
bnb_4bit_use_double_quant=True,
)
original_model = AutoModelForCausalLM.from_pretrained(
model_name,
device_map=device_map,
quantization_config=bnb_config,
trust_remote_code=True,
use_auth_token=True
)
Tokenização:
Dependendo do caso de uso específico e dos requisitos do modelo, garanta a configuração correta do tokenizer sem configurações redundantes. Por exemplo, use_fast=True é recomendado para melhor desempenho (Abraçando o rosto)â <â < (Pesos e preconceitos).
tokenizer = AutoTokenizer.from_pretrained(
model_name,
trust_remote_code=True,
padding_side="left",
add_eos_token=True,
add_bos_token=True,
use_fast=False
)
tokenizer.pad_token = tokenizer.eos_token
5.2 Usando outros modelos populares (por exemplo, GPT-3, Mistral)
Seleção de modelo:
- Para modelos como GPT-3 e Mistral, certifique-se de usar o nome e o identificador corretos do modelo Hugging Face ou de outras fontes.
Tokenização:
- Semelhante ao Llama 3, certifique-se de que o tokenizer esteja configurado corretamente e seja compatível com o modelo.
Memória e computação:
- Cada modelo pode ter requisitos de memória diferentes. Ajuste a configuração do seu ambiente de acordo.
Exemplo para GPT-3:
model_name = 'openai/gpt-3'
device_map = {"": 0}
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.float16,
bnb_4bit_use_double_quant=True,
)
original_model = AutoModelForCausalLM.from_pretrained(
model_name,
device_map=device_map,
quantization_config=bnb_config,
trust_remote_code=True,
use_auth_token=True
)
Exemplo para Mistral:
model_name = 'mistral-7B'
device_map = {"": 0}
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.float16,
bnb_4bit_use_double_quant=True,
)
original_model = AutoModelForCausalLM.from_pretrained(
model_name,
device_map=device_map,
quantization_config=bnb_config,
trust_remote_code=True,
use_auth_token=True
)
Considerações sobre tokenização: Cada modelo pode ter requisitos exclusivos de tokenização. Certifique-se de que o tokenizer corresponda ao modelo e esteja configurado corretamente.
Exemplo de tokenizador Llama 3:
tokenizer = AutoTokenizer.from_pretrained(
model_name,
trust_remote_code=True,
padding_side="left",
add_eos_token=True,
add_bos_token=True,
use_fast=False
)
tokenizer.pad_token = tokenizer.eos_token
Exemplo de tokenizador GPT-3 e Mistral:
tokenizer = AutoTokenizer.from_pretrained(
model_name,
use_fast=True
)
7. Teste o modelo com inferência zero-shot
Avalie o modelo base com um exemplo de entrada:
from transformers import set_seed
set_seed(42)
index = 10
prompt = dataset['test'][index]['dialogue']
formatted_prompt = f"Instruct: Summarize the following conversation.\n{prompt}\nOutput:\n"
# Generate output
def gen(model, prompt, max_length):
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_length=max_length)
return tokenizer.batch_decode(outputs, skip_special_tokens=True)
res = gen(original_model, formatted_prompt, 100)
output = res[0].split('Output:\n')[1]
print(f'INPUT PROMPT:\n{formatted_prompt}')
print(f'MODEL GENERATION - ZERO SHOT:\n{output}')
8. Pré-processe o conjunto de dados
Converta pares de diálogo-resumo em prompts:
def create_prompt_formats(sample):
blurb = "Below is an instruction that describes a task. Write a response that appropriately completes the request."
instruction = "### Instruct: Summarize the below conversation."
input_context = sample['dialogue']
response = f"### Output:\n{sample['summary']}"
end = "### End"
parts = [blurb, instruction, input_context, response, end]
formatted_prompt = "\n\n".join(parts)
sample["text"] = formatted_prompt
return sample
dataset = dataset.map(create_prompt_formats)
Tokenize o conjunto de dados formatado:
def preprocess_batch(batch, tokenizer, max_length):
return tokenizer(batch["text"], max_length=max_length, truncation=True)
max_length = 1024
train_dataset = dataset["train"].map(lambda batch: preprocess_batch(batch, tokenizer, max_length), batched=True)
eval_dataset = dataset["validation"].map(lambda batch: preprocess_batch(batch, tokenizer, max_length), batched=True)
9. Prepare o modelo para QLoRA
Prepare o modelo para ajuste fino com eficiência de parâmetros:
original_model = prepare_model_for_kbit_training(original_model)
Hiperparâmetros e seu impacto
Os hiperparâmetros desempenham um papel crucial na otimização do desempenho do seu modelo. Aqui estão alguns hiperparâmetros principais a serem considerados:
- Taxa de Aprendizagem: controla a velocidade com que o modelo atualiza seus parâmetros. Uma alta taxa de aprendizagem pode levar a uma convergência mais rápida, mas pode ultrapassar a solução ideal. Uma baixa taxa de aprendizagem garante uma convergência constante, mas pode exigir mais épocas.
- Tamanho do batch: o número de amostras processadas antes do modelo atualizar seus parâmetros. Tamanhos de lote maiores podem melhorar a estabilidade, mas requerem mais memória. Tamanhos de lote menores podem gerar mais ruído no processo de treinamento.
- Etapas de acumulação de gradiente: este parâmetro ajuda a simular lotes maiores acumulando gradientes em várias etapas antes de executar uma atualização de parâmetro.
- Número de Épocas: o número de vezes que todo o conjunto de dados passa pelo modelo. Mais épocas podem melhorar o desempenho, mas podem levar ao overfitting se não forem gerenciadas adequadamente.
- Decadência de peso: Técnica de regularização para evitar overfitting penalizando pesos grandes.
- Agendador de Taxa de Aprendizagem: ajusta a taxa de aprendizagem durante o treinamento para melhorar o desempenho e a convergência.
Personalize a configuração de treinamento ajustando hiperparâmetros como taxa de aprendizagem, tamanho do lote e etapas de acumulação de gradiente com base no modelo específico e nos requisitos da tarefa. Por exemplo, os modelos Llama 3 podem exigir taxas de aprendizagem diferentes em comparação com modelos menores (Pesos e preconceitos)â <â < (GitHub)
Exemplo de configuração de treinamento
orpo_args = ORPOConfig( learning_rate=8e-6, lr_scheduler_type="linear",max_length=1024,max_prompt_length=512, beta=0.1,per_device_train_batch_size=2,per_device_eval_batch_size=2, gradient_accumulation_steps=4,optim="paged_adamw_8bit",num_train_epochs=1, evaluation_strategy="steps",eval_steps=0.2,logging_steps=1,warmup_steps=10, report_to="wandb",output_dir="./results/",)
10. Treine o modelo
Configure o treinador e comece a treinar:
trainer = ORPOTrainer(
model=original_model,
args=orpo_args,
train_dataset=train_dataset,
eval_dataset=eval_dataset,
tokenizer=tokenizer,)
trainer.train()
trainer.save_model("fine-tuned-llama-3")
Avaliando o modelo ajustado
Após o treinamento, avalie o desempenho do modelo usando métodos qualitativos e quantitativos.
1. Avaliação Humana
Compare os resumos gerados com os escritos por humanos para avaliar a qualidade.
2. Avaliação Quantitativa
Use métricas como ROUGE para avaliar o desempenho:
from rouge_score import rouge_scorer scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True) scores = scorer.score(reference_summary, generated_summary) print(scores)
Desafios e soluções comuns
1. Limitações de memória
O uso do QLoRA ajuda a mitigar problemas de memória ao quantizar os pesos dos modelos para 4 bits. Certifique-se de ter memória GPU suficiente para lidar com o tamanho do lote e do modelo.
2. Overfitting
Monitore as métricas de validação para evitar overfitting. Use técnicas como parada precoce e redução de peso.
3. Treinamento Lento
Otimize a velocidade de treinamento ajustando o tamanho do lote, a taxa de aprendizagem e usando o acúmulo de gradiente.
4. Qualidade de dados
Certifique-se de que seu conjunto de dados esteja limpo e bem pré-processado. A baixa qualidade dos dados pode impactar significativamente o desempenho do modelo.
Conclusão
O ajuste fino de LLMs usando QLoRA é uma maneira eficiente de adaptar grandes modelos pré-treinados a tarefas específicas com custos computacionais reduzidos. Seguindo este guia, você pode ajustar o PHI, o Llama 3 ou qualquer outro modelo de código aberto para obter alto desempenho em suas tarefas específicas.
