Pular para o conteúdo
← Blog
IA

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.

Diego Heusser · · 4 min de leitura

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.

  1. 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].
  2. 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.
  3. 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.
  4. 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.
  5. 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 mesmo MiniGPT aprende no treino e prevê no usotreinar.pyusar.pyTexto e vocabuláriopalavras viram númerosPegar lotetrecho + próxima palavra certaPassar no MiniGPTembedding, atenção, saídaMedir o erroquanto errou a próxima palavraAjustar pesosbackward + stepCarregar modelo.ptrecria o MiniGPT treinadoFrase inicial“o gato” vira númerosPrever próxima palavraMiniGPT + softmaxSortear e adicionarconforme a probabilidadeFrase completao gato subiu no telhado .↻ volta ao lote, 1500 vezes↻ repete até o ponto finalmodelo.ptpesos + vocabulário
fluxo do código · treinar.py → modelo.pt → usar.py

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.