0Pricing
AI Agents · Aula

LoRA e QLoRA para ajuste eficiente em custos

Treine apenas adaptadores de baixa ordem sobre uma base quantizada — é possível fazer o ajuste fino de um modelo 70B em uma única GPU.

LoRA e QLoRA para ajuste eficiente em custos é uma aula grátis de AI Agents no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de AI Agents, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Agents inclui 4 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

Por que usar PEFT?

O ajuste fino completo do Llama 70B requer mais de 8 H100 e atualiza 70 bilhões de parâmetros. O PEFT (ajuste fino eficiente em parâmetros) atualiza < 1% dos parâmetros com qualidade semelhante. Isso gera uma enorme economia de custos.

LoRA: adaptação de baixa ordem

LoRA (Hu et al. 2021) treina pequenas matrizes de "adaptador" junto com os pesos-base congelados:

  • Adicione matrizes A x B, em que A é dxr e B é rxd, e r é pequeno (8, 16, 64)
  • Propagação direta: y = Wx + (BA)x
  • Treine apenas A e B — uma quantidade muito menor de parâmetros

QLoRA: LoRA quantizado

QLoRA (Dettmers et al. 2023) reduz ainda mais o custo ao quantizar o modelo-base para 4 bits durante o treinamento:

  • Modelo-base em NF4 (4 bits)
  • Adaptadores LoRA em maior precisão
  • Permite fazer ajuste fino de um modelo 70B em uma única A100/H100

Setup with peft + transformers

# pip install peft transformers bitsandbytes
from peft import LoraConfig, get_peft_model
from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained(
    'meta-llama/Llama-3.1-8B-Instruct',
    load_in_4bit=True,        # QLoRA
    device_map='auto'
)

lora_config = LoraConfig(
    r=16,                     # rank
    lora_alpha=32,
    target_modules=['q_proj', 'v_proj'],
    lora_dropout=0.05,
    bias='none'
)
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# trainable params: ~0.5% of total

Training Loop with TRL

from trl import SFTTrainer

trainer = SFTTrainer(
    model=model,
    train_dataset=dataset,
    tokenizer=tokenizer,
    args=TrainingArguments(
        per_device_train_batch_size=4,
        gradient_accumulation_steps=4,
        learning_rate=2e-4,
        num_train_epochs=3,
        output_dir='./lora-out'
    )
)
trainer.train()
model.save_pretrained('./adapter')

Usando Unsloth

Unsloth é a biblioteca LoRA mais rápida — 2 vezes mais rápida que o peft padrão. API pronta para uso:

from unsloth import FastLanguageModel

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name='meta-llama/Llama-3.1-8B-Instruct',
    load_in_4bit=True
)
model = FastLanguageModel.get_peft_model(
    model,
    r=16,
    target_modules=['q_proj', 'k_proj', 'v_proj', 'o_proj', 'gate_proj', 'up_proj', 'down_proj']
)

Estimativa de custos

QLoRA no Llama 3.1 8B com 10 mil exemplos:

  • ~4 horas em uma única H100
  • ~US$ 5–10 de custo de GPU na nuvem
  • Arquivo do adaptador: 100–300 MB

Escolhendo a ordem r

  • r = 8 — mínimo, para mudanças de formato/estilo
  • r = 16–32 — para a maioria dos casos
  • r = 64+ — para novos comportamentos substanciais, com mais capacidade

Módulos-alvo

Por padrão, use as projeções de atenção (q, v). Para obter mais capacidade, inclua todas as camadas lineares — melhor qualidade, mais parâmetros.

Hiperparâmetros importantes

  • Taxa de aprendizado — 1e-4 a 5e-4 é o intervalo típico
  • Épocas — 2–5 para SFT
  • Tamanho do lote — depende da VRAM; use acúmulo de gradientes para simular um lote maior

Mesclando o adaptador com o modelo-base

Para inferência, você pode mesclar o LoRA novamente com os pesos-base:

merged = model.merge_and_unload()
merged.save_pretrained('./full-model')

Servindo vários LoRAs

vLLM permite trocar LoRAs dinamicamente durante a inferência. Isso é útil para ajustes finos específicos por cliente sobre um modelo-base compartilhado:

llm = LLM(model='base', enable_lora=True, max_lora_rank=64)
response = llm.generate(prompt, lora_request=LoRARequest('customer-a', 1, './customer-a-adapter'))

Avaliando o adaptador

Sempre execute seu conjunto de avaliação YOUR no modelo ajustado. Às vezes, o ajuste piora o desempenho em casos extremos — seja honesto sobre as regressões.

Vantagem do LoRA

Qual é a principal vantagem prática do LoRA em relação ao ajuste fino completo?

Recapitulação

LoRA + QLoRA = ajuste fino econômico. Unsloth para velocidade, peft/TRL para abrangência. Use a ordem 16–32 na maioria dos casos. Faça a avaliação em comparação com seu conjunto de referência.

Perguntas Frequentes

A aula “LoRA e QLoRA para ajuste eficiente em custos” é grátis?

Sim — o texto completo de “LoRA e QLoRA para ajuste eficiente em custos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de AI Agents, atualize para CoddyKit PRO. O curso de AI Agents inclui 4 aulas no total.

O que vou aprender em “LoRA e QLoRA para ajuste eficiente em custos”?

Treine apenas adaptadores de baixa ordem sobre uma base quantizada — é possível fazer o ajuste fino de um modelo 70B em uma única GPU. Você pratica AI Agents com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar AI Agents?

Nenhuma experiência prévia é necessária. AI Agents no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “LoRA e QLoRA para ajuste eficiente em custos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de AI Agents?

Sim. Cada aula de AI Agents inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Quando o ajuste fino supera a criação de instruções
  2. Coleta de dados: trajetórias e reprodução de rastros
  3. LoRA e QLoRA para ajuste eficiente em custos
  4. Avaliação de modelos ajustados em comparação com a base
← Voltar para AI Agents