Durante minha pós graduação tive a oportunidade de descobrir um framework para fine-tuning de LLMs, o Unsloth.
Ele não é um wrapper pro Hugging Face, mas sim um framework altamente otimizado que reimplementa a stack de training (transformers + bitsandbytes + peft) para extrair o máximo de performance possível, reduzindo drasticamente o consumo de VRAM e o tempo de treino.

O resultado? Modelos com fine-tuning 2x mais rápido e com até 70% menos memória que o pipeline padrão da 🤗 Hugging Face.

Porque o Unsloth existe?

Quem já tentou fazer fine-tuning em um Llama, Mistral ou Qwen usando a stack tradicional poderá perceber alguns comportamentos:

VRAM evapora.
Tempo de treino é uma eternidade.
Pequenas configs de LoRA ou quantização viram dor de cabeça.

O Unsloth foi concebido justamente pra resolver isso, sem reinventar a roda, apenas otimizando o que já existe.

Camadas do modelo com kernel fusion eficiente (CUDA otimizada).
Quantização 4-bit e 8-bit com suporte nativo via bitsandbytes.
Patching inteligente das classes do transformers e peft.
API 100% compatível com o Hugging Face.

Como funciona?

O Unsloth reconstrói o pipeline de treino em cima de três pilares principais:

Carga otimizada de modelos
Usa lazy loading e quantized weights para carregar apenas o necessário na VRAM.

from unsloth import FastLanguageModel

model, tokenizer = FastLanguageModel.from_pretrained(
	model_name="unsloth/mistral-7b-bnb-4-bit,
	max_seq_length=2048,
	load_in_4bit=True,
	dtype=None, # usa o melhor dtype automaticamente
)

Treinamento com PEFT acelerado
Ele integra com o peft e o transformers.Trainer, mas sem o overhead dos métodos originais:

model = FastLanguageModel.get_peft_model(
	model,
	r=16,
	target_modules = ["q_proj", "k_proj", "v_proj", "o_proj",
                  "gate_proj", "up_proj", "down_proj",],,
	lora_alpha=32,
	lora_dropout=0,
	bias="none",
	use_gradient_checkpointing="unsloth",
)

Compatibilidade direta om o Trainer da HF

from trl import SFTTrainer
from transformers import TrainingArgs
from unsloth import is_bfloat16_supported

args = TrainingArguments(
	per_device_train_batch_size = 2,
	gradient_accumulation_steps = 4,
	warmup_steps = 5,
	max_steps = 60,
	# num_train_epochs = 1,
	learning_rate = 2e-4,
	fp16=not is_bfloat16_supported(),
	bf16 = is_bfloat16_supported(),
	logging_steps = 1,
	optim = "adamw_8bit",
	weight_decay = 0.01,
	lr_scheduler_type = "linear",
	seed = 3407,
	output_dir = "outputs",	
)

trainer = SFTTrainer(
	model = model,
	tokenizer = tokenizer,
	train_dataset = dataset,
	dataset_text_field = "text",
	max_seq_length = max_seq_length,
	dataset_num_proc = 2,
	packing = False # Pode fazer o treinamento 5x mais rápido em sequências curtas.
	args = args,
)

trainer.train()

Benchmarks e performance

Em GPUs como RTX 3090, 4070 Ti ou até mesmo em T4 (do Google Colab), os ganhos são expressivos

Fonte: https://unsloth.ai/blog/long-context

Integração com o ecossistema Hugging Face

O grande trunfo do Unsloth é não reinventar.
Ele roda sobre as mesmas bases:

datasets para dados.
transformers para tokenização.
peft para LoRA.
bitsandbytes para quantização.

Quer tokenizar um dataset gigante?
Use o map com num_proc tranquilamente, o Unsloth é thread-safe e otimizado pra CPU também (requer alguns cuidados caso esteja no Windows).

Futuro do Unsloth

O projeto está crescendo rápido.

Suporte a modelos de Visão.
Integração com OpenVINO e ONNX Runtime
Suporte a Mixture of Experts.

Conclusão

O Unsloth é uma das formas mais eficientes e acessíveis de fazer fine-tuning de LLMs.
Ele reduz o custo, simplifica o código e mantém total compatibilidade com o ecossistema que a gente já conhece.

Links úteis

Repositório oficial: https://github.com/unslothai/unsloth
Docs: https://docs.unsloth.ai/
Exemplos: https://docs.unsloth.ai/get-started/unsloth-notebooks

Unsloth - Fine-tuning de LLMs na velocidade da luz e custo baixo