Criando um GPT com 200 linhas em Python

Por que estudar um GPT em Python puro

O que me chamou atenção imediatamente foi a afirmação central de Karpathy: "Everything else is just efficiency". Em outras palavras, tudo o mais é apenas eficiência.

Ou seja, toda a engenharia que envolve modelos como o GPT-4 ou o ChatGPT não altera a estrutura algorítmica fundamental. Ela apenas executa essa estrutura em escala.

Compreender o microgpt é, portanto, compreender os LLMs em sua forma mais pura. Além disso, um GPT em Python sem bibliotecas obriga você a ver cada conta acontecendo, sem nenhuma caixa preta no caminho.

O código-fonte desse GPT em Python está disponível no Gist oficial do microgpt e no Google Colab. Recomendo abrir o arquivo em uma aba ao lado enquanto lê este artigo.

Se você ainda não conhece a ideia geral desses modelos, leia antes o artigo sobre como funciona uma LLM.

O dataset do GPT em Python

O combustível de qualquer modelo de linguagem é um fluxo de dados textuais. Em aplicações de produção, esse fluxo corresponde a bilhões de páginas da internet.

No microgpt, por outro lado, Karpathy utiliza um conjunto de 32.000 nomes próprios, um por linha:

emma
olivia
ava
isabella
...

Cada nome funciona como um documento independente. Assim, o objetivo do modelo é aprender os padrões estatísticos presentes nesses documentos.

Ao final do treinamento, o GPT em Python gera novos nomes que compartilham essas regularidades. Na prática, são nomes que soam plausíveis, mas que não existem no dataset original.

Essa simplificação é pedagogicamente brilhante. Ela elimina o pré-processamento de dados massivos, mas preserva a lógica fundamental: o GPT em Python aprende a completar sequências com base em probabilidades.

O tokenizador

Redes neurais operam sobre números, não sobre caracteres ou palavras. Por isso, precisamos de um mecanismo de conversão entre texto e identificadores inteiros, o que chamamos de tokenizador.

No microgpt, o tokenizador é intencionalmente simples: cada caractere único no dataset recebe um identificador inteiro sequencial. Como o conjunto de nomes tem 26 letras minúsculas, o vocabulário final tem 27 tokens.

Ou seja, são os 26 caracteres mais um token especial chamado BOS, sigla de Beginning of Sequence. Esse token serve como delimitador de documento.

Durante o treinamento, o código envolve cada nome com esse token nos dois lados: [BOS, e, m, m, a, BOS]. Dessa forma, o modelo aprende que BOS sinaliza o início e o fim de um nome.

É o mesmo mecanismo pelo qual modelos de produção distinguem o início e o fim de uma conversa.

Tokenizadores industriais, como o tiktoken utilizado pelo GPT-4, trabalham com vocabulários de cerca de 100.000 tokens. Além disso, eles usam algoritmos de compressão como o BPE (Byte Pair Encoding), que representa palavras comuns como tokens únicos e palavras raras como composição de subtokens.

Mesmo assim, a diferença é de eficiência, não de princípio. Um GPT em Python com tokens de caractere aprende exatamente o mesmo tipo de tarefa que um modelo com BPE.

O autograd do GPT em Python

Esta é, sem dúvida, a seção mais matematicamente densa do projeto, e também a mais elegante. Afinal, para treinar uma rede neural, precisamos de gradientes.

Para cada parâmetro, precisamos saber se aumentar aquele número faz a perda subir ou descer, e em que magnitude. É exatamente essa pergunta que o autograd do GPT em Python responde.

class Value:
    __slots__ = ('data', 'grad', '_children', '_local_grads')

    def __init__(self, data, children=(), local_grads=()):
        self.data = data
        self.grad = 0
        self._children = children
        self._local_grads = local_grads

∂L/∂c += (∂v/∂c) · (∂L/∂v)

Os parâmetros do modelo

Os parâmetros são o conhecimento do modelo. Em outras palavras, são uma coleção de números de ponto flutuante que começam aleatórios e passam por otimização a cada iteração do treinamento.

O microgpt usa a seguinte configuração:

• n_embd = 16: dimensão dos embeddings.
• n_head = 4: número de cabeças de atenção.
• n_layer = 1: número de camadas.
• block_size = 16: comprimento máximo de sequência.

Além disso, o código organiza os parâmetros em matrizes nomeadas:

• wte: tabela de embeddings de tokens (vocab_size × n_embd).
• wpe: tabela de embeddings de posição (block_size × n_embd).
• attn_wq, attn_wk, attn_wv, attn_wo: matrizes de projeção de atenção.
• mlp_fc1, mlp_fc2: camadas da rede feed-forward.
• lm_head: projeção final para o vocabulário.

Com essa configuração, o modelo totaliza 4.192 parâmetros. Para comparação, o menor GPT-2 tinha 117 milhões de parâmetros, e modelos modernos chegam a centenas de bilhões.

Mesmo assim, cada número do GPT em Python segue o mesmo caminho de um parâmetro em um modelo gigante.

A arquitetura do GPT em Python

A função gpt(token_id, pos_id, keys, values) processa um único token por vez. Ela recebe o identificador do token atual, sua posição na sequência e o KV Cache acumulado dos tokens anteriores.

Como resultado, a função retorna logits, ou seja, pontuações brutas sobre qual token deve vir a seguir. A arquitetura segue o GPT-2, mas com simplificações: RMSNorm no lugar de LayerNorm, ReLU no lugar de GeLU e nenhum bias nas camadas.

