A Engenharia da Destilação: Como Modelos Chineses Aprenderam com Claude, GPT-4 e a Si Mesmos — E Por Que Treinar Custa Tanto

"Distilling powerful models into smaller ones yields excellent results; small models relying on large-scale RL require enormous compute." — DeepSeek-R1 Technical Report, jan/2025

Você abre o terminal, dispara claude code, e o modelo resolve um bug obscuro em 40 segundos de raciocínio encadeado, chamando ferramentas, lendo arquivos, testando hipóteses. Esse comportamento — esse andar particular do agente — vale ouro. Não pelo que ele disse, mas pela sequência de pensamento que produziu a resposta.

Agora imagine pegar 16 milhões dessas sequências e usá-las para ensinar outro modelo, menor, mais barato, a agir igual.

Isso tem nome. Chama-se destilação de conhecimento. É a técnica que redefine a corrida de IA em 2025-2026, o motivo pelo qual modelos chineses alcançaram a fronteira com uma fração do orçamento, e o porquê de a Anthropic e a OpenAI estarem furiosas. É também, curiosamente, uma das coisas mais legais que você pode fazer na sua própria máquina por cinco dólares.

Este artigo explica como funciona — do primeiro princípio até o pipeline que treinou o DeepSeek-R1, passando pela por que treinar do zero custa cem milhões de dólares e como você fine-tuna seu próprio modelo numa tarde.

Parte 1 — A Intuição: Por Que Um Modelo Pequeno Pode Ser Tão Bom Quanto Um Grande

Comecemos com uma analogia. Pense num professor de matemática que resolve uma equação difícil na lousa. Ele não entrega só a resposta (x = 7). Ele entrega o caminho: "isole o termo, aplique a regra da cadeia, verifique o sinal". Esse caminho carrega muito mais informação que a resposta final sozinha.

Modelos de linguagem grandes (LLMs) fazem a mesma coisa internamente. Quando o GPT-4 responde "2 + 2 = 4", ele não calcula apenas isso. Sua última camada produz uma distribuição de probabilidade sobre todo o vocabulário — talvez 0,99 para "4", mas também 0,0001 para "quatro", 0,00005 para "four", 10⁻⁶ para "5". Esses números pequenos, aparentemente inúteis, carregam a topologia do conhecimento: o modelo sabe que "4" é mais próximo de "quatro" que de "cachorro".

Geoffrey Hinton chamou isso de dark knowledge — conhecimento escuro, escondido nos cantos da distribuição de probabilidade. Seu artigo seminal de 2015 (Distilling the Knowledge in a Neural Network, mais de 33 mil citações) mostrou que treinar um modelo menor para reproduzir essas distribuições suaves — não só a resposta final — transfere muito mais conhecimento do que copiar o rótulo correto.

O Mecanismo: Temperature Scaling

Para expor esse dark knowledge, Hinton usou um truque chamado temperature. A saída normal de um modelo é:

p_i = exp(z_i) / Σ_j exp(z_j)

Divida tudo por uma temperatura T alta e a distribuição "amortece":

q_i = exp(z_i / T) / Σ_j exp(z_j / T)

Com T = 1, recuperamos o comportamento normal (distribuições afiadas, quase one-hot). Com T alto (digamos, 5 ou 20), as probabilidades se espalham e revelam as relações finas entre os tokens. Treine o modelo menor para imitar essa distribuição suave do professor, e ele absorve o dark knowledge.

A função de perda combina os dois sinais:

L = α²·T²·CE(soft_targets) + (1-α)·CE(hard_labels)

O fator T² compensa o fato de que gradientes de soft targets escalam com 1/T². É um detalhe técnico, mas importa: sem ele, o otimizador ignora os alvos suaves.

Minimal Example: Destilação em 30 Linhas de PyTorch

Antes de qualquer teoria profunda, vejamos a forma mais simples possível. Treinar um modelo pequeno (student) para imitar as probabilidades de um grande (teacher), só com logits — chamado de logit distillation:

import torch
import torch.nn as nn
import torch.nn.functional as F

