Como ajustar LLMs localmente

Ajustando um grande modelo de linguagem usado localmente para exigir um rack de GPUs. Em 2026, graças à quantização e métodos eficientes de parâmetros como LoRA, você pode ajustar um modelo de parâmetros de 7 a 8B em uma única GPU de consumidor com 12 a 24 GB de VRAM – ou mesmo em Apple Silicon com memória unificada. Este guia percorre todo o pipeline: preparando dados, executando o ajuste fino do LoRA e mesclando o resultado em um modelo que você pode realmente executar.

Índice

• Por que ajustar em vez de solicitar
• Requisitos de hardware e software
• Preparando um conjunto de dados de treinamento
• Ajuste fino com LoRA
• Executando o ciclo de treinamento
• Mesclando e exportando o modelo
• Executando seu modelo ajustado localmente
• Armadilhas Comuns
• Perguntas frequentes

Por que ajustar em vez de solicitar

A engenharia imediata e o RAG resolvem a maioria dos problemas – tente-os primeiro. O ajuste fino vale o esforço extra, especificamente quando você precisa que o modelo siga consistentemente um formato de saída restrito, adote um tom específico ao longo de milhares de gerações ou execute uma tarefa que o modelo básico lida de forma inconsistente, mesmo com bons prompts e exemplos. Ele incorpora o comportamento aos pesos, em vez de reexplicá-lo a cada solicitação.

Requisitos de hardware e software

Para um modelo básico de parâmetros de 7 a 8B com quantização de 4 bits e LoRA, 12 a 16 GB de VRAM são realistas em uma única GPU. Modelos maiores de 13-14B levam você a cartões de 24 GB. Instale a pilha principal:

pip install torch transformers peft bitsandbytes accelerate datasets trl

peft(Ajuste fino com eficiência de parâmetros) implementa LoRA.bitsandbyteslida com a quantização de 4 bits para que o modelo base caiba na memória.trlfornece um loop de treinamento criado especificamente para o ajuste fino do modelo de linguagem.

Preparando um conjunto de dados de treinamento

O formato é mais importante do que o volume para tarefas restritas – 200-500 exemplos de alta qualidade geralmente superam 5.000 exemplos barulhentos. Use um formato de instrução simples como JSONL:

{"instruction": "Summarize this support ticket in one sentence.", "input": "Customer reports login failures since the 2.3 update...", "output": "User cannot log in after updating to version 2.3."}
{"instruction": "Summarize this support ticket in one sentence.", "input": "Payment declined for annual plan renewal...", "output": "Annual plan renewal payment was declined."}

Carregue-o com odatasetsbiblioteca:

from datasets import load_dataset

dataset = load_dataset("json", data_files="train.jsonl", split="train")

def format_example(example):
    return {
        "text": f"### Instruction:\n{example['instruction']}\n\n### Input:\n{example['input']}\n\n### Response:\n{example['output']}"
    }

dataset = dataset.map(format_example)

Ajuste fino com LoRA

LoRA congela os pesos do modelo básico e treina pequenas matrizes adaptadoras de baixa classificação injetadas em camadas de atenção. Isso reduz os parâmetros treináveis ​​de bilhões para milhões, e é por isso que cabe no hardware do consumidor:

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
from peft import LoraConfig, get_peft_model
import torch

model_name = "meta-llama/Meta-Llama-3-8B"

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
)

tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name, quantization_config=bnb_config, device_map="auto")

lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
)

model = get_peft_model(model, lora_config)
model.print_trainable_parameters()

Essa última linha normalmente imprime algo como “parâmetros treináveis: 0,06% do total” – um lembrete concreto de por que isso cabe em uma única GPU, onde o ajuste fino completo não caberia.

Executando o ciclo de treinamento

trléSFTTrainerenvolve Rosto AbraçadoTrainercom padrões sensatos para ajuste de instrução:

from trl import SFTTrainer, SFTConfig

training_args = SFTConfig(
    output_dir="./lora-output",
    per_device_train_batch_size=2,
    gradient_accumulation_steps=4,
    num_train_epochs=3,
    learning_rate=2e-4,
    logging_steps=10,
    save_strategy="epoch",
    bf16=True,
)

trainer = SFTTrainer(
    model=model,
    train_dataset=dataset,
    args=training_args,
    dataset_text_field="text",
)

