Como Treinar Seu Próprio ChatGPT por 50 Dólares?

Resumo

nanochat é o framework de treinamento de LLM de código aberto de Andrej Karpathy que permite treinar um chatbot de nível GPT-2 por menos de US$50 em cerca de 2 horas. O projeto utiliza um único nó de GPU 8xH100, código mínimo (~500 linhas para o modelo central) e um único seletor de configuração (--depth) para otimizar automaticamente todos os hiperparâmetros. Registros atuais mostram a conclusão do treinamento em 1,65 horas com uma pontuação CORE de 0,2626, superando o GPT-2 da OpenAI de 2019 que custou US$43.000 e levou 168 horas.

Introdução

Treinar um grande modelo de linguagem costumava exigir milhões de dólares e uma equipe de pesquisadores com doutorado. Esses dias acabaram.

Andrej Karpathy acaba de lançar o nanochat, um projeto de código aberto que treina uma IA conversacional capaz por menos do custo de um bom jantar. Todo o pipeline roda em um único nó de GPU 8xH100 e é concluído em menos de 2 horas.

Por Que Isso Importa Agora

O cenário da IA mudou drasticamente no início de 2026. O que levou 168 horas e US$43.000 à OpenAI em 2019, agora leva 1,65 horas e US$48. Isso representa uma aceleração de 100x impulsionada por melhorias algorítmicas, hardware superior e otimização da comunidade.

Para desenvolvedores de API e equipes que constroem aplicações baseadas em IA, isso muda tudo. Agora você pode experimentar o treinamento de modelos personalizados, testar mudanças arquitetônicas e entender os internos de LLMs sem orçamentos massivos de infraestrutura.

O Que Você Aprenderá

Ao final deste artigo, você entenderá:

• Como o nanochat alcança uma redução de custo de 100x em comparação com o treinamento tradicional de LLMs
• A arquitetura completa (modelo GPT, otimizador Muon, carregamento de dados)
• Instruções passo a passo para treinar seu próprio modelo
• Como usar o nanochat para pesquisa e experimentação rápidas de LLMs
• Limitações reais e o que a capacidade do GPT-2 realmente significa

O Que É o nanochat?

nanochat é um sistema mínimo de treinamento de LLM que cobre todo o pipeline de desenvolvimento: tokenização, pré-treinamento, ajuste fino (finetuning), avaliação, inferência e uma UI web semelhante ao ChatGPT.

O código-base cabe em um único repositório, sem monstros de configuração ou complexidade de framework. Karpathy o projetou como uma "linha de base forte" que é legível, hackeável e forkeável.

A Principal Afirmação

Treine um modelo com capacidade de GPT-2 (1.6B parâmetros) por:

• US$48 sob demanda (2 horas a ~$24/hora para 8xH100)
• ~$15 em instâncias spot

Para contextualizar, o treinamento original do GPT-2 da OpenAI em 2019 custou aproximadamente US$43.000 e levou 7 dias em 32 chips TPU v3.

O Que o nanochat Abrange

A Filosofia: Um Único Seletor Para Controlar Tudo

A maioria dos frameworks de LLM te afoga em arquivos de configuração. O nanochat adota a abordagem oposta.

Todo o sistema gira em torno de um parâmetro: --depth (o número de camadas do transformador).

# Modelo do tamanho do GPT-1
torchrun --standalone --nproc_per_node=8 -m scripts.base_train -- --depth=12

# Modelo com capacidade de GPT-2
torchrun --standalone --nproc_per_node=8 -m scripts.base_train -- --depth=24

# Indo além dos limites
torchrun --standalone --nproc_per_node=8 -m scripts.base_train -- --depth=26

Defina a profundidade, e o nanochat calcula todo o resto automaticamente:

• Largura do transformador (dimensão de embedding)
• Número de cabeças de atenção
• Taxas de aprendizado para cada grupo de parâmetros
• Horizonte de treinamento (total de passos)
• Agendamentos de decaimento de peso
• Tamanhos de batch