def distillation_loss(student_logits, teacher_logits, labels, T=4.0, alpha=0.7):
    # Soft targets: a distribuição suavizada do professor (dark knowledge)
    soft_targets = F.softmax(teacher_logits / T, dim=-1)
    soft_pred = F.log_softmax(student_logits / T, dim=-1)

    # KL divergence mede quão longe o student está do teacher
    soft_loss = F.kl_div(soft_pred, soft_targets, reduction='batchmean') * (T * T)

    # Hard targets: a resposta correta (one-hot), como treino normal
    hard_loss = F.cross_entropy(student_logits, labels)

    return alpha * soft_loss + (1 - alpha) * hard_loss

# Loop de treino (esqueleto)
for batch in dataloader:
    inputs, labels = batch
    with torch.no_grad():
        teacher_logits = teacher_model(inputs)   # professor congelado
    student_logits = student_model(inputs)        # student aprende

    loss = distillation_loss(student_logits, teacher_logits, labels)
    loss.backward()
    optimizer.step()

Pronto. Esse é o coração da destilação. O professor nunca é atualizado (torch.no_grad()); só o student aprende. A mágica está na mistura: o student absorve tanto o que responder (hard loss) quanto como o professor pensa (soft loss).

Nota prática: este exemplo assume que você tem acesso aos logits internos do teacher — o que é verdade para modelos open-source (Llama, Qwen), mas impossível para APIs fechadas como Claude ou GPT-4. Para esses, usamos a próxima técnica.

Parte 2 — Quando Você Não Tem Os Logits: Response Distillation (SFT Com Outputs Do Teacher)

Aqui está o ponto crucial que conecta tudo ao mundo real dos modelos chineses.

Quando você chama a API do Claude, você recebe texto — a resposta final. Você não recebe a distribuição de probabilidade sobre 100 mil tokens. Logo, não pode fazer logit distillation clássico.

Mas pode fazer algo mais simples e escalável: response distillation. Pergunte ao Claude milhões de coisas, colete as respostas, e use esses pares (pergunta, resposta) como dados de supervised fine-tuning (SFT) para um modelo menor.

# Pipeline de response distillation (esqueleto)
import openai  # ou anthropic

def generate_teacher_data(prompts, teacher_model="claude-opus-4"):
    dataset = []
    for prompt in prompts:
        response = client.messages.create(
            model=teacher_model,
            messages=[{"role": "user", "content": prompt}]
        )
        dataset.append({
            "prompt": prompt,
            "completion": response.content[0].text
        })
    return dataset

# Depois: SFT normal no student com esses dados

Esta é a técnica que Stanford usou para criar o Alpaca em 2023: fine-tuning do LLaMA 7B em 52 mil instruções geradas pelo text-davinci-003, custando cerca de $600. A Vicuna fez o mesmo com 70 mil conversas do ChatGPT. O Alpaca-GPT4 foi o primeiro a usar GPT-4 sistematicamente como gerador.

O trade-off: response distillation descarta o dark knowledge dos logits. Você captura a resposta final, não a riqueza da distribuição interna. Funciona bem — mas não tão bem quanto logit distillation quando você tem acesso aos pesos.

Por Que Funciona Mesmo Sem Logits

Aqui está uma intuição que costuma surpreender: cadeias de raciocínio (chain-of-thought) são muito mais comprimíveis que distribuições brutas de texto.

Considere. Para um modelo reproduzir a resposta final "x = 7", ele precisa aprender uma função de mapeamento complexa. Mas para reproduzir a cadeia "isole o termo → aplique a regra → verifique o sinal → x = 7", o student aprende um caminho decomposto em passos menores, cada um mais fácil de imitar. O raciocínio, ao ser explicitado, vira uma trilha de migalhas que o student pode seguir.

É por isso que o paper LLMs Are Reasoning Teachers (ACL 2023) mostrou que um modelo pequeno fine-tunado em cadeias de raciocínio geradas por um modelo grande consegue aproximadamente o mesmo desempenho em raciocínio — sem nunca ter visto os logits do teacher.

