Laboratório GPT-2 · RoBERTa
00

Mapa do curso
e do laboratório

O que você vai aprender, em que ordem, por quê nessa ordem — e onde cada peça mora na sua máquina.

Apostila 00 · abertura 17 apostilas e uma página de glossário · 11 laboratórios

1 Por que este curso existe

Este curso desmonta o GPT-2 e o RoBERTa — os sete modelos que a organização openai-community publicou no Hugging Face. Eles não são uma lista aleatória: são um corte histórico. Entre 2018 e 2019, a área inteira de processamento de linguagem se dividiu em dois galhos, e esses sete arquivos são exatamente o registro desse momento.

De um lado, o galho decoder: GPT-1 → GPT-2 small → medium → large → XL. É a linhagem que gera texto, uma palavra de cada vez, olhando só para trás. Ela levaria ao GPT-3, ao ChatGPT e a tudo que veio depois.

Do outro lado, o galho encoder: BERT → RoBERTa. É a linhagem que compreende texto, olhando o enunciado inteiro de uma vez, para frente e para trás. Ela continua muito usada em classificação, busca e extração de informação.

E há uma ponte deliciosa entre os dois galhos: os dois modelos roberta-*-openai-detector. Eles são RoBERTas treinados especificamente para detectar texto escrito pelo GPT-2. A própria OpenAI construiu o caçador junto com a caça. Estudar os dois lado a lado não é só conveniente — é a melhor aula possível sobre a diferença entre gerar e compreender.

A ideia que amarra tudo

GPT e RoBERTa usam o mesmo tijolo: o bloco Transformer com atenção. A diferença entre eles cabe em uma linha de código — uma máscara triangular. Tudo o mais (o objetivo de treino, o tokenizador, o formato da saída, os usos práticos) é consequência dessa única escolha. Quando você entender essa frase de verdade, o curso terá cumprido seu papel.

2 Os sete modelos, em números

Todos foram baixados para models\hf. Os tamanhos são dos pesos em fp32 (32 bits por parâmetro), como a OpenAI publicou.
ModeloParâmetrosCamadasdmodelCabeçasContextoFamília
openai-gpt (GPT-1)117 M1276812512decoder
gpt2124 M12768121024decoder
gpt2-medium355 M241024161024decoder
gpt2-large774 M361280201024decoder
gpt2-xl1 558 M481600251024decoder
roberta-base-openai-detector125 M1276812512encoder
roberta-large-openai-detector355 M24102416512encoder

Repare em duas coisas que já contam uma história:

3 A trilha, capítulo por capítulo

A ordem importa. Cada apostila usa o vocabulário construído na anterior. Não pule — especialmente da 01 à 05, que são a fundação. Palavras como token, camada e modelo têm aqui o sentido de aprendizado de máquina, que nem sempre é o mesmo do resto da TI; a página de glossário, que vem logo depois deste mapa, mostra os dois lados.

Antes da Parte I — Página de consulta

NºTítuloA pergunta que responde
—Glossário do cursoO que token, camada, modelo e máscara querem dizer aqui — e o que as mesmas palavras querem dizer no resto da TI. Leia logo depois deste mapa e volte a ele quando precisar.

Parte I — A fundação (como um Transformer funciona)

NºTítuloA pergunta que responde
01Tokenização e BPEComo texto vira número? Por que GPT-2 quebra "Rafhael" em pedaços?
02EmbeddingsComo um número vira significado? O que é wte e wpe?
03Atenção (self-attention)Como uma palavra "olha" para as outras? De onde vem Q, K e V?
04Multi-head e máscara causalPor que várias cabeças? Como se impede o modelo de ver o futuro?
05O bloco Transformer completoLayerNorm, GELU, conexão residual — para que serve cada peça?

Parte II — A família GPT (gerar)

NºTítuloA pergunta que responde
06Arquitetura GPT-2 de ponta a pontaComo as peças se montam? O que muda de small para XL?
07Decodificação e amostragemO que fazem temperature, top-k e top-p? Por que greedy repete?
08Pré-treino, loss e perplexidadeO que exatamente o modelo aprendeu? Como se mede isso?
09GPT-1 → GPT-2: o que mudouPor que mover o LayerNorm? Por que trocar o tokenizador?

Parte III — A família BERT (compreender)

NºTítuloA pergunta que responde
10RoBERTa: BERT feito direitoO que é MLM? Por que remover o NSP melhorou tudo?
11Encoder vs decoder — o confrontoA máscara triangular e todas as suas consequências.
12O detector de GPT-2Como se fine-tuna um classificador? O <s> e a cabeça linear.

Parte IV — Colocar na sua máquina

NºTítuloA pergunta que responde
13O código original da OpenAIO GPT-2 inteiro cabe em 174 linhas. Lendo a fonte primária.
14Servindo modelos: API, TGI e TEIComo servir por HTTP? O que os servidores de produção fazem a mais?
15Guia do laboratórioCada script, cada comando, e todos os números medidos.

Parte V — Onde este caminho para

NºTítuloA pergunta que responde
16O teto deste caminhoAté onde vai o caminho que o GPT-2 abriu? O argumento de LeCun, lido de dentro do modelo.

4 Onde tudo mora na sua máquina

Onde baixar