Essa filosofia de "um único seletor" possibilita o que Karpathy chama de minissérie nanochat: uma família de modelos otimizados para computação em diferentes tamanhos, todos treinados com a mesma abordagem baseada em princípios.

Por Que Isso Funciona

A equipe mediu leis de escala em dezenas de execuções de treinamento. Eles encontraram relações previsíveis entre profundidade, largura, tamanho do batch e duração do treinamento. Em vez de expor todos esses controles, o nanochat codifica essas relações diretamente no script de treinamento.

Você obtém treinamento otimizado para computação sem precisar de um doutorado em deep learning.

O Ranking: Correndo para Superar o GPT-2

O nanochat mantém um ranking público que acompanha o tempo para atingir a capacidade do "GPT-2". O objetivo é superar a pontuação CORE original da OpenAI de 0,256525 em 22 tarefas de avaliação (ARC, MMLU e outras do conjunto de benchmarks DCLM).

Recordes Atuais

Como a IA Descobriu Otimizações

As execuções 5 e 6 incorporaram mudanças do sistema de "auto-pesquisa" de Karpathy. Um agente de IA explorou modificações arquitetônicas em pequenos modelos d12 (execuções de treinamento de 5 minutos), então traduziu as mudanças vencedoras para a configuração d24 completa.

O sistema encontrou melhorias para:

• Mecanismo de backout: Melhor subtração residual de camada intermediária
• Implementação de smear: Mistura de bigramas mais eficiente a partir de tokens anteriores

Essas mudanças reduziram o tempo de treinamento de 2,02 horas para 1,65 horas, uma melhoria de 19% descoberta através de experimentação autônoma.

Como o nanochat Funciona

O código-base contém aproximadamente 3.000 linhas em seus módulos centrais. Vamos examinar cada componente.

1. O Modelo GPT (nanochat/gpt.py)

O transformador segue as melhores práticas modernas com várias otimizações:

Recursos da Arquitetura:

• Embeddings Rotacionais (RoPE): Codificação posicional relativa sem embeddings de posição aprendidos
• Normalização QK: Estabiliza o treinamento em escala
• Pesos não vinculados: Camadas separadas de embedding de token e projeção de saída
• Ativação ReLU²: ReLU ao quadrado no MLP em vez de GeLU
• Atenção de Consulta Agrupada (GQA): Menos cabeças KV do que cabeças de consulta para inferência mais rápida
• Atenção de janela deslizante: Padrão configurável (por exemplo, "SSSL" alterna contexto curto/longo)
• Flash Attention 3: Otimização para GPU Hopper com fallback para SDPA

Embeddings de Valor (ResFormer):Camadas alternadas incluem embeddings de valor aprendíveis misturados via gating dependente da entrada:

# Resíduo de valor: mistura o embedding de valor com gate por cabeça
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

Isso adiciona capacidade sem uma sobrecarga de computação significativa.

Truques de Eficiência:

O modelo inclui três mecanismos aprendidos que melhoram a dinâmica do treinamento:

# 1. Escalonamento residual por camada
x = self.resid_lambdas[i] * x + self.x0_lambdas[i] * x0

# 2. Smear: mistura o embedding do token anterior para informação de bigrama
gate = self.smear_lambda * torch.sigmoid(self.smear_gate(x[:, :, :24]))
x = x + gate * x_pre_smear

# 3. Backout: subtrai o resíduo da camada intermediária
x = x - self.backout_lambda * x_backout

2. O Otimizador Muon (nanochat/optim.py)

O nanochat usa uma estratégia de otimizador mista:

Muon (Momento Ortogonalizado por Newton-Schulz):

O otimizador Muon ortogonaliza as atualizações de peso usando uma iteração quíntica de Newton-Schulz chamada "Polar Express":

# Coeficientes Polar Express (5 iterações)
polar_express_coeffs = [
    (8.156, -22.483, 15.879),
    (4.043, -2.809, 0.500),
    # ... mais coeficientes
]

# Loop de ortogonalização
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:

Após a ortogonalização, as atualizações são normalizadas por neurônio para evitar o colapso da escala:

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:

Para configurações multi-GPU, o otimizador implementa o sharding estilo ZeRO-2 com comunicação assíncrona de três fases:

Fase 1: Inicia todas as operações assíncronas reduce_scatter
Fase 2: Aguarda as reduções, calcula as atualizações, inicia os all_gathers
Fase 3: Aguarda os gathers, copia de volta os parâmetros atualizados

Isso sobrepõe a comunicação com a computação, maximizando a utilização da GPU.

3. Gerenciamento de Precisão (nanochat/common.py)

O nanochat gerencia a precisão explicitamente em vez de usar torch.amp.autocast:

A camada Linear personalizada converte os pesos para corresponder ao dtype de computação durante o forward pass:

class Linear(nn.Linear):
    def forward(self, x):
        return F.linear(x, self.weight.to(dtype=x.dtype))

Os pesos mestres permanecem em FP32 para a precisão do otimizador. Para GPUs H100 e Blackwell, o treinamento FP8 está disponível via --fp8, convertendo a maioria das camadas para Float8Linear com escalonamento por tensor.

4. Carregamento de Dados (nanochat/dataloader.py)

O dataloader usa empacotamento best-fit alinhado ao BOS:

• Cada linha começa com o token BOS (Início da Sequência)
• Documentos empacotados usando algoritmo best-fit para minimizar o desperdício
• Quando nenhum documento cabe, um é cortado para preencher exatamente
• 100% de utilização com ~35% de corte de token em comprimento de sequência de 2048

Isso garante que cada token possa referenciar o BOS e ver o contexto completo do documento.

# Encontra o maior documento que cabe inteiramente
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 o documento completo
else:
    # Corta o documento mais curto para preencher o espaço restante

5. Unificação do Flash Attention (nanochat/flash_attention.py)

O projeto fornece uma interface unificada que alterna automaticamente entre FA3 e PyTorch SDPA:

from nanochat.flash_attention import flash_attn

# Funciona em qualquer hardware - seleciona automaticamente o melhor backend
y = flash_attn.flash_attn_func(q, k, v, causal=True, window_size=window_size)

Em GPUs Hopper com bfloat16, ele usa Flash Attention 3. Em todos os outros lugares, ele retorna à atenção de produto escalar escalonado do PyTorch.

6. Motor de Inferência (nanochat/engine.py)

A classe Engine lida com a geração eficiente com:

• Cache KV: Cache de prompt pré-preenchido com flash_attn_with_kvcache do FA3
• Uso de Ferramentas: Tokens especiais acionam a calculadora Python via eval()
• Geração em Batch: Clona o cache KV para amostragem paralela

O motor coordena o fluxo da conversação, incluindo a forçagem de tokens de saída de ferramentas quando o modelo invoca a calculadora.

Passo a Passo: Treine Seu Próprio Modelo

Todo o pipeline reside em runs/speedrun.sh. Veja como executá-lo.

Pré-requisitos

• Nó de GPU 8xH100 (ou similar)
• ~20 GB de espaço em disco para o dataset
• Python 3.10+
• Gerenciador de pacotes uv

Passo 1: Configuração do Ambiente

# Instalar uv
curl -LsSf https://astral.sh/uv/install.sh | sh

# Criar e ativar ambiente virtual
uv venv
source .venv/bin/activate

# Instalar dependências
uv sync --extra gpu

Passo 2: Baixar Dados de Treinamento

# Baixar ~2B caracteres do dataset ClimbMix
python -m nanochat.dataset -n 170

# Isso baixa ~170 shards de ~100MB cada
# Total: ~17 GB comprimidos

O script baixa shards de dados de pré-treinamento com bloqueio de arquivo para lidar com a coordenação multi-rank.

Passo 3: Treinar o Tokenizador

# Treina o tokenizador BPE com vocabulário de 32.768
python -m scripts.tok_train

# Avalia a taxa de compressão
python -m scripts.tok_eval