Parte 3 — O Caso Paradigmático: Como O DeepSeek-R1 Se Destilou

Em 20 de janeiro de 2025, a DeepSeek publicou um modelo que mudou a indústria: o R1, um modelo de raciocínio competitivo com o OpenAI o1. Mas o mais impactante não foi o R1 em si — foi o que eles fizeram depois.

O R1 é enorme: 671 bilhões de parâmetros (arquitetura MoE, com 37 bilhões ativos por token). Rodar isso é caro. Então a DeepSeek fez algo elegante: usou o próprio R1 como professor para treinar seis modelos menores de outras famílias.

O Dataset: 800 Mil Amostras

Eles geraram aproximadamente 800 mil exemplos de treinamento usando o R1 completo:

• ~600 mil exemplos de raciocínio (reasoning), gerados via rejection sampling — pediram ao R1 que resolvesse problemas, ficaram com as soluções corretas, e usaram as cadeias de pensamento completas como dado.
• ~200 mil exemplos não-raciocínio (escrita, QA, tradução), reutilizados do DeepSeek-V3.

Os Students

Os modelos menores escolhidos como students:

Todos receberam apenas SFT — sem etapa de reinforcement learning. Esta é uma decisão metodológica deliberada, declarada textualmente no paper: "we apply only SFT and do not include an RL stage." O objetivo era isolar a eficácia da destilação pura.

Os Resultados: O Surpreendente

A tabela de benchmarks do paper conta uma história notável:

A conclusão central do paper, que virou citação obrigatória: um modelo de 32 bilhões de parâmetros destilado do R1 superou um modelo de 32 bilhões treinado com mais de 10 mil passos de reinforcement learning. Destilar conhecimento pronto de um modelo maior é mais barato e eficaz que treinar raciocínio do zero no modelo pequeno.

Isso liberou, sob licença MIT, modelos de raciocínio da classe do GPT-4 que rodam em hardware acessível. Foi um marco para o open-source.

R1-Zero: O Experimento Mais Louco

Antes do R1, a DeepSeek tentou algo radical: o R1-Zero. Pegaram o modelo base (DeepSeek-V3-Base) e aplicaram reinforcement learning puro, sem nenhum supervised fine-tuning inicial — sem "cold start", sem dados humanos demonstrando raciocínio.

O algoritmo usado, GRPO (Group Relative Policy Optimization), dispensa o critic neural caro do PPO tradicional. Em vez disso, estima o baseline a partir da média de um grupo de respostas:

A_i = (r_i - mean(group)) / std(group)

Os rewards eram 100% baseados em regras: a resposta matemática está dentro de um \boxed{}? O código passa nos testes? O formato inclui as tags <think> e <answer>? Sem reward model neural, sem rotulagem humana.

E aconteceu algo notável. Durante o treino, o modelo desenvolveu espontaneamente autorreflexão. Surgiram "aha moments" — o modelo passou a escrever coisas como "espera, deixa eu reconsiderar" no meio de uma cadeia de raciocínio. Centenas a milhares de tokens de pensamento emergiram sem nunca terem sido explicitamente ensinados.

O AIME 2024 (competição matemática difícil) subiu de 15,6% para 71,0% de acerto — paridade com o OpenAI o1-0912.

A ressalva: o R1-Zero tinha problemas sérios de legibilidade e misturava chinês e inglês aleatoriamente. Por isso o R1 final combinou SFT, RL e destilação. Mas o R1-Zero provou que raciocínio pode emergir de rewards baseados em regras — um resultado profundo.

Parte 4 — A Polêmica: Destilação Não Autorizada e a Guerra Frontier

Agora a parte que faz manchete. A destilação como técnica ML é legal. Mas usar os outputs de Claude, GPT-4 ou Gemini para treinar um modelo concorrente viola os termos de uso dessas empresas. Os "Três Grandes" usam linguagem quase idêntica:

• OpenAI: "Use Output to develop models that compete with OpenAI." (proibido)
• Google Gemini: "You may not use the Services to develop models that compete with the Services."
• Anthropic (Claude): não permite usar outputs para treinar modelos que competem.

