Introdução
Depois que os modelos Llama e Mistral foram lançados, os LLMs de código aberto tiraram os holofotes do OpenAI. Desde então, vários modelos foram lançados com base na arquitetura Llama e Mistral, com desempenho equivalente a modelos proprietários como GPT-3.5 Turbo, Claude, Gemini, etc.
Mas ultimamente, tem surgido uma nova classe de LLMs. Estes são os LLMs na categoria de parâmetros sub-7B. Menos parâmetros os tornam compactos o suficiente para serem executados em hardware de consumo, mantendo a eficiência comparável aos modelos 7B. Modelos como Tiny-Llama-1B, Phi-2 da Microsoft e Qwen-3b do Alibaba podem ser ótimos substitutos para modelos maiores para execução local ou implantação no limite. Ao mesmo tempo, o ajuste fino é crucial para tirar o melhor proveito de qualquer modelo básico para quaisquer tarefas posteriores.
Aqui, exploraremos como ajustar uma base Modelo Tiny-Llama em um conjunto de dados Alpaca limpo.
Objetivos de aprendizagem
- Entenda o ajuste fino e seus diferentes métodos.
- Aprenda sobre ferramentas e técnicas para um ajuste fino eficiente.
- Saiba mais sobre o WandB para registrar logs de treinamento.
- Ajuste Tiny-Llama no conjunto de dados Alpaca no Colab.
Este artigo foi publicado como parte do Blogatona de Ciência de Dados.
Índice
O que é ajuste fino LLM?
O ajuste fino é o processo de fazer um modelo pré-treinado aprender novos conhecimentos. O modelo pré-treinado é um modelo de uso geral treinado em uma grande quantidade de dados. No entanto, na maioria dos casos, eles não funcionam conforme o esperado, e o ajuste fino é a maneira mais eficaz de adaptar o modelo a casos de uso específicos. Por exemplo, base LLMs tem um bom desempenho na geração de texto em controle de qualidade de turno único, mas tem dificuldade com conversas em vários turnos, como modelos de bate-papo.
Os modelos básicos precisam ser treinados em transcrições de diálogos para serem capazes de manter conversas em vários turnos. O ajuste fino é essencial para moldar modelos pré-treinados em diferentes avatares. A qualidade dos modelos ajustados depende da qualidade dos dados e dos recursos do modelo base. Existem várias maneiras de modelar o ajuste fino, como LoRA, QLoRA, etc.
Vamos examinar brevemente esses conceitos.
LoRA
LoRA significa Adaptação de classificação baixa, uma técnica popular de ajuste fino na qual selecionamos alguns parâmetros treináveis em vez de atualizar todos os parâmetros por meio de uma aproximação de classificação baixa das matrizes de peso originais. O modelo LoRA pode ser ajustado mais rapidamente em hardware com menos uso intensivo de computação.
QLoRA
QLoRA ou Quantized LoRA é um passo além do LoRA. Em vez de um modelo de precisão total, ele quantiza os pesos do modelo para diminuir a precisão do ponto flutuante antes de aplicar o LoRA. Quantização é o processo de conversão de valores de bits mais altos para valores mais baixos. Um processo de quantização de 4 bits envolve quantizar os pesos de 16 bits em valores flutuantes de 4 bits.
A quantização do modelo leva a uma redução substancial no tamanho do modelo com precisão comparável ao modelo original. No QLoRA, pegamos um modelo quantizado e aplicamos LoRA a ele. Os modelos podem ser quantizados de várias maneiras, como por meio de llama.cpp, AWQ, bitsandbytes, etc.
Ajuste fino com Unsloth
Unsloth é uma plataforma de código aberto para ajustar modelos populares de linguagem grande com mais rapidez. Ele suporta LLMs populares, incluindo Llama-2 e Mistral, e seus derivados como Yi, Open-hermes, etc. Ele implementa kernels triton personalizados e um mecanismo de back-prop manual para melhorar a velocidade do treinamento do modelo.
Aqui, usaremos o Unsloth para ajustar um modelo Tiny-Llama quantizado básico de 4 bits no Alpaca conjunto de dados. O modelo é quantizado com bits e bytes, e os kernels são otimizados com Triton da OpenAI.
Registrando com WandB
No aprendizado de máquina, é crucial registrar métricas de treinamento e avaliação. Isso nos dá uma visão completa da viagem do trem. Pesos e desvios (WandB) é uma biblioteca de código aberto para visualizar e rastrear experimentos de aprendizado de máquina. Possui um aplicativo web dedicado para visualização de métricas de treinamento em tempo real. Também nos permite gerenciar modelos de produção de forma centralizada. Usaremos o WandB apenas para rastrear nossa execução de ajuste fino do Tiny-Llama.
Para usar o WandB, cadastre-se para uma conta gratuita e crie um Chave API.
Agora, vamos começar a ajustar nosso modelo.
Como ajustar o Tiny-Llama?
O ajuste fino é uma tarefa que exige muita computação. Requer uma máquina com 10-15 GB de VRAM, ou você pode usar o tempo de execução gratuito da GPU Tesla T4 do Colab.
Agora instale Unsloth e WandB
%%capture
import torch
major_version, minor_version = torch.cuda.get_device_capability()
!pip install wandb
if major_version >= 8:
# Use this for new GPUs like Ampere, Hopper GPUs (RTX 30xx, RTX 40xx, A100, H100, L40)
!pip install "unsloth[colab_ampere] @ git+https://github.com/unslothai/unsloth.git"
else:
# Use this for older GPUs (V100, Tesla T4, RTX 20xx)
!pip install "unsloth[colab] @ git+https://github.com/unslothai/unsloth.git"
pass
O próximo passo é carregar o modelo pré-treinado quantizado de 4 bits com Unsloth.
from unsloth import FastLanguageModel
import torch
max_seq_length = 4096 # Choose any! We auto support RoPE Scaling internally!
dtype = None # None for auto detection. Float16 for Tesla T4, V100, Bfloat16 for Ampere+
load_in_4bit = True # Use 4bit quantization to reduce memory usage. Can be False.
model, tokenizer = FastLanguageModel.from_pretrained(
model_name = "unsloth/tinyllama-bnb-4bit", # "unsloth/tinyllama" for 16bit loading
max_seq_length = max_seq_length,
dtype = dtype,
load_in_4bit = load_in_4bit,
)
Isso instalará o modelo localmente. O tamanho do modelo de 4 bits será em torno de 760 MBs.
Agora aplique PEFT para o modelo Tiny-Llama de 4 bits.
model = FastLanguageModel.get_peft_model(
model,
r = 32, # Choose any number > 0 ! Suggested 8, 16, 32, 64, 128
target_modules = ["q_proj", "k_proj", "v_proj", "o_proj",
"gate_proj", "up_proj", "down_proj",],
lora_alpha = 32,
lora_dropout = 0, # Currently only supports dropout = 0
bias = "none", # Currently only supports bias = "none"
use_gradient_checkpointing = True, # @@@ IF YOU GET OUT OF MEMORY - set to True @@@
random_state = 3407,
use_rslora = False, # We support rank stabilized LoRA
loftq_config = None, # And LoftQ
)
Prepare os dados
A próxima etapa é preparar o conjunto de dados para ajuste fino. Como mencionei anteriormente, usaremos um limpo Conjunto de dados Alpaca. Esta é uma versão limpa do conjunto de dados Alpaca original. Segue o formato instrução-entrada-resposta. Aqui está um exemplo de dados da Alpaca
Agora, vamos preparar nossos dados.
@title prepare data
#alpaca_prompt = """Below is an instruction that describes a task, paired with an input that
provides further context.
Write a response that appropriately completes the request.
### Instruction:
{}
### Input:
{}
### Response:
{}"""
EOS_TOKEN = tokenizer.eos_token
def formatting_prompts_func(examples):
instructions = examples["instruction"]
inputs = examples["input"]
outputs = examples["output"]
texts = []
for instruction, input, output in zip(instructions, inputs, outputs):
# Must add EOS_TOKEN, otherwise your generation will go on forever!
text = alpaca_prompt.format(instruction, input, output) + EOS_TOKEN
texts.append(text)
return { "text" : texts, }
pass
from datasets import load_dataset
dataset = load_dataset("yahma/alpaca-cleaned", split = "train")
dataset = dataset.map(formatting_prompts_func, batched = True,)
Agora, divida os dados em dados de treinamento e avaliação. Peguei dados de avaliação pequenos, pois dados de avaliação maiores retardam o treinamento.
dataset_dict = dataset.train_test_split(test_size=0.004)
Configurar WandB
Agora, configure Pesos e Vieses em seu tempo de execução atual.
# @title wandb init
import wandb
wandb.login()
Forneça a chave API para fazer login no WandB quando solicitado.
Configure variáveis de ambiente.
%env WANDB_WATCH=all
%env WANDB_SILENT=true
Modelo de trem
Até agora, carregamos o modelo de 4 bits, criamos a configuração LoRA, preparamos o conjunto de dados e configuramos o WandB. A próxima etapa é treinar o modelo nos dados. Para isso, precisamos definir um treinador da biblioteca Trl. Usaremos o SFTrainer da Trl. Mas antes disso, inicialize o WandB e defina os argumentos de treinamento apropriados.
import os
from trl import SFTTrainer
from transformers import TrainingArguments
from transformers.utils import logging
import wandb
logging.set_verbosity_info()
project_name = "tiny-llama"
entity = "wandb"
# os.environ["WANDB_LOG_MODEL"] = "checkpoint"
wandb.init(project=project_name, name = "tiny-llama-unsloth-sft")
Argumentos de treinamento
args = TrainingArguments(
per_device_train_batch_size = 2,
per_device_eval_batch_size=2,
gradient_accumulation_steps = 4,
evaluation_strategy="steps",
warmup_ratio = 0.1,
num_train_epochs = 1,
learning_rate = 2e-5,
fp16 = not torch.cuda.is_bf16_supported(),
bf16 = torch.cuda.is_bf16_supported(),
optim = "adamw_8bit",
weight_decay = 0.1,
lr_scheduler_type = "linear",
seed = 3407,
output_dir = "outputs",
report_to="wandb", # enable logging to W&B
# run_name="tiny-llama-alpaca-run", # name of the W&B run (optional)
logging_steps=1, # how often to log to W&B
logging_strategy = 'steps',
save_total_limit=2,
)
Isso é importante para o treinamento. Para manter baixo o uso da GPU, mantenha baixas as etapas de treinamento, lote de avaliação e acumulação de gradiente. O logging_steps é o número de etapas antes que as métricas sejam registradas no WandB.
Agora, inicialize o SFTTrainer.
trainer = SFTTrainer(
model = model,
tokenizer = tokenizer,
train_dataset = dataset_dict["train"],
eval_dataset=dataset_dict["test"],
dataset_text_field = "text",
max_seq_length = max_seq_length,
dataset_num_proc = 2,
packing = True, # Packs short sequences together to save time!
args = args,
)
Agora, comece o treinamento.
trainer_stats = trainer.train()
wandb.finish()
Durante a execução do treinamento, o WandB rastreará as métricas de treinamento e avaliação. Você visita o link do painel fornecido e o vê em tempo real.
Esta é uma captura de tela da minha execução em um notebook Colab.
A velocidade de treinamento dependerá de vários fatores, incluindo os tamanhos dos dados de treinamento e avaliação, o tamanho do lote de treinamento e avaliação e o número de épocas. Se você encontrar problemas de uso da GPU, tente reduzir os tamanhos das etapas de acúmulo de lote e gradiente. O tamanho do lote do trem = batch_size_per_device *gradiente_accumulation_steps. E o número de etapas de otimização = dados totais de treinamento/tamanho do lote. Você pode brincar com os parâmetros e ver qual funciona melhor.
Você pode visualizar a perda de treinamento e avaliação do seu treinamento no painel do WandB.
Perda de trem
Perda de avaliação
Inferência
Você pode salvar os adaptadores LoRA localmente ou enviá-los para o repositório HuggingFace.
model.save_pretrained("lora_model") # Local saving
# model.push_to_hub("your_name/lora_model", token = "...") # Online saving
Você também pode carregar o modelo salvo do disco e usá-lo para inferência.
if False:
from unsloth import FastLanguageModel
model, tokenizer = FastLanguageModel.from_pretrained(
model_name = "lora_model", # YOUR MODEL YOU USED FOR TRAINING
max_seq_length = max_seq_length,
dtype = dtype,
load_in_4bit = load_in_4bit,
)
inputs = tokenizer(
[
alpaca_prompt.format(
"capital of France?", # instruction
"", # input
"", # output - leave this blank for a generation!
)
]*1, return_tensors = "pt").to("cuda")
outputs = model.generate(**inputs, max_new_tokens = 64, use_cache = True)
tokenizer.batch_decode(outputs)
Para streaming de respostas do modelo.
from transformers import TextStreamer
text_streamer = TextStreamer(tokenizer)
_ = model.generate(**inputs, streamer = text_streamer, max_new_tokens = 64)
Então, tratava-se de ajustar um modelo Tiny-Llama com registro WandB.
Aqui está o Caderno Colab para o mesmo.
Conclusão
LLMs pequenos podem ser benéficos para implantação em hardware com restrição de computação, como computadores pessoais, telefones celulares e outros wearables, etc. O ajuste fino permite que esses modelos tenham um melhor desempenho em tarefas posteriores. Neste artigo, aprendemos como ajustar um modelo de linguagem base em um conjunto de dados.
Principais lições
- O ajuste fino é o processo de fazer com que um modelo pré-treinado se adapte a uma nova tarefa específica.
- Tiny-Llama é um LLM com apenas 1.1 bilhão de parâmetros e é treinado em 3 trilhões de tokens.
- Existem diferentes maneiras de ajustar LLMs, como LoRA e QLoRA.
- Unsloth é uma plataforma de código aberto que fornece LLMs otimizados para CUDA para acelerar o ajuste fino de LLMs.
- Weights and Biases (WandB) é uma ferramenta para rastrear e armazenar experimentos de ML.
Perguntas Frequentes
R. O ajuste fino, no contexto do aprendizado de máquina, especialmente do aprendizado profundo, é uma técnica em que você pega um modelo pré-treinado e o adapta a uma tarefa nova e específica.
R. É possível ajustar LLMs menores gratuitamente no Colab por meio da GPU Tesla T4 com QLoRA.
A. O ajuste fino melhora enormemente a capacidade do LLM de executar tarefas posteriores, como dramatização, geração de código, etc.
R. Tiny-Llama treinado em 3 trilhões de tokens é um LLM com parâmetros de 1.1B. O modelo adota a arquitetura original do Llama-2.
R. Unsloth é uma ferramenta de código aberto que fornece ajuste fino de LLM mais rápido e eficiente, otimizando kernels de GPU com Triton.
A mídia mostrada neste artigo não é propriedade da Analytics Vidhya e é usada a critério do Autor.
Relacionado
- Conteúdo com tecnologia de SEO e distribuição de relações públicas. Seja amplificado hoje.
- PlatoData.Network Gerativa Vertical Ai. Capacite-se. Acesse aqui.
- PlatoAiStream. Inteligência Web3. Conhecimento Amplificado. Acesse aqui.
- PlatãoESG. Carbono Tecnologia Limpa, Energia, Ambiente, Solar, Gestão de resíduos. Acesse aqui.
- PlatoHealth. Inteligência em Biotecnologia e Ensaios Clínicos. Acesse aqui.
- Fonte: https://www.analyticsvidhya.com/blog/2024/02/fine-tuning-a-tiny-llama-model-with-unsloth/
- :tem
- :é
- :não
- :onde
- $UP
- 1
- 11
- 12
- 15%
- 16
- 1b
- 258
- 32
- 7
- 8
- a
- A100
- Capaz
- Sobre
- Conta
- acumulação
- precisão
- adaptar
- adaptação
- adicionar
- Todos os Produtos
- permite
- tb
- quantidade
- an
- analítica
- Análise Vidhya
- e
- qualquer
- api
- app
- Aplicar
- Aplicando
- apropriado
- adequadamente
- arquitetura
- SOMOS
- argumentos
- por aí
- artigo
- AS
- At
- auto
- Avatares
- b
- base
- baseado
- BE
- sido
- antes
- abaixo
- benéfico
- Benefícios
- MELHOR
- Melhor
- viés
- vieses
- bilhão
- Pouco
- pedaços
- em branco
- blogatona
- brevemente
- trazer
- mas a
- by
- CAN
- capacidades
- capacidade
- capital
- casos
- Categoria
- bate-papo
- Escolha
- classe
- código
- compacto
- comparável
- completar
- Completa
- computadores
- conceitos
- Configuração
- configurado
- consumidor
- Hardware para Consumidores
- contexto
- conversas
- crio
- criado
- crucial
- Atual
- Atualmente
- personalizadas
- Dash
- painel de instrumentos
- dados,
- conjuntos de dados
- dedicado
- profundo
- deep learning
- definir
- depender
- depende
- implantar
- Implantação
- Derivativos
- descreve
- Detecção
- diálogos
- diferente
- critério
- do
- down
- Mais cedo
- borda
- Eficaz
- eficiência
- eficiente
- outro
- emergência
- permitir
- encontro
- Motor
- Melhora
- suficiente
- entidade
- Meio Ambiente
- épocas
- especialmente
- essencial
- etc.
- Éter (ETH)
- avaliação
- exemplo
- exemplos
- experimentos
- explorar
- fatores
- FALHA
- falso
- longe
- mais rápido
- poucos
- menos
- Flutuador
- flutuante
- segue
- Escolha
- formato
- França
- Gratuito
- da
- mais distante
- Gemini
- propósito geral
- geração
- ter
- Git
- dado
- dá
- Go
- GPU
- GPUs
- ótimo
- Hardware
- Ter
- SUA PARTICIPAÇÃO FAZ A DIFERENÇA
- Alta
- superior
- segurar
- Como funciona o dobrador de carta de canal
- Como Negociar
- Contudo
- HTTPS
- Abraçando o Rosto
- i
- if
- implementa
- importar
- importante
- melhorar
- in
- Incluindo
- entrada
- inputs
- instalar
- em vez disso
- instruções
- Pretendido
- para dentro
- envolve
- questões
- IT
- jpg
- Guarda
- manutenção
- Chave
- Conhecimento
- Kumar
- língua
- grande
- Maior
- Leads
- APRENDER
- aprendido
- aprendizagem
- Deixar
- menos
- Permite
- Biblioteca
- como
- ribalta
- linear
- LINK
- lhama
- Ilm
- carregar
- carregamento
- local
- localmente
- log
- registrado
- logging
- fora
- Baixo
- diminuir
- máquina
- aprendizado de máquina
- fazer
- Fazendo
- gerencia
- manual
- max-width
- Mídia
- Memória
- mencionado
- métodos
- Métrica
- ML
- Móvel Esteira
- celulares
- modelo
- modelos
- mais
- mais eficiente
- a maioria
- múltiplo
- devo
- my
- nome
- você merece...
- Novo
- Próximo
- nenhum
- caderno
- número
- of
- frequentemente
- mais velho
- on
- online
- só
- open source
- OpenAI
- otimização
- otimizado
- otimizando
- or
- original
- OS
- Outros
- de outra forma
- A Nossa
- Fora
- saída
- outputs
- Acima de
- propriedade
- Packs
- emparelhado
- parâmetro
- parâmetros
- parte
- passar
- realizar
- realização
- pessoal
- Computadores pessoais
- telefones
- fotografia
- plataforma
- platão
- Inteligência de Dados Platão
- PlatãoData
- Jogar
- ponto
- Popular
- possível
- Precisão
- Preparar
- preparado
- processo
- Produção
- proprietário
- fornece
- publicado
- Empurrar
- Dúvidas
- qualidade
- R
- classificar
- em tempo real
- reduzir
- redução
- redução
- liberado
- repositório
- solicitar
- exige
- pesquisa
- resposta
- respostas
- retorno
- Tipo
- rtx
- Execute
- mesmo
- Salvar
- salvo
- poupança
- dimensionamento
- Ciência
- Vejo
- semente
- selecionar
- conjunto
- Baixo
- mostrando
- assinar
- desde
- Tamanho
- tamanhos
- retarda
- pequeno
- menor
- específico
- velocidade
- divisão
- fica
- começo
- Passo
- Passos
- de streaming
- Lutar
- substancial
- tal
- ajuda
- suportes
- Tire
- tomado
- Tarefa
- tarefas
- técnica
- técnicas
- Tesla
- teste
- texto
- geração de texto
- do que
- que
- A
- deles
- Eles
- então
- Lá.
- Este
- deles
- coisa
- isto
- Através da
- tempo
- para
- juntos
- token
- Tokens
- também
- levou
- ferramenta
- ferramentas
- tocha
- Total
- pista
- Rastreamento
- Trem
- treinado
- Training
- transformadores
- Trilhão
- Tritão
- verdadeiro
- tentar
- atualização
- us
- Uso
- usar
- usava
- Valores
- versão
- via
- Visite a
- visualizar
- foi
- Caminho..
- maneiras
- we
- acessórios
- web
- webp
- peso
- BEM
- foram
- O Quê
- O que é a
- quando
- qual
- enquanto
- precisarão
- de
- trabalho
- escrever
- Você
- investimentos
- zefirnet