Como treinar um GPT em Python

Na prática, o treinamento do GPT em Python repete um mesmo ciclo por num_steps = 1000 iterações. Cada iteração segue estes passos:

1. Seleção e tokenização: o código escolhe um documento e o envolve com BOS nos dois lados.
2. Forward pass: os tokens passam pelo modelo um a um, construindo o grafo computacional até a perda.
3. Cálculo da perda: a perda em cada posição é a entropia cruzada, ou seja, o logaritmo negativo da probabilidade do token correto.
4. Backward pass: loss.backward() propaga gradientes por todo o grafo.
5. Atualização com Adam: o otimizador Adam atualiza os parâmetros.

A fórmula da perda é loss = -log(p(target)). Uma perda igual a 0 significa previsão perfeita, enquanto um modelo surpreso com o token correto produz uma perda alta.

A inferência no GPT em Python

Após o treinamento, os parâmetros ficam fixos e usamos o modelo para gerar novos nomes. O processo começa sempre com o token BOS e segue em loop.

Em cada volta, o GPT em Python gera logits, que o softmax converte em probabilidades. Em seguida, o código sorteia um token de acordo com essa distribuição.

O parâmetro temperature controla a aleatoriedade, porque o código divide os logits pela temperatura antes do softmax:

• Temperatura baixa (ex.: 0,5): aguça a distribuição e deixa o modelo mais conservador.
• Temperatura próxima de 0: vira decodificação gulosa, que sempre escolhe o token mais provável.
• Temperatura alta: achata a distribuição e gera saídas mais diversas e menos coerentes.

O processo termina quando o modelo gera outro BOS, indicando fim do documento, ou quando atinge o comprimento máximo de sequência. Entre os exemplos gerados estão nomes como "karia", "kamon" e "vialan", que parecem reais, mas não existem no dataset.

Do GPT em Python à produção

O microgpt implementa a essência algorítmica completa de um LLM. Portanto, o que separa este script de 200 linhas de um sistema como o ChatGPT não é a estrutura, e sim a escala e a engenharia de eficiência.

Karpathy sistematiza essa diferença de forma clara:

Modelos de produção também incorporam variações arquitetônicas. Entre elas estão o RoPE (Rotary Position Embeddings) no lugar de embeddings posicionais aprendidos e o GQA (Grouped Query Attention) para reduzir o tamanho do KV Cache.

Além disso, eles usam ativações lineares com gate e camadas MoE (Mixture of Experts). Mesmo assim, a estrutura de atenção e MLP intercalados em um fluxo residual continua a mesma do GPT em Python.

Se quiser aprofundar a parte arquitetural com uma visão mais conceitual, leia também o artigo O que é um GPT e como sua arquitetura funciona. Os dois textos se complementam bem.

Conclusão

O microgpt é um projeto raro, porque une rigor técnico e clareza pedagógica. Além disso, ele fica em uma escala que qualquer desenvolvedor com noções de Python e cálculo consegue acompanhar.

Ao estudá-lo, compreendi de forma visceral que os LLMs são otimizadores de distribuições de probabilidade sobre sequências de tokens. Toda a engenharia monumental dos sistemas de produção existe para executar esse princípio em escala industrial.

Encorajo fortemente qualquer desenvolvedor que trabalhe com .NET, Python ou qualquer outra linguagem a percorrer o código desse GPT em Python. Então, abra o Gist, rode no Colab, mude n_embd ou n_layer e observe o efeito na perda.

É uma das experiências mais esclarecedoras sobre o funcionamento interno dos modelos de linguagem.

FAQ

O que é o microgpt?

É um GPT em Python puro, publicado por Andrej Karpathy em fevereiro de 2026, com cerca de 200 linhas e sem dependências. Ele implementa dataset, tokenizador, autograd, Transformer, treino e inferência.

Preciso de GPU para rodar o microgpt?

Não, porque o código roda em CPU com Python puro. Segundo Karpathy, o treino completo leva cerca de um minuto em um notebook.

Quantos parâmetros o microgpt tem?

O modelo tem 4.192 parâmetros, com uma camada, quatro cabeças de atenção e embeddings de dimensão 16.

Qual a diferença entre o microgpt e o ChatGPT?

O algoritmo é o mesmo, mas o ChatGPT usa trilhões de tokens, bilhões de parâmetros, GPUs e etapas de pós-treinamento como SFT e RLHF.

O microgpt usa PyTorch?

Não, já que ele implementa o próprio autograd na classe Value. O PyTorch faz a mesma coisa, mas com tensores e aceleração por GPU.

O modelo entende o que está fazendo?

Mecanicamente, não há mágica: o modelo é uma função matemática que mapeia tokens para uma distribuição de probabilidade sobre o próximo token. Se isso constitui compreensão é uma questão filosófica, mas o mecanismo inteiro cabe nas 200 linhas do script.

Por que o modelo alucina?

Ele amostra tokens de uma distribuição de probabilidade e não possui conceito de verdade. O nome "karia" gerado pelo microgpt e uma afirmação falsa do ChatGPT são o mesmo fenômeno: uma continuação plausível que não corresponde à realidade.

Por que o microgpt é tão lento?

Ele processa um escalar por vez em Python puro, enquanto uma GPU processa milhões de escalares em paralelo. Ou seja, a lentidão é o preço da clareza, e não um defeito do algoritmo.