Em fevereiro de 2026, a Anthropic publicou um post técnico detalhado identificando campanhas de destilação em escala industrial:

A OpenAI, por sua vez, acusou publicamente a DeepSeek em fevereiro de 2026, em memorando à comissão da Câmara dos EUA sobre a China, mencionando "roteadores ofuscados", "aproveitar-se da P&D americana" e 2,8 milhões de GPU-hours de H800.

A Evidência de "Contaminação"

Um sinal diagnóstico curioso: DeepSeek R1 e V3, quando perguntados sobre sua própria identidade, frequentemente se identificam como "ChatGPT". Isso é citado em issues do GitHub e discussões no r/MachineLearning como evidência (não prova) de que os dados de treino incluíram outputs do GPT-4. O modelo aprendeu o padrão de resposta tão bem que internalizou a identidade do teacher.

A Ironia Central

Aqui reside o debate ético mais fascinante. A OpenAI está sendo processada pelo New York Times, autores e programadores por treinar sobre conteúdo protegido por direitos autorais sem permissão — e agora invoca "fair use" para si mesma. Ao mesmo tempo, trata a destilação alheia como roubo.

Como analistas legais observam (Harvard Law, Lawfare), a destilação ocupa uma área cinzenta: raramente ilegal sob lei de propriedade intelectual, mas acionável como quebra de contrato via termos de serviço. E difícil de enforcear entre fronteiras.

A Distinção Que Importa: Self-Distillation vs. Destilação de Terceiro

Voltemos ao caso DeepSeek-R1. Há uma diferença ética e legal crucial que se perde nas manchetes:

O caso R1-Distill é o exemplo positivo da destilação: uma força democratizadora legítima. Destilar de si mesmo é o equivalente a open-source sob esteroides.

O Muro de Proteção (E Por Que Ele Falha)

Como os labs frontier se defendem tecnicamente?

O achado mais importante: o paper do ACL 2025 demonstra que watermarks podem ser removidos por paraphrasing antes da destilação. Ou seja, não existe defesa técnica robusta comprovada até o momento. É uma corrida assimétrica — atacar é mais barato que defender.

Parte 5 — Por Que Treinar Custa Tanto

Se a destilação é tão poderosa, por que simplesmente não treinamos todos os modelos do zero com ela? Por que o GPT-4 custou ~$100 milhões para treinar?

A Lei De Chinchilla: O Custo Do Pré-Treino

Antes de destilar qualquer coisa, alguém precisa criar o modelo base — o foundation model. E isso obedece a leis de escala implacáveis.

A lei de Chinchilla (Hoffmann et al., DeepMind, 2022) estabelece que, para compute ótimo, você treina com aproximadamente 20 tokens por parâmetro. Um modelo de 1 bilhão de parâmetros precisa de ~20 bilhões de tokens.

O compute total segue aproximadamente:

C ≈ 6 × N × D

Onde N é o número de parâmetros e D é o número de tokens. Dobrar o modelo e dobrar os tokens (como Chinchilla recomenda) quadruplica o custo.

Números Concretos de Modelos Reais

A ressalva sobre DeepSeek-V3: o número de $5,576 milhões é o reportado oficialmente (compute de treino direto). Mas a SemiAnalysis estimou o custo total — incluindo P&D, falhas experimentais, infraestrutura, equipe — em mais de $1 bilhão. O número marketing-amigável esconde o custo real.

Onde Vai O Dinheiro

• GPUs (60-70%): o componente dominante. Preço de aluguel de H100 caiu de $8-10/hora (final de 2024) para $1,50-3/hora (mid-2025), mas clusters de milhares de GPUs por meses somam rápido.
• Energia (10-15%): datacenters consomem megawatts.
• Dados (variável): aquisição e, crucialmente, rotulagem humana para RLHF — milhões para modelos frontier.
• Pessoal: pesquisadores seniores custam $500 mil a $2 milhões por ano; equipes de 50 a 500 pessoas.
• Infraestrutura/rede/storage (10-20%).

