Resumo
nanochat é o framework open source de Andrej Karpathy que permite treinar um chatbot no nível do GPT-2 por menos de US$50 em cerca de 2 horas, rodando em um único nó com 8 GPUs H100, usando código enxuto (~500 linhas para o modelo principal) e uma configuração simplificada por meio do seletor --depth. O projeto já registrou treinamento concluído em 1,65 horas, com pontuação CORE de 0,2626 — superando o GPT-2 original da OpenAI, que custou US$43.000 e levou 168 horas.
Introdução
Treinar grandes modelos de linguagem costumava ser privilégio de poucos: exigia milhões de dólares e equipes de PHDs. Agora, isso mudou.
Andrej Karpathy lançou o nanochat, um projeto open source capaz de treinar uma IA conversacional funcional por menos do que o custo de um jantar. O pipeline todo roda em um único nó GPU 8xH100 e termina em menos de duas horas.
Por Que Isso Importa Agora
O salto tecnológico desde 2019 é enorme. O que custava US$43.000 e 168 horas para a OpenAI treinar, agora requer 1,65 horas e US$48. Essa aceleração de 100x foi impulsionada por avanços algorítmicos, hardware mais potente e otimizações vindas da comunidade.
Para quem desenvolve APIs ou aplicações baseadas em IA, isso abre espaço para experimentar modelos customizados, testar arquiteturas e mergulhar nos detalhes dos LLMs sem precisar de orçamento bilionário.
💡 Combine isso com plataformas como Apidog para testar e documentar seus serviços de IA — e monte uma stack completa, pronta para produção.
O Que Você Vai Aprender
Ao final, você saberá:
- Como o nanochat atingiu 100x de redução de custo no treinamento de LLMs
- Arquitetura completa: modelo GPT, otimizador Muon, dataloader
- Passo a passo prático para treinar seu modelo
- Como usar nanochat para pesquisa/experimentação rápida com LLMs
- Limites reais: o que significa “capacidade GPT-2”
O Que É o nanochat?
nanochat é um sistema mínimo para treinamento de LLMs, cobrindo tokenização, pré-treinamento, fine-tuning (SFT), avaliação, inferência e interface web estilo ChatGPT.
O código fica em um único repositório, sem dependências pesadas ou configurações complexas — projetado para ser legível, fácil de modificar e forkar.
A Principal Proposta
Treinar um modelo no nível do GPT-2 (1.6B parâmetros) por:
- US$48 sob demanda (~2 horas a US$24/hora em 8xH100)
- ~US$15 em instâncias spot
Para comparar, o GPT-2 original da OpenAI custou ~US$43.000 e 7 dias em 32 TPUs v3.
O Que o nanochat Abrange
| Estágio | Script | Descrição |
|---|---|---|
| Tokenização | scripts.tok_train |
Treina tokenizador BPE (vocabulário 32768) |
| Pré-treinamento | scripts.base_train |
Treina modelo GPT base |
| Ajuste Fino | scripts.chat_sft |
SFT supervisionado para chat |
| Avaliação | scripts.base_eval |
Métrica CORE, bits-por-byte |
| Inferência | scripts.chat_cli |
Chat via linha de comando |
| UI Web | scripts.chat_web |
Interface web estilo ChatGPT |
Filosofia: Um Único Seletor Para Controlar Tudo
A maioria dos frameworks LLM exige múltiplos arquivos de configuração. O nanochat faz o oposto: tudo gira em torno do parâmetro --depth (número de camadas do transformer).
# Modelo tamanho GPT-1
torchrun --standalone --nproc_per_node=8 -m scripts.base_train -- --depth=12
# Modelo capacidade GPT-2
torchrun --standalone --nproc_per_node=8 -m scripts.base_train -- --depth=24
# Indo além
torchrun --standalone --nproc_per_node=8 -m scripts.base_train -- --depth=26
Defina a profundidade: o resto (largura, heads, LR, batch, steps) é ajustado automaticamente pelo script.
Essa estratégia permite criar uma família de modelos otimizados (“nanochat miniseries”), todos com base na mesma lógica.
Por Que Isso Funciona
Karpathy e equipe mediram relações de escala em dezenas de runs. Encontraram proporções previsíveis entre profundidade, largura, batch e duração — e codificaram essas relações no script, eliminando a necessidade de múltiplos hiperparâmetros.
Assim, qualquer um pode treinar modelos otimizados sem precisar dominar os detalhes de deep learning.
Ranking: Corrida Para Superar o GPT-2
Nanochat mantém um ranking público para medir o tempo até atingir a capacidade do GPT-2 (CORE score da OpenAI: 0,256525).
Recordes Atuais
| Execução | Modelo | Tempo | CORE | Inovação |
|---|---|---|---|---|
| GPT-2 Original | 1.6B | 168h | 0.2565 | Baseline OpenAI 2019 |
| Execução 1 | d24 | 3.04h | 0.2585 | Baseline inicial |
| Execução 2 | d26 | 2.91h | 0.2578 | Treinamento FP8 |
| Execução 3 | d26 | 2.76h | 0.2602 | Batch de 1M tokens |
| Execução 4 | d24 | 2.02h | 0.2571 | Dataset ClimbMix |
| Execução 5 | d24 | 1.80h | 0.2690 | Otimizações via IA |
| Execução 6 | d24 | 1.65h | 0.2626 | Smear/backout aprimorado |
Como a IA Descobriu Otimizações
Nas execuções 5 e 6, um agente IA testou mudanças arquiteturais em modelos pequenos (d12, 5min de treino), depois aplicou as melhores no d24.
Melhorias encontradas:
- Backout: Subtração residual intermediária
- Smear: Mistura de bigramas mais eficiente
Esses ajustes cortaram o tempo de treino de 2,02h para 1,65h (~19%).
Como o nanochat Funciona
O core do código tem cerca de 3.000 linhas. Veja os principais módulos:
1. Modelo GPT (nanochat/gpt.py)
O transformer implementa práticas modernas e otimizações.
Recursos da Arquitetura:
- RoPE: Codificação posicional relativa
- Normalização QK: Estabiliza treino em larga escala
- Embeddings não vinculados: Separação de embeddings de entrada e saída
- ReLU²: Ativação MLP mais eficiente
- GQA: Atenção com menos heads KV
- Atenção de janela: Contexto curto/longo alternado (ex: “SSSL”)
- Flash Attention 3: Otimização para Hopper, fallback para SDPA
Embeddings de Valor (ResFormer):
# Residual de valor: mistura embedding com gate por head
if ve is not None:
ve = ve.view(B, T, self.n_kv_head, self.head_dim)
gate = 3 * torch.sigmoid(self.ve_gate(x[..., :self.ve_gate_channels]))
v = v + gate.unsqueeze(-1) * ve
Truques de Eficiência:
# 1. Residual escalonado por camada
x = self.resid_lambdas[i] * x + self.x0_lambdas[i] * x0
# 2. Smear: mistura embedding do token anterior
gate = self.smear_lambda * torch.sigmoid(self.smear_gate(x[:, :, :24]))
x = x + gate * x_pre_smear
# 3. Backout: subtrai resíduo intermediário
x = x - self.backout_lambda * x_backout
2. Otimizador Muon (nanochat/optim.py)
Nanochat adota otimização mista:
| Parâmetro | Otimizador | Finalidade |
|---|---|---|
| Embeddings, lm_head | AdamW | Otimização adaptativa |
| Escalares | AdamW | Fatores de escala |
| Matrizes 2D | Muon | Atualização ortogonalizada |
Muon (Momento Ortogonalizado por Newton-Schulz):
# Polar Express: 5 iterações
polar_express_coeffs = [
(8.156, -22.483, 15.879),
(4.043, -2.809, 0.500),
# ...
]
for a, b, c in polar_express_coeffs[:ns_steps]:
A = X.mT @ X
B = b * A + c * (A @ A)
X = a * X + X @ B
Redução de variância NorMuon:
v_mean = g.float().square().mean(dim=red_dim, keepdim=True)
v_norm = v_mean.sum(dim=(-2, -1), keepdim=True).sqrt()
final_scale = step_size * (v_norm / v_norm_new.clamp_min(1e-10))
g = g * final_scale.to(g.dtype)
Treinamento Distribuído: Otimizador implementa sharding estilo ZeRO-2 com comunicação assíncrona em 3 fases.
3. Gerenciamento de Precisão (nanochat/common.py)
Nanochat controla precisão explicitamente (sem torch.amp.autocast):
| Hardware | dtype padrão | Motivo |
|---|---|---|
| CUDA SM 80+ (A/H100) | bfloat16 | Cores tensor BF16 nativos |
| CUDA < 80 (V100/T4) | float32 | Sem suporte BF16 |
| CPU/MPS | float32 | Sem cores reduzidas |
Exemplo de camada Linear:
class Linear(nn.Linear):
def forward(self, x):
return F.linear(x, self.weight.to(dtype=x.dtype))
Treinamento FP8 disponível via --fp8 para H100+.
4. Carregamento de Dados (nanochat/dataloader.py)
Dataloader usa empacotamento best-fit alinhado ao token BOS:
- Cada linha começa com BOS
- Documentos encaixados por algoritmo best-fit
- Quando não cabe, corta documento para preencher
- ~100% de uso, ~35% corte em seq. 2048
Exemplo:
# Busca maior doc que cabe
best_idx = -1
best_len = 0
for i, doc in enumerate(doc_buffer):
doc_len = len(doc)
if doc_len <= remaining and doc_len > best_len:
best_idx = i
best_len = doc_len
if best_idx >= 0:
doc = doc_buffer.pop(best_idx)
# Adiciona doc inteiro
else:
# Corta doc mais curto para preencher espaço
5. Flash Attention Unificado (nanochat/flash_attention.py)
Interface unificada alterna FA3 e SDPA conforme hardware:
from nanochat.flash_attention import flash_attn
y = flash_attn.flash_attn_func(q, k, v, causal=True, window_size=window_size)
Usa FA3 em Hopper+bfloat16, fallback para SDPA em outros casos.
6. Motor de Inferência (nanochat/engine.py)
Classe Engine faz:
- Cache KV: cache de prompt pré-preenchido (FA3)
-
Ferramentas: tokens especiais ativam calculadora Python via
eval() - Batch generation: clones de cache KV para amostragem paralela
Coordena geração de conversas e tokens especiais.
Passo a Passo: Treine Seu Próprio Modelo
O pipeline está em runs/speedrun.sh.
Pré-requisitos
- Nó GPU 8xH100 (ou similar)
- ~20GB de disco para dataset
- Python 3.10+
- Gerenciador de pacotes
uv
1. Configuração do Ambiente
# Instale uv
curl -LsSf https://astral.sh/uv/install.sh | sh
# Crie e ative o venv
uv venv
source .venv/bin/activate
# Instale dependências
uv sync --extra gpu
2. Baixe os Dados de Treinamento
python -m nanochat.dataset -n 170
# Baixa ~170 shards (~100MB cada) = ~17GB compactados
3. Treine o Tokenizador
python -m scripts.tok_train
python -m scripts.tok_eval
Treinamento termina em ~10 minutos nos 2B caracteres.
4. Pré-treine o Modelo Base
torchrun --standalone --nproc_per_node=8 -m scripts.base_train -- \
--depth=24 \
--target-param-data-ratio=8 \
--device-batch-size=16 \
--fp8 \
--run=my-first-model
-
--depth=24: Tamanho GPT-2 -
--target-param-data-ratio=8: Sub-treino para velocidade -
--device-batch-size=16: Batch por GPU -
--fp8: Habilita FP8 (H100+)
Tempo: ~2 horas.
5. Ajuste Fino Supervisionado
curl -L -o ~/.cache/nanochat/identity_conversations.jsonl \
https://karpathy-public.s3.us-west-2.amazonaws.com/identity_conversations.jsonl
torchrun --standalone --nproc_per_node=8 -m scripts.chat_sft -- \
--device-batch-size=16 \
--run=my-sft
Ensina formato de chat, tokens especiais e uso de ferramentas.
6. Converse Com o Seu Modelo
# Chat CLI
python -m scripts.chat_cli -p "Por que o céu é azul?"
# UI web
python -m scripts.chat_web
A interface web roda na porta 8000, estilo ChatGPT.
Fluxo de Pesquisa: Experimentação Rápida
Para testar ideias, use modelos menores para ciclos rápidos.
Experimentos Rápidos (~5 minutos)
OMP_NUM_THREADS=1 torchrun --standalone --nproc_per_node=8 -m scripts.base_train -- \
--depth=12 \
--run="d12-test" \
--core-metric-every=999999 \
--sample-every=-1 \
--save-every=-1
Modelo d12 (GPT-1), log mínimo, ideal para testar arquitetura.
Métricas para Monitorar
- val_bpb: Bits-por-byte de validação
- core_metric: Score DCLM CORE
- train/mfu: Utilização de FLOPS
- train/tok_per_sec: Vazão de tokens
Requisitos de Teste
Melhorias devem funcionar em todas as profundidades (d12 a d26). Evite overfitting em um só tamanho!
Por Que nanochat Importa
Acessibilidade de Custo
| Abordagem | Custo | Tempo | Hardware |
|---|---|---|---|
| GPT-2 (2019) | $43.000 | 168h | 32x TPU v3 |
| nanochat (2026) | $48 | 2h | 8x H100 |
| nanochat spot | ~$15 | 2h | 8x H100 (spot) |
Agora é acessível para:
- Pesquisadores individuais
- Startups pequenas
- Cursos universitários
- Amadores
Valor Educacional
- ~500 linhas para modelo GPT
- ~530 linhas para otimizador
- Comentários claros e sem configurações ocultas
- Ideal para estudo, modificação e experimentação
Velocidade de Pesquisa
- Teste de hipóteses rápido
- Mais experimentos por semana
- Baixo custo de erro
- Ranking público estimula colaboração
Transparência
- Leis de escala documentadas em
dev/LOG.md - Ablations em GitHub Discussions
- Detalhes de reprodução para ranking
- IA contribui de forma transparente
Limitações e Realidade
Requisitos de Hardware
O custo de US$48 assume nó 8xH100. Preço por provedor:
- Lambda Labs: ~US$25/h para 8xH100
- RunPod: ~US$15/h spot
- Tempo: ~2h pré-treino + SFT
Reserve US$50-100 para execução completa.
Teto de Capacidade
Nanochat = desempenho GPT-2 (2019):
Pode fazer:
- Chat básico
- Raciocínio simples
- Matemática elementar
- Recordação limitada
Não faz:
- Raciocínio complexo
- Geração de código avançada
- Seguimento instruções complexas
- Competir com GPT-4, Claude, Gemini
Pense como “criança do jardim de infância”.
Requisitos de Dados
- ~170 shards
- ~17GB compactados
- ~2B caracteres
Necessário armazenamento e banda.
Limitações de Métrica
CORE score cobre 22 tarefas, mas não:
- Qualidade de chat real
- Conhecimento de domínio
- Nuance de instrução
- Segurança/alinhamento
Variância de ~0,016 entre seeds. Resultados podem variar.
FAQ
Quanto custa treinar um modelo?
US$48 sob demanda (2h x US$24/h) ou ~US$15 em spot, para pré-treino. SFT adiciona ~30min.
Qual GPU é necessária?
Mínimo: 1 GPU moderna de datacenter. Ideal: 8xH100 ou 8xA100. Código escala de 1 a 8 GPUs com acumulação automática de gradiente.
Quanto tempo leva?
De 1,65 a 3 horas conforme configuração/hardware. Recorde atual: 1,65h (d24).
O que é métrica CORE?
Score DCLM CORE avalia 22 tarefas (ARC, MMLU, etc). GPT-2: 0,256525. Nanochat: >0,26.
Posso treinar em uma GPU só?
Sim. Sem torchrun, usa acumulação automática. Treinamento é 8x mais lento, mas resultado quase idêntico.
Qual dataset?
Melhor resultado: ClimbMix (web curado pela NVIDIA). Tokenizador treina em ~2B caracteres dos primeiros 8 shards (~uns 17GB).
Funciona em Apple Silicon?
Sim. Roda em MPS (float32). Mais lento que CUDA, mas útil para experimentação.
Posso retomar de um checkpoint?
Sim. Use --resume-from-step=<step>. Estado do dataloader é salvo para retomada exata.
Diferença nanochat x nanoGPT?
nanoGPT só pré-treinava. nanochat cobre pipeline completo: tokenização, pré-treino, SFT, RLHF, avaliação, inferência e UI web.
Conclusão
Nanochat mostra que treinar LLM não exige mais fortunas ou clusters exclusivos. O que custava US$43.000 em 2019 agora sai por menos de US$50.
Mais do que custo, o projeto é uma base mínima, legível e com interface única — ideal tanto para pesquisa quanto para aprendizado.
Principais Pontos
- 100x redução de custo: $43.000 → $48 para GPT-2
- 100x mais rápido: 168h → 1,65h
-
Um seletor de configuração:
--depthfaz tudo - Pipeline completo: tokenização até UI web
- Impulsionado pela comunidade: ranking público, melhorias contínuas
Próximos Passos
Quer treinar seu próprio modelo? Comece pelo repositório nanochat e o script runs/speedrun.sh.
Para quem desenvolve APIs e IA, nunca foi tão fácil entender as entranhas do treino de LLMs. A barreira caiu de “startup bilionária” para “projeto de fim de semana”.
Top comments (0)