O tokenizador usa um padrão de divisão estilo GPT-4 com BPE de fallback de byte. O treinamento é concluído em ~10 minutos em 2B caracteres.

Passo 4: Pré-treinar o Modelo Base

# Treina o modelo d24 (capacidade GPT-2)
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

Parâmetros chave:

• --depth=24: Modelo do tamanho do GPT-2
• --target-param-data-ratio=8: Ligeiramente sub-treinado para velocidade
• --device-batch-size=16: Tamanho de batch por GPU
• --fp8: Habilita treinamento FP8 (apenas H100+)

Tempo de execução esperado: ~2 horas.

Passo 5: Ajuste Fino Supervisionado

# Baixar conversas de identidade
curl -L -o ~/.cache/nanochat/identity_conversations.jsonl \
    https://karpathy-public.s3.us-west-2.amazonaws.com/identity_conversations.jsonl

# Executar SFT para capacidade de chat
torchrun --standalone --nproc_per_node=8 -m scripts.chat_sft -- \
    --device-batch-size=16 \
    --run=my-sft

Isso ensina ao modelo o formato de conversação, tokens especiais e uso de ferramentas.

Passo 6: Conversar Com Seu Modelo

# Chat CLI
python -m scripts.chat_cli -p "Por que o céu é azul?"

# Ou iniciar a UI web
python -m scripts.chat_web

A UI web roda na porta 8000 e fornece uma interface semelhante ao ChatGPT.

Fluxo de Trabalho de Pesquisa: Experimentação Rápida

Para testar novas ideias, use modelos menores para uma iteração mais rápida.

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

Isso treina um modelo d12 (tamanho GPT-1) com log mínimo. Perfeito para testar mudanças arquitetônicas.

Métricas a Monitorar

Acompanhe estas no Weights & Biases:

1. val_bpb: Bits-por-byte de validação (perda independente do tamanho do vocabulário)
2. core_metric: Pontuação de avaliação DCLM CORE
3. train/mfu: Utilização de FLOPS do modelo (eficiência de hardware)
4. train/tok_per_sec: Vazão de treinamento

Requisitos de Teste

Qualquer melhoria deve funcionar em todas as profundidades (d12 a d26). Isso evita o overfitting a um único tamanho de modelo e garante avanços baseados em princípios.

Por Que o nanochat Importa

Acessibilidade de Custo

Isso torna o treinamento de LLMs acessível a:

• Pesquisadores individuais
• Startups pequenas
• Cursos universitários
• Amadores

Valor Educacional

O código-base serve como um recurso de aprendizado:

• ~500 linhas para o modelo GPT
• ~530 linhas para o otimizador
• Comentários claros sobre cada decisão de design
• Nenhuma configuração oculta

Estudantes podem ler, modificar e experimentar um pipeline completo de LLM.

Velocidade de Pesquisa

Reduzir o treinamento de dias para horas permite:

• Teste de hipóteses mais rápido
• Mais experimentos por semana
• Menor custo de falha
• Colaboração da comunidade via ranking

Transparência

Cada escolha de design é documentada:

• Leis de escala em dev/LOG.md
• Estudos de ablação em GitHub Discussions
• Detalhes completos de reprodução para entradas do ranking
• Divulgação clara da contribuição da IA

Limitações e Verificação da Realidade

O nanochat é impressionante, mas possui limites claros.

Requisitos de Hardware

O valor de US$48 assume acesso a um nó 8xH100. Os custos de aluguel em nuvem variam:

• Lambda Labs: ~$25/hora para 8xH100
• RunPod: ~$15/hora preço spot
• Tempo total de execução: ~2 horas de pré-treinamento + SFT

Você precisará de ~$50-100 para uma execução completa, dependendo do provedor.

Teto de Capacidade

O nanochat alcança desempenho de nível GPT-2 (tecnologia de 2019). Isso significa:

O que ele pode fazer:

• Conversação básica
• Raciocínio simples
• Matemática elementar
• Recordação de fatos (limitada)

O que ele não pode fazer:

• Raciocínio complexo multi-etapas
• Geração de código além de funções simples
• Seguimento de instruções com nuance
• Competir com GPT-4, Claude ou Gemini

Pense nele como uma criança do jardim de infância: capaz de conversação básica, mas não de trabalho de nível especialista.

Requisitos de Dados

A execução completa (speedrun) baixa:

• ~170 shards de dados
• ~17 GB comprimidos
• ~2B caracteres no total

Você precisará de armazenamento e largura de banda adequados.

Limitações da Métrica

A pontuação CORE mede 22 tarefas, mas não captura:

• Qualidade de conversação no mundo real
• Conhecimento específico de domínio
• Nuance no seguimento de instruções
• Segurança e alinhamento

Diferentes sementes aleatórias produzem uma variância CORE de ~0,016. Seus resultados podem variar.

FAQ

Quanto custa para treinar um modelo com nanochat?

Aproximadamente US$48 sob demanda (US$24/hora × 2 horas) ou ~$15 em instâncias spot. Isso cobre apenas o pré-treinamento. Adicione ~30 minutos para SFT.

Qual GPU eu preciso?

Mínimo: Uma única GPU (qualquer GPU de datacenter moderna). Ótimo: 8xH100 ou 8xA100 para o treinamento mais rápido. O código escala de 1 GPU para 8 GPUs com acumulação automática de gradientes.

Quanto tempo leva o treinamento?

De 1,65 a 3 horas, dependendo da configuração e do hardware. O recorde atual no ranking é de 1,65 horas para um modelo d24.

O que é a métrica CORE?

A pontuação DCLM CORE avalia modelos em 22 tarefas, incluindo ARC (perguntas científicas), MMLU (compreensão de linguagem multi-tarefa) e outros benchmarks. O GPT-2 obteve 0,256525. O nanochat regularmente excede 0,26.

Posso treinar em uma única GPU?

Sim. Omita torchrun e o código usará automaticamente a acumulação de gradientes. O treinamento levará 8× mais tempo, mas produzirá resultados quase idênticos.

Qual dataset o nanochat usa?

O melhor atualmente usa ClimbMix (dataset web curado pela NVIDIA). Versões anteriores usavam FineWeb-EDU. O tokenizador treina em ~2B caracteres dos primeiros ~8 shards.

O nanochat funciona em Apple Silicon?

Sim. O código roda em MPS (Metal Performance Shaders) com precisão float32. O treinamento é mais lento que CUDA, mas funcional para experimentação.

Posso retomar o treinamento de um checkpoint?

Sim. Use --resume-from-step=<step> para continuar a partir de um checkpoint salvo. O estado do dataloader também é salvo para uma retomada exata.

Qual a diferença entre nanochat e nanoGPT?

nanoGPT cobria apenas o pré-treinamento. nanochat se estende a todo o pipeline: tokenização, pré-treinamento, SFT, RLHF, avaliação, inferência e UI web.

Conclusão

O nanochat prova que o treinamento de LLM não exige mais orçamentos massivos ou infraestrutura especializada. O que custava US$43.000 em 2019, agora custa menos de US$50.

O impacto do projeto se estende além da redução de custos brutos. Ao fornecer uma base de código mínima e legível com uma interface de "um único seletor", Karpathy criou tanto uma ferramenta de pesquisa quanto um recurso educacional.

Principais Conclusões

• Redução de custo de 100x: De US$43.000 para US$48 para capacidade GPT-2
• Aceleração de 100x: De 168 horas para 1,65 horas
• Um único seletor de configuração: --depth controla tudo
• Pipeline completo: Da tokenização à UI web
• Impulsionado pela comunidade: Ranking público com melhorias contínuas

Próximos Passos

Pronto para treinar seu próprio modelo? Comece com o repositório nanochat e o script runs/speedrun.sh.

Para desenvolvedores de API que constroem aplicações baseadas em IA, entender os detalhes internos do treinamento de LLMs nunca foi tão acessível. A barreira de entrada caiu de "startup financiada por capital de risco" para "projeto de fim de semana".