O Over-Training: Por Que Os Labs Quebram Chinchilla

Aqui está um detalhe contraintuitivo. Chinchilla diz "20 tokens por parâmetro". Mas o Llama 3 70B foi treinado com ~200 tokens por parâmetro — dez vezes mais que o ótimo de compute.

Por que desperdiçar compute? Porque o objetivo não é apenas qualidade do modelo, mas custo de inferência. Um modelo over-trained fica mais eficiente para rodar depois. Você gasta mais uma vez no treino para gastar menos bilhões em inferência durante anos. É uma otimização de custo total de propriedade, não de qualidade pura.

Parte 6 — Como Treinar Seu Próprio Modelo (Sem Ser Bilionário)

Agora a parte prática. Você não vai treinar um GPT-4 do zero — isso requer $100 milhões e 25 mil GPUs. Mas você pode fine-tunar um modelo open-source para suas necessidades numa tarde, por menos de $20.

Existem três níveis, em ordem de custo:

A Mágica: LoRA e QLoRA

A razão pela qual fine-tune se tornou acessível são duas técnicas: LoRA (Low-Rank Adaptation) e QLoRA (Quantized LoRA).

Em vez de atualizar todos os bilhões de parâmetros (impossível numa GPU doméstica), o LoRA congela o modelo original e adiciona pequenos "adaptadores" de baixo rank — treina apenas 1-2% dos parâmetros. O QLoRA vai além: quantiza o modelo base para 4 bits (formato NF4), reduzindo drasticamente a memória necessária.

A redução é brutal: fine-tunar um modelo de 7 bilhões com QLoRA cabe numa GPU de 6GB — uma RTX 3060 comum.

O Stack Prático

Onde Alugar GPUs

Fine-Tune Com Dados Destilados: O Pipeline Completo

Aqui está o fluxo para você criar seu próprio modelo especializado — usando response distillation legítima (a partir de um modelo open-source que você pode destilar, ou sua própria base de dados):

# Passo 1: Gerar dados com um teacher open-source (ex: Qwen, Llama)
from openai import OpenAI

teacher = OpenAI(
    api_key="sua-key",
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"  # Qwen
)

prompts = [
    "Explique recursão para um iniciante.",
    "Otimize esta query SQL: SELECT * FROM users...",
    # ... centenas ou milhares de prompts do seu domínio
]

dataset = []
for prompt in prompts:
    resp = teacher.chat.completions.create(
        model="qwen-plus",
        messages=[{"role": "user", "content": prompt}]
    )
    dataset.append({
        "instruction": prompt,
        "output": resp.choices[0].message.content
    })

# Passo 2: Fine-tune com Unsloth (QLoRA)
# Instalar: pip install unsloth
from unsloth import FastLanguageModel
import torch

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Qwen2.5-7B-bnb-4bit",  # student base
    max_seq_length=2048,
    dtype=None,
    load_in_4bit=True,
)

model = FastLanguageModel.get_peft_model(
    model,
    r=16,  # rank do adapter LoRA
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
    lora_alpha=16,
    lora_dropout=0,
)

# Treinar com o dataset gerado pelo teacher
from trl import SFTTrainer
trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,
    dataset_text_field="text",
    max_seq_length=2048,
    args=TrainingArguments(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        num_train_epochs=3,
        learning_rate=2e-4,
        output_dir="outputs",
    ),
)
trainer.train()

Custos Estimados Para Fine-Tune

Compare com os $100 milhões do GPT-4. A diferença entre pré-treino e fine-tune é de quatro ordens de magnitude.

Parte 7 — A Geopolítica Da Destilação

Por que isso tudo importa para além da técnica?

A destilação é a alternativa de baixo custo ao compute leadership. Os EUA tentam manter liderança em IA restringindo exportações de GPUs avançadas (H800 banido em outubro de 2023, H20 ainda permitido sob condições). A lógica: sem chips, a China não consegue treinar modelos frontier.