Os scripts do laboratório, o servidor do curso, a lista de dependências e as instruções de instalação estão no repositório público do curso: github.com/Rafhael-Oliveira-IA/conceitos-gpt. Quem não usa git pode baixar tudo em um arquivo .zip. Os modelos não vão no repositório, porque somam 13,2 GB: o script tools/download_models.py baixa os sete direto do Hugging Face.

# a raiz do repositório, onde quer que você o clone
├── .venv\                  # Python 3.14 + torch 2.14 (CPU) + transformers 5
├── models\hf\              # os 7 modelos, 13,2 GB em safetensors
├── repos\
│   ├── gpt-2\              # código original da OpenAI, em TensorFlow (para LER)
│   ├── GPT-3-Encoder\      # tokenizador em JS + vocab.bpe + encoder.json
│   └── gpt-3\              # amostras do modelo de 175B e estatísticas
├── lab\                    # << os 11 experimentos para você rodar
├── server\app.py           # << API HTTP compativel com TGI e TEI, e a bancada
├── model\                  # o ELLM do experimento seguinte (Antevisão)
├── tools\                  # download, geração de PDF, verificação
├── src\conceitos_gpt-1-gpt-2\  # fonte HTML de cada apostila (eng\ = versão em inglês)
├── src\conceitos_antevisao\    # a teoria do ELLM, experimento Antevisão
├── pdfs\gpt-1-gpt-2\          # << as 17 apostilas e o glossário (eng\ em inglês)
└── out\                    # saídas dos experimentos
Uma decisão de ferramenta, e o porquê

Este laboratório roda em Python puro: transformers + PyTorch em CPU. Nada de Ollama, Docker ou WSL. Vale explicar a escolha, porque ela não é preguiça.

Ollama roda apenas modelos generativos. A família GPT rodaria nele; os dois RoBERTa não — eles são encoders com uma cabeça de classificação, e o llama.cpp, motor por baixo do Ollama, não implementa esse tipo de saída. Metade do curso ficaria de fora.

TGI e TEI (os servidores de produção do Hugging Face, hoje Apache 2.0) são distribuídos como imagens Docker Linux e dependem de kernels CUDA. O laboratório foi feito para uma máquina comum: Windows, sem GPU NVIDIA, sem Docker e sem WSL. E o que eles oferecem — continuous batching, paged attention — só compensa a partir de dezenas de requisições simultâneas. Para uma pessoa aprendendo, não fariam diferença.

Em vez disso, escrevemos um servidor com os mesmos endpoints deles (/generate, /embed, /predict) em ~200 linhas legíveis — apostila 14. Você aprende como um servidor de inferência funciona por dentro, em vez de apenas usá-lo. E o Python cru tem uma vantagem decisiva: dá para abrir o modelo e olhar — pesos, matrizes de atenção, logits, estados intermediários. É disso que o curso é feito.

5 O que existe além do que usamos

Você vai encontrar estas ferramentas por aí. Vale saber para que cada uma serve, mesmo sem usá-las aqui.

FerramentaPara quêServe encoder?Roda aqui?
transformers (o nosso)entender e experimentarsimsim
Ollama / llama.cpprodar LLM no desktop, rápido, quantizadonãosim, mas não serve RoBERTa
TGI / vLLMservir decoders em produção, GPUnãoprecisa Linux + NVIDIA
TEIservir embeddings e classificadoressimWindows não é suportado

Note a terceira coluna: só o transformers e o TEI atendem os dois galhos da árvore. É uma assimetria real do ecossistema — as ferramentas populares de "rodar IA local" foram feitas para modelos que geram, e ignoram os que compreendem.

6 Como estudar isto

Cada apostila da 01 em diante tem sempre a mesma estrutura, e ela foi desenhada para você ler com o computador aberto ao lado:

  1. Intuição — a ideia em português, sem símbolo nenhum.
  2. Analogia — uma imagem mental para segurar a ideia.
  3. Matemática — a fórmula, com cada símbolo explicado um por um. Nunca jogo uma equação sem dizer o que é cada letra.
  4. Código — a mesma coisa em Python, comentada linha a linha.
  5. No laboratório — o script exato para rodar e o que observar na saída.
  6. Exercício — uma coisa para você mudar e prever o resultado antes de rodar.
O conselho mais importante

Na etapa 6, preveja antes de rodar. Escreva num papel o que você acha que vai acontecer, depois execute. O aprendizado acontece na diferença entre o que você previu e o que apareceu na tela — não na leitura. Um modelo de linguagem, aliás, aprende exatamente assim: prevendo e se corrigindo pelo erro. Você vai ver isso na apostila 08.

Exercício 0 — calibre sua intuição

Antes de ler qualquer outra apostila, responda de cabeça, sem pesquisar. Guarde as respostas e confira ao terminar o curso:

  1. O GPT-2 XL tem 12× mais parâmetros que o GPT-2 small. Você acha que ele escreve 12× melhor? O que "melhor" significaria aqui?
  2. Se o GPT-2 gera texto olhando só para trás, como ele consegue manter coerência num parágrafo inteiro?
  3. O RoBERTa detector acerta quanto, na sua estimativa, ao julgar se um texto foi escrito por máquina? E hoje, em 2026, com textos de modelos modernos — você apostaria nele?

A pergunta 3 tem uma resposta desconfortável. Vamos chegar nela na apostila 12.


Próxima: a página de glossário, e depois a apostila 01 — Tokenização e BPE.
Comece a 01 mesmo que ache que já sabe: o BPE tem detalhes, como o espaço que vira parte do token, que mudam o comportamento do modelo.