Como funciona o GPT: do Transformer ao código
Como um modelo GPT gera texto, um token de cada vez, explicado sem matemática pesada.
O GPT é uma máquina de prever a próxima palavra. Ele lê um texto, calcula qual pedaço (token) tem mais chance de vir em seguida, adiciona esse pedaço e repete, uma palavra por vez, até a resposta ficar pronta.
Neste post eu explico como isso funciona por dentro de um jeito simples e, depois, mostro em código: um exemplo de atenção sem treino, um mini GPT de 27 mil parâmetros treinado do zero em PyTorch e o mesmo modelo completando frases.
Pense num autocompletar de celular turbinado: a diferença é que, em vez de olhar só a última palavra, ele presta atenção em todo o contexto ao mesmo tempo.
As 5 etapas do Transformer
Todo GPT passa o texto pelas mesmas cinco etapas, de cima para baixo, a cada palavra que gera.
- Tokenização: o texto é quebrado em pedaços. “o gato subiu no” vira [“o”, “gato”, “subiu”, “no”], e cada pedaço vira um número: [0, 1, 2, 3].
- Embeddings: cada token vira uma lista de números que guarda seu “significado”. Palavras parecidas ficam com números parecidos. Soma-se também a posição, para o modelo saber a ordem.
- Atenção (self-attention): o coração do modelo. Cada token olha para os anteriores e decide quais importam mais. Em “o pescador sentou no banco do rio”, “banco” presta atenção em “pescador” e entende que não é um banco financeiro.
- Camadas empilhadas: atenção + uma pequena rede neural se repetem dezenas de vezes. As primeiras camadas captam gramática; as últimas, ideias mais abstratas como tom e intenção.
- Previsão: no fim, o modelo dá uma probabilidade para cada token possível (“telhado” 70%, “sofá” 20%…), escolhe um, adiciona ao texto e volta para a etapa 1.
O aprendizado vem do treino: o modelo leu bilhões de textos tentando adivinhar a palavra seguinte e, a cada erro, ajustou um pouquinho seus bilhões de parâmetros. Depois, um ajuste com feedback humano transforma o “completador de texto” num assistente que conversa.
Atenção na prática: um Transformer sem treino
Antes de treinar, vale ver as cinco etapas em poucas linhas de numpy. Os pesos são aleatórios, então a previsão não faz sentido, mas o fluxo é o mesmo de um GPT de verdade.
import numpy as np # biblioteca de cálculo com vetores e matrizes
np.random.seed(42) # fixa a aleatoriedade para o resultado ser sempre o mesmo
# 1) TOKENIZAÇÃO: cada palavra vira um número
vocab = ["o", "gato", "subiu", "no", "telhado", "dormiu"] # todas as palavras que o modelo conhece
texto = ["o", "gato", "subiu", "no"] # frase de entrada, já quebrada em tokens
ids = [vocab.index(p) for p in texto] # troca cada palavra pela sua posição no vocabulário: [0, 1, 2, 3]
# 2) EMBEDDINGS: cada número vira um vetor (significado + posição)
d = 8 # tamanho do vetor que representa cada palavra
emb_token = np.random.randn(len(vocab), d) # um vetor de "significado" para cada palavra do vocabulário
emb_posicao = np.random.randn(10, d) # um vetor para cada posição na frase (até 10 palavras)
x = emb_token[ids] + emb_posicao[:len(ids)] # vetor final de cada token = significado + posição
# 3) ATENÇÃO: cada token decide em quais tokens anteriores prestar atenção
Wq, Wk, Wv = (np.random.randn(d, d) for _ in range(3)) # três matrizes de pesos (no treino elas seriam aprendidas)
Q, K, V = x @ Wq, x @ Wk, x @ Wv # Q = o que o token procura, K = o que ele oferece, V = a informação dele
notas = Q @ K.T / np.sqrt(d) # nota de quanto cada token combina com cada outro token
notas += np.triu(np.ones_like(notas), 1) * -1e9 # máscara: esconde as palavras futuras (GPT só olha o passado)
def softmax(z): # função que transforma notas em probabilidades
e = np.exp(z - z.max(axis=-1, keepdims=True)) # exponencial das notas (subtrair o máximo evita números gigantes)
return e / e.sum(axis=-1, keepdims=True) # divide pelo total para as probabilidades somarem 100%
pesos = softmax(notas) # notas viram porcentagens de atenção
print("Atenção de 'no' sobre", texto, "->", pesos[-1].round(2)) # mostra em quem o último token prestou atenção
x = x + pesos @ V # cada token recebe a informação dos tokens em que prestou atenção
# 4) REDE NEURAL da camada: processa o que a atenção juntou
W1, W2 = np.random.randn(d, 16), np.random.randn(16, d) # pesos da pequena rede neural
x = x + np.maximum(0, x @ W1) @ W2 # expande para 16, zera os negativos (ReLU) e volta ao tamanho d
# 5) PREVISÃO: qual palavra vem depois de "no"?
probs = softmax(x[-1] @ emb_token.T) # compara o último token com cada palavra do vocabulário e vira probabilidade
print("Próxima palavra:", vocab[int(np.argmax(probs))]) # escolhe a palavra com maior probabilidade
Rodando com a frase “o gato subiu no”, o último token concentrou 99% da atenção em “o” e o modelo previu “subiu”: errado, como esperado, porque ninguém ensinou nada a ele. É o treino que conserta isso.
Treinando um mini GPT (treinar.py)
Agora um modelo que aprende de verdade: 2 camadas, 4 cabeças de atenção e 27.678 parâmetros, treinado em 12 frases curtas. O ciclo é sempre o mesmo: mostrar um trecho, pedir a próxima palavra, medir o erro e ajustar os pesos.
import torch # biblioteca de deep learning (PyTorch)
import torch.nn as nn # blocos prontos de redes neurais (camadas, embeddings, atenção)
import torch.nn.functional as F # funções auxiliares, como o cálculo do erro
torch.manual_seed(42) # fixa a aleatoriedade para o treino dar sempre o mesmo resultado
# 1) DADOS: o "livro" que o modelo vai ler para aprender
FRASES = [ # lista com as frases de treino
"o gato subiu no telhado .", # frase 1
"o gato dormiu no sofá .", # frase 2
"o cachorro correu no quintal .", # frase 3
"o cachorro dormiu na varanda .", # frase 4
"a menina leu um livro .", # frase 5
"a menina comeu uma maçã .", # frase 6
"o menino jogou bola no quintal .", # frase 7
"o menino comeu um pão .", # frase 8
"o gato comeu o peixe .", # frase 9
"a menina subiu na árvore .", # frase 10
"o cachorro latiu para o gato .", # frase 11
"o gato fugiu para o telhado .", # frase 12
] # fim da lista de frases
palavras = " ".join(FRASES).split() # junta todas as frases e quebra em palavras (tokens)
vocab = sorted(set(palavras)) # lista de palavras únicas, em ordem alfabética
stoi = {p: i for i, p in enumerate(vocab)} # dicionário palavra -> número
dados = torch.tensor([stoi[p] for p in palavras]) # o texto inteiro convertido em números
# 2) CONFIGURAÇÃO (um GPT de verdade usa números MUITO maiores)
CONTEXTO = 8 # quantas palavras o modelo enxerga de uma vez
D = 32 # tamanho do vetor de cada palavra (embedding)
CABECAS = 4 # quantas cabeças de atenção trabalham em paralelo
CAMADAS = 2 # quantos blocos Transformer ficam empilhados
# 3) O MODELO
class Bloco(nn.Module): # um bloco Transformer: atenção + rede neural
def __init__(self): # monta as peças do bloco
super().__init__() # inicializa a classe base do PyTorch
self.ln1 = nn.LayerNorm(D) # normaliza os números antes da atenção (estabiliza o treino)
self.atencao = nn.MultiheadAttention(D, CABECAS, batch_first=True) # camada de atenção com várias cabeças
self.ln2 = nn.LayerNorm(D) # normaliza os números antes da rede neural
self.rede = nn.Sequential(nn.Linear(D, 4 * D), nn.GELU(), nn.Linear(4 * D, D)) # rede neural: expande, ativa e volta ao tamanho D
def forward(self, x): # o que acontece quando os dados passam pelo bloco
T = x.size(1) # quantidade de palavras na sequência
mascara = torch.triu(torch.ones(T, T, dtype=torch.bool), diagonal=1) # máscara que esconde as palavras futuras
h = self.ln1(x) # normaliza a entrada
a, _ = self.atencao(h, h, h, attn_mask=mascara) # cada palavra presta atenção nas anteriores
x = x + a # soma o resultado da atenção à entrada (conexão residual)
x = x + self.rede(self.ln2(x)) # passa pela rede neural e soma de novo (conexão residual)
return x # devolve os vetores atualizados
class MiniGPT(nn.Module): # o modelo completo
def __init__(self, tamanho_vocab): # monta o modelo para um vocabulário de certo tamanho
super().__init__() # inicializa a classe base do PyTorch
self.emb_token = nn.Embedding(tamanho_vocab, D) # tabela de vetores de significado, um por palavra
self.emb_pos = nn.Embedding(CONTEXTO, D) # tabela de vetores de posição, um por posição
self.blocos = nn.Sequential(*[Bloco() for _ in range(CAMADAS)]) # empilha os blocos Transformer
self.ln = nn.LayerNorm(D) # normalização final
self.saida = nn.Linear(D, tamanho_vocab) # transforma cada vetor numa nota para cada palavra do vocabulário
def forward(self, ids): # o que acontece quando uma sequência de números entra no modelo
pos = torch.arange(ids.size(1)) # posições 0, 1, 2... de cada palavra
x = self.emb_token(ids) + self.emb_pos(pos) # vetor de cada palavra = significado + posição
return self.saida(self.ln(self.blocos(x))) # passa pelos blocos e devolve as notas da próxima palavra
# 4) TREINO
def pegar_lote(tamanho=32): # sorteia trechos do texto para treinar
inicio = torch.randint(0, len(dados) - CONTEXTO - 1, (tamanho,)) # sorteia onde cada trecho começa
x = torch.stack([dados[i:i + CONTEXTO] for i in inicio]) # entrada: trechos de 8 palavras
y = torch.stack([dados[i + 1:i + CONTEXTO + 1] for i in inicio]) # resposta certa: o mesmo trecho, uma palavra à frente
return x, y # devolve entrada e resposta
if __name__ == "__main__": # só treina quando este arquivo é executado diretamente
modelo = MiniGPT(len(vocab)) # cria o modelo com pesos aleatórios
otimizador = torch.optim.AdamW(modelo.parameters(), lr=3e-3) # algoritmo que ajusta os pesos
for passo in range(1501): # repete o ciclo de treino 1501 vezes
x, y = pegar_lote() # pega um lote de trechos e respostas
logits = modelo(x) # o modelo dá as notas para a próxima palavra
erro = F.cross_entropy(logits.view(-1, len(vocab)), y.view(-1)) # mede o quanto ele errou
otimizador.zero_grad() # limpa os cálculos do passo anterior
erro.backward() # calcula quanto cada peso contribuiu para o erro
otimizador.step() # ajusta os pesos um pouquinho para errar menos
if passo % 300 == 0: # a cada 300 passos...
print(f"passo {passo:4d} | erro {erro.item():.3f}") # ...mostra o erro atual
torch.save({"pesos": modelo.state_dict(), "vocab": vocab}, "modelo.pt") # salva pesos e vocabulário no arquivo
print("Modelo salvo em modelo.pt") # avisa que terminou
O erro despenca nos primeiros 300 passos, de chute puro para quase acerto:
passo 0 | erro 3.760 ← chutando
passo 300 | erro 0.179 ← já aprendeu
passo 600 | erro 0.147
passo 900 | erro 0.154
passo 1200 | erro 0.205
passo 1500 | erro 0.142
Modelo salvo em modelo.pt
Usando o modelo treinado (usar.py)
Com o modelo.pt salvo, gerar texto é um laço simples: prever a próxima palavra, sortear conforme a probabilidade, adicionar à frase e repetir até o ponto final.
import torch # biblioteca de deep learning (PyTorch)
import torch.nn.functional as F # funções auxiliares, como o softmax
from treinar import MiniGPT, CONTEXTO # reaproveita a definição do modelo do arquivo de treino
torch.manual_seed(0) # fixa o sorteio para as frases saírem sempre iguais
salvo = torch.load("modelo.pt") # abre o arquivo gerado pelo treino
vocab = salvo["vocab"] # recupera a lista de palavras
stoi = {p: i for i, p in enumerate(vocab)} # dicionário palavra -> número
modelo = MiniGPT(len(vocab)) # cria um modelo vazio do mesmo tamanho
modelo.load_state_dict(salvo["pesos"]) # coloca nele os pesos aprendidos
modelo.eval() # coloca o modelo em modo de uso (não treina mais)
@torch.no_grad() # desliga o cálculo de gradientes, que só serve no treino
def completar(inicio, max_palavras=6, temperatura=0.8): # completa uma frase palavra por palavra
ids = [stoi[p] for p in inicio.split()] # converte o começo da frase em números
for _ in range(max_palavras): # gera no máximo 6 palavras novas
x = torch.tensor([ids[-CONTEXTO:]]) # pega só as últimas palavras que cabem no contexto
logits = modelo(x)[0, -1] / temperatura # notas da próxima palavra (temperatura controla a ousadia)
probs = F.softmax(logits, dim=-1) # transforma as notas em probabilidades
prox = torch.multinomial(probs, 1).item() # sorteia uma palavra conforme a probabilidade
ids.append(prox) # adiciona a palavra sorteada à frase
if vocab[prox] == ".": # se a palavra for o ponto final...
break # ...para de gerar
return " ".join(vocab[i] for i in ids) # converte os números de volta em texto
@torch.no_grad() # desliga o cálculo de gradientes, que só serve no treino
def top_previsoes(inicio, n=3): # mostra as n palavras mais prováveis depois de um começo de frase
x = torch.tensor([[stoi[p] for p in inicio.split()]]) # converte o começo da frase em números
probs = F.softmax(modelo(x)[0, -1], dim=-1) # probabilidades da próxima palavra
top = torch.topk(probs, n) # pega as n maiores probabilidades
return ", ".join(f"{vocab[i]} {p:.0%}" for p, i in zip(top.values, top.indices)) # monta o texto "palavra %"
for frase in ["o gato subiu no", "a menina comeu", "o cachorro"]: # começos de frase para analisar
print(f"'{frase}' -> {top_previsoes(frase)}") # mostra as palavras mais prováveis
for frase in ["o gato", "a menina", "o cachorro", "o menino"]: # começos de frase para testar
print(completar(frase)) # mostra a frase completada pelo modelo
O resultado, agora com um modelo treinado:
| Início | Previsão da próxima palavra |
|---|---|
| o gato subiu no | telhado 100% |
| a menina comeu | uma 100% |
| o cachorro | correu 45%, dormiu 32%, latiu 22% |
o gato comeu o peixe .
a menina leu um livro .
o cachorro correu no quintal .
o menino jogou bola no quintal .
Em “o cachorro” o modelo divide a chance entre três verbos porque viu os três no texto. É esse sorteio entre palavras prováveis que faz o GPT responder diferente a cada vez; a temperatura controla o quanto ele arrisca.
O fluxo do código
O treino gira no laço da esquerda até o erro cair e grava os pesos em modelo.pt; o uso carrega esse arquivo e gira no laço da direita, uma palavra por volta. A caixa destacada é o mesmo MiniGPT nos dois lados: no treino ele aprende, no uso ele prevê.
Do mini GPT ao GPT de verdade
A receita é a mesma; o que muda é a escala. O mini GPT só sabe o que leu: 30 palavras, e praticamente decorou as frases. Um GPT real usa vetores com milhares de números, dezenas de camadas, muitas cabeças de atenção, trilhões de palavras de treino e bilhões de parâmetros. É essa escala que faz o modelo generalizar em vez de decorar.
| Mini GPT deste post | GPT de verdade | |
|---|---|---|
| Texto de treino | 75 palavras | trilhões de tokens |
| Vocabulário | 30 palavras | dezenas de milhares de tokens |
| Camadas | 2 | dezenas |
| Parâmetros | 27.678 | bilhões |
| Treino | segundos num notebook | semanas em milhares de GPUs |
Como rodar
pip install torch numpy # instala as bibliotecas
python mini_gpt.py # atenção sem treino (numpy)
python treinar.py # treina e salva modelo.pt
python usar.py # carrega o modelo e completa frases
Para experimentar: troque as FRASES por frases suas, aumente CAMADAS e D, ou mude a temperatura no usar.py e veja as frases ficarem mais criativas ou mais previsíveis.