Mas a destilação via API subverte essa lógica. Você não precisa de um cluster de 25 mil H100 para alcançar a fronteira — precisa de acesso à API de quem já está lá, mais um cluster modesto para fine-tune. É por isso que a Anthropic fala em "enfraquecer os export controls" quando acusa as empresas chinesas.

Dario Amodei, CEO da Anthropic, em análise ponderada, descreveu o DeepSeek-V3 como "um ponto esperado numa curva de redução de custo de ~4x ao ano", não um breakthrough. Curiosamente, ele não opinou sobre as acusações de destilação, dizendo apenas levar a DeepSeek "pela palavra".

A consequência macroeconômica é a comoditização dos modelos foundationais. Se a destilação permite alcançar 90% da qualidade frontier por 5% do custo, o valor migra da camada de modelos para a camada de aplicações. O "moat" econômico dos labs frontier é o que está realmente em jogo — daí a reação tão forte apesar da base legal frágil.

Conclusão: O Que Você Deve Levar

1. Destilação é uma técnica ML estabelecida e legítima (Hinton, 2015). Comprime conhecimento de um teacher num student via distribuições suaves (logit) ou respostas (response).

2. O caso DeepSeek-R1 é o exemplo positivo: destilou de si mesmo em modelos open-source menores, sob licença MIT, provando que raciocínio de classe frontier pode rodar em hardware acessível. Um modelo de 32B destilado superou um 32B treinado com 10 mil passos de RL.

3. A destilação não autorizada de APIs fechadas (Claude, GPT-4) é o centro da polêmica: legal como técnica, mas viola termos de uso. A Anthropic documentou 16 milhões de interações; a OpenAI acusou a DeepSeek publicamente.

4. Não há defesa técnica robusta: watermarking falha contra paraphrasing (ACL 2025). A corrida é assimétrica.

5. Pré-treino do zero é proibitivo ($60M-$1B+), mas fine-tune é acessível ($5-$100 com QLoRA + Unsloth). A diferença é de quatro ordens de magnitude.

6. Você pode treinar seu próprio modelo hoje: pegue um modelo open-source como teacher, gere dados do seu domínio, fine-tune um student com QLoRA numa GPU de $2/hora. É exatamente o pipeline que democratizou a IA.

A destilação é, simultaneamente, a técnica mais poderosa e mais controversa da IA atual. Comprime conhecimento, reduz custos, democratiza acesso — e, no processo, ameaça os modelos de negócio de quem construiu a fronteira. Entender como ela funciona não é mais opcional para quem trabalha com IA.

Referências

Papers fundamentais:

• Hinton et al. — Distilling the Knowledge in a Neural Network (2015)
• Hoffmann et al. — Chinchilla Scaling Laws (2022)
• DeepSeek-R1 Technical Report (jan/2025)

Destilação em LLMs:

• MiniLLM — Reverse KL Distillation (2023)
• GKD — Generalized Knowledge Distillation (ICLR 2024)
• LLMs Are Reasoning Teachers (ACL 2023)
• Agent Distillation (2025)

Self-play / RL:

• DPO — Direct Preference Optimization (2023)
• SPIN — Self-Play Fine-Tuning (NeurIPS 2024)
• Self-Rewarding Language Models (ICML 2024)

Análises industriais e reportagens:

• Anthropic — Detecting and Preventing Distillation Attacks (fev/2026)
• Dario Amodei — On DeepSeek and Export Controls
• Reuters — OpenAI acusa DeepSeek (fev/2026)
• Harvard Law — DeepSeek, ChatGPT and Global Tech Supremacy
• Lawfare — Responding to AI Distillation Without Panic
• ACL 2025 — Watermarks falham contra destilação
• Simon Willison — DeepSeek R1 family

Ferramentas práticas:

• Unsloth — Fine-tune 2x mais rápido
• Axolotl — Multi-GPU fine-tuning
• DeepSeek-R1 GitHub (modelos destilados)

Próximo artigo da série: Como montar um pipeline de destilação completo — de geração de dados com teacher open-source até deploy do student fine-tunado com vLLM.