trainer.train()

A acumulação de gradiente permite simular um tamanho de lote maior do que o permitido pela VRAM, acumulando gradientes em vários lotes pequenos antes de atualizar os pesos – definaper_device_train_batch_sizetão alto quanto a memória permitir, então aumentegradient_accumulation_stepspara atingir um tamanho de lote efetivo de 8-16.

Mesclando e exportando o modelo

Após o treinamento, mescle os pesos do adaptador LoRA de volta ao modelo base para um ponto de verificação independente que você pode distribuir ou converter:

from peft import PeftModel

base_model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype=torch.bfloat16, device_map="auto")
merged_model = PeftModel.from_pretrained(base_model, "./lora-output/checkpoint-final")
merged_model = merged_model.merge_and_unload()

merged_model.save_pretrained("./merged-model")
tokenizer.save_pretrained("./merged-model")

Executando seu modelo ajustado localmente

Converta o modelo mesclado para o formato GGUF para inferência local rápida comllama.cppou Ollama:

python convert_hf_to_gguf.py ./merged-model --outfile my-model.gguf --outtype q4_k_m

ollama create my-model -f Modelfile
ollama run my-model

Oq4_k_ma quantização mantém a qualidade próxima do modelo de precisão total enquanto reduz o tamanho do arquivo em aproximadamente 4x, o que é importante para executar o modelo confortavelmente em um laptop.

Armadilhas Comuns

O overfitting em pequenos conjuntos de dados é a falha mais comum – se sua perda cair para perto de zero dentro de uma época, você provavelmente estará memorizando em vez de generalizar, e a perda de validação deve ser observada separadamente da perda de treinamento. A taxa de aprendizagem é o segundo problema mais comum: 2e-4 funciona para a maioria das configurações LoRA 7-8B, mas aumentar em pequenos conjuntos de dados desestabiliza o treinamento rapidamente.

Observe também a consistência da formatação imediata. Se seus dados de treinamento usarem um modelo de instrução específico, suas chamadas de inferência deverão usar exatamente o mesmo modelo — um formato incompatível no momento da inferência degrada silenciosamente a qualidade da saída sem que nenhum erro seja gerado.

Para saber mais sobre como executar modelos com eficiência depois de ajustados, nossolaboratório inicial e guia DevOpscobre infraestrutura de auto-hospedagem e, se você estiver construindo uma API em torno do seu modelo, consulte nossoTutorial FastAPI REST.

Perguntas frequentes

De quantos dados eu realmente preciso?
Para tarefas restritas e bem definidas, 200 a 500 exemplos de alta qualidade costumam ser suficientes. Mudanças mais amplas de comportamento (tom, acompanhamento de instruções multitarefas) se beneficiam de milhares de exemplos diversos.

Posso fazer ajustes em um MacBook?
Sim, usando o suporte de treinamento do MLX ou llama.cpp no ​​Apple Silicon. Memória unificada significa que um MacBook de 32 a 64 GB pode lidar com o ajuste fino de LoRA de 7 a 8B, embora mais lento do que uma GPU NVIDIA dedicada.

Qual é a diferença entre LoRA e QLoRA?
QLoRA adiciona quantização de 4 bits do modelo base congelado em cima do LoRA, reduzindo ainda mais os requisitos de memória com perda mínima de qualidade – é o que torna os modelos 8B treináveis ​​em GPUs de 12 a 16 GB.

Preciso fazer um ajuste fino ou o RAG funcionaria?
Se o problema for “o modelo não conhece esta informação”, use RAG. Se o problema for “o modelo conhece as informações, mas não formata ou se comporta da maneira que preciso”, o ajuste fino é a melhor ferramenta.

Quanto tempo leva o ajuste fino do LoRA?
Para 500 exemplos e 3 épocas em uma única GPU de consumidor, espere de 20 minutos a algumas horas, dependendo da duração da sequência e da classe da GPU.

Pronto para fazer o ajuste fino?

Comece com um conjunto de dados pequeno e limpo de 200 a 300 exemplos para uma única tarefa restrita antes de aumentar a escala. O pipeline acima – adaptador LoRA, SFTTrainer, mesclagem, exportação GGUF – é o mesmo formato usado para ajustes finos de produção, apenas em uma escala que cabe no hardware que você provavelmente já possui.