Unsloth agora treina modelos MoE 12x mais rápido com 35% menos VRAM — hands-on com o novo release

Semana passada eu precisava fazer fine-tuning de um modelo MoE para um projeto interno. Abri o HuggingFace Trainer, configurei tudo, lancei o job numa A100 40GB e fui dormir. Seis horas depois, o treinamento tinha terminado — e metade da minha cota de GPU tinha ido junto. Aí saiu o novo release do Unsloth. Mesmo modelo, mesma config, mesma GPU: 70 minutos. Não é typo. Setenta minutos.

O repositório é github.com/unslothai/unsloth, com mais de 30 mil stars no GitHub. E esse release merece cada uma delas.

O que mudou neste release

O Unsloth já era a ferramenta go-to para fine-tuning eficiente de LLMs. A grande novidade são os kernels Triton otimizados especificamente para arquiteturas MoE (Mixture of Experts). Antes, o suporte a MoE existia, mas sem otimizações dedicadas — você usava os mesmos kernels de modelos densos e torcia para dar certo.

Agora os números falam por si:

Métrica	HF Trainer (baseline)	Unsloth (novo release)	Melhoria
Tempo de treino (A100 40GB)	~6h	~70min	12x mais rápido
Uso de VRAM	38.2 GB	24.8 GB	35% menos
Contexto máximo	8K tokens	48K tokens	6x mais longo
Perda de acurácia	baseline	baseline	nenhuma

Esse último ponto é o que importa. Não é um tradeoff velocidade-por-qualidade. Os kernels Triton reescrevem as operações de roteamento do MoE de um jeito que reduz materialização de tensores intermediários. Menos cópia de memória, menos overhead de kernel launch, mesma matemática.

Modelos suportados no release: DeepSeek, GLM-4.7-Flash, Kimi-2.5, Llama 4, Mistral, Gemma 2, Qwen 2.5. Basicamente tudo que você vai querer usar em produção.

Hands-on: fine-tuning de um Llama 4 8B

Chega de slide. Vamos rodar.

1. Instalação

pip install "unsloth[triton] @ git+https://github.com/unslothai/unsloth.git"
pip install sglang  # para deploy depois

Se você está numa instância com CUDA 12.x, o Triton já vem compatível. Em CUDA 11.8, precisa do triton-nightly. Não tente rodar sem Triton — os kernels MoE dependem dele.

2. Configuração do modelo

from unsloth import FastLanguageModel

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="meta-llama/Llama-4-Scout-8B",
    max_seq_length=32768,
    load_in_4bit=True,
    dtype=None,  # auto-detect
)

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=16,
    lora_dropout=0,
    bias="none",
    use_gradient_checkpointing="unsloth",
)

O use_gradient_checkpointing="unsloth" é o que ativa os kernels otimizados. Sem isso, você está rodando o path padrão do HuggingFace.

3. Dataset e treinamento

from trl import SFTTrainer
from transformers import TrainingArguments

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,  # seu dataset formatado
    dataset_text_field="text",
    max_seq_length=32768,
    args=TrainingArguments(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        warmup_steps=10,
        num_train_epochs=3,
        learning_rate=2e-4,
        fp16=not torch.cuda.is_bf16_supported(),
        bf16=torch.cuda.is_bf16_supported(),
        output_dir="outputs",
        optim="adamw_8bit",
    ),
)

trainer.train()

Na minha A100 40GB com um dataset de ~50K exemplos, esse treinamento rodou em 68 minutos. O pico de VRAM foi 24.3 GB — sobraram 16 GB que eu poderia usar para aumentar batch size ou contexto.

4. Salvando o modelo

model.save_pretrained_merged(
    "llama4-8b-finetuned",
    tokenizer,
    save_method="merged_16bit",
)

Deploy com SGLang

Uma coisa que eu gosto no ecossistema Unsloth é que eles pensaram no pipeline completo. Treinou? Deploy com SGLang. Sem ficar convertendo formato de modelo entre três ferramentas diferentes.

python -m sglang.launch_server \
    --model-path llama4-8b-finetuned \
    --port 8000 \
    --tp 1

O SGLang roda inference otimizada com continuous batching e funciona como um drop-in replacement para a API da OpenAI. Seu código de aplicação não muda — é apontar a URL e pronto.

Pipeline inteira open-source: Unsloth para treino, SGLang para serving. Sem vendor lock-in, sem licença enterprise obscura.

Quanto custa na prática

Porque no final das contas, é sempre sobre dinheiro.

Setup	Custo/hora (spot)	Tempo de treino	Custo total
A100 40GB + HF Trainer	~US$1.10/h	6h	US$6.60
A100 40GB + Unsloth	~US$1.10/h	70min	US$1.28
A10G 24GB + Unsloth (4bit)	~US$0.50/h	~2.5h	US$1.25

Leu direito: com Unsloth, dá para fazer fine-tuning de um modelo MoE de 8B numa A10G — uma GPU que custa metade de uma A100. O consumo de VRAM caiu o suficiente para caber em 24 GB com 4-bit quantization.

Para quem roda fine-tuning frequente, a diferença anualizada é brutal. Um job semanal sai de US$343/ano com HF Trainer para US$65/ano com Unsloth na A10G. Mesmo dinheiro, cinco vezes mais experimentos.

Limitações — porque nem tudo são flores

Eu já testei bastante para listar o que ainda não funciona bem:

Multi-GPU: o suporte a tensor parallelism no treinamento ainda é experimental. Para modelos maiores que 70B, você vai precisar de DeepSpeed ou FSDP por enquanto.
Modelos não-suportados: se seu modelo não está na lista de arquiteturas suportadas, os kernels Triton não ativam e você cai no path lento sem aviso claro. Verifique a compatibility matrix no repo.
Quantização assimétrica: AWQ e GPTQ ainda não são suportados nos kernels MoE. É QLoRA com bitsandbytes ou full precision.
Documentação: melhorou muito, mas ainda tem gaps. O notebook de exemplo para MoE não cobre todos os edge cases. Já abri duas issues no repo.

Nada disso é um deal-breaker, mas é bom saber antes de começar.

Veredito

O Unsloth com kernels Triton para MoE é, sem exagero, a maior melhoria prática em tooling de fine-tuning que eu vi nos últimos seis meses. 12x mais rápido, 35% menos VRAM, sem perda de acurácia — e tudo open-source.

Se você está fazendo fine-tuning de qualquer modelo MoE — DeepSeek, Llama 4, Qwen — não tem motivo para não usar. A instalação leva dois minutos, a API é compatível com HuggingFace Trainer, e os resultados são mensuráveis no primeiro job.

Repo: github.com/unslothai/unsloth. Vai lá, roda, mede. Depois me conta.