Laboratório GPT-2 · RoBERTa · Parte IV — Na sua máquina
15

Guia do
laboratório

Cada comando, cada script, cada arquivo. A apostila de referência para voltar depois — e o resumo de tudo que foi medido.

Apostila 15 de 15 Referência

1 Comece por aqui

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.

# abra o PowerShell na raiz do repositório e rode, em ordem:

.venv\Scripts\python.exe lab\01_tokenizer.py
.venv\Scripts\python.exe lab\02_embeddings.py
.venv\Scripts\python.exe lab\03_attention.py
.venv\Scripts\python.exe lab\04_multihead_mask.py
.venv\Scripts\python.exe lab\05_block.py
.venv\Scripts\python.exe lab\06_scale.py
.venv\Scripts\python.exe lab\07_decoding.py
.venv\Scripts\python.exe lab\08_perplexity.py
.venv\Scripts\python.exe lab\09_detector.py
.venv\Scripts\python.exe lab\10_original_code.py

# o lab 11 precisa do servidor. Em OUTRO terminal:
.venv\Scripts\python.exe server\app.py
# e então:
.venv\Scripts\python.exe lab\11_api.py

Os labs 06 e 08 carregam o gpt2-xl (6 GB de RAM, ~3 min). Se estiver com pressa ou memória curta, acrescente rapido:

.venv\Scripts\python.exe lab\06_scale.py rapido

2 Índice: apostila → laboratório

NºApostilaScriptO experimento principal
01Tokenização e BPE01_tokenizer.pyo custo do português; três tokenizadores incompatíveis
02Embeddings02_embeddings.pyvizinhos de " Brazil"; wpe aprendeu a ordem sozinho
03Atenção03_attention.pya saturação do softmax sem √dk
04Multi-head e máscara04_multihead_mask.pya prova de causalidade — diferença exatamente 0,00
05O bloco Transformer05_block.pyPre-LN vs Post-LN; o logit lens
06Arquitetura e escala06_scale.pya fórmula de parâmetros exata; in-context learning
07Decodificação07_decoding.pynúcleo top-p de 1 a 5 548 tokens; 80% de repetição no greedy
08Perplexidade08_perplexity.pyescala monotônica; ruído é mais fácil que texto embaralhado
09GPT-1 → GPT-206 e 08PPL 46 → 21,7 com o mesmo tamanho
10RoBERTa e MLM04, seção 3o encoder muda tudo quando você mexe no fim
11Encoder vs decoder04, seção 3a mesma prova, lida dos dois lados
12O detector09_detector.pyLLM moderno passa como humano com 99,9%
13Código original10_original_code.pyas 25 primeiras fusões do BPE; JS = Python
14Servindo modelos11_api.pyo ciclo gerar→detectar; a falha da busca semântica

3 Estrutura dos arquivos

GPT-2\
├── .venv\                      Python 3.14 + torch 2.14 (CPU) + transformers 5
├── models\hf\                  os 7 modelos, 13,2 GB em safetensors
├── repos\
│   ├── gpt-2\                  codigo original TensorFlow (para LER)
│   ├── GPT-3-Encoder\          tokenizador em JS + vocab.bpe + encoder.json
│   └── gpt-3\                  amostras do 175B e estatisticas do corpus
├── lab\
│   ├── common.py                modulo compartilhado — carrega e configura tudo
│   └── 01..11_*.py             os experimentos
├── server\app.py             API compativel com TGI e TEI
├── tools\
│   ├── style.css               tipografia das apostilas
│   ├── generate_pdfs.py           HTML -> PDF (Chrome headless + numeracao)
│   ├── download_models.py       download dos modelos
│   └── verify.py            teste de fumaca dos 7 modelos
├── src\conceitos_gpt-1-gpt-2\  fonte HTML das 16 apostilas (eng\ = inglês)
├── src\conceitos_antevisao\    a teoria do ELLM (experimento Antevisão)
├── pdfs\gpt-1-gpt-2\          << as apostilas prontas; pdfs\antevisao\ as do projeto
└── out\                        saidas dos experimentos

Comandos de manutenção

# conferir que os 7 modelos carregam
.venv\Scripts\python.exe tools\verify.py

# regerar todos os PDFs depois de editar um HTML
.venv\Scripts\python.exe tools\generate_pdfs.py

# regerar só um
.venv\Scripts\python.exe tools\generate_pdfs.py 07

4 Os apelidos dos modelos

Todos os scripts usam apelidos curtos, definidos em lab/common.py:

ApelidoRepositório Hugging FaceRAM
gpt1openai-community/openai-gpt0,4 GB
gpt2openai-community/gpt20,5 GB
gpt2-mediumopenai-community/gpt2-medium1,3 GB
gpt2-largeopenai-community/gpt2-large2,9 GB
gpt2-xlopenai-community/gpt2-xl5,8 GB
det-baseopenai-community/roberta-base-openai-detector0,5 GB
det-largeopenai-community/roberta-large-openai-detector1,4 GB
# para escrever seus proprios experimentos
import common
tok, mod      = common.carregar_gerador("gpt2-medium")
tok, mod, rot = comum.carregar_detector("det-base")
tok, mod      = comum.carregar_base("gpt2", atencoes=True)

O common.py aponta o cache para models\hf, liga o modo offline (nada vai à rede), força UTF-8 no console do Windows, desliga gradientes e corrige os rótulos ausentes do det-large.

5 Tudo o que foi medido nesta máquina

Os números que aparecem nas apostilas. Todos reproduzíveis com os scripts.
MediçãoResultadoLab
Custo do português vs inglês (tokens/palavra)1,86 vs 1,14 — 1,63×01
Vizinhos de " Brazil" no wteArgentina, Portugal, Chile, Bolívia02
Entropia do softmax sem √dk, d=10240,022 (saturado) vs 1,1703
Causalidade: efeito do futuro no passado0,00e+00 no GPT-2; ~3e−01 no RoBERTa04
Gradiente na 1ª de 40 camadasPre-LN 1,5 milhão de vezes maior05
Ganho do cache KV42,2 vs 25,0 tokens/s04
Fórmula de contagem de parâmetroserro 0,0% nos 5 modelos06
In-context learning: P(" Paris") no gpt20,032 → 0,385 com 3 exemplos06
Núcleo top-p (p=0,9), mesmo parâmetrode 1 a 5 548 tokens07
Repetição de 4-gramas, greedy80% (0% nas demais estratégias)07
Perplexidade GPT-1 → GPT-2 XL46,07 → 21,70 → 16,04 → 14,30 → 12,9308
PPL: ruído vs texto embaralhado469 vs 3 874 (ruído é mais fácil)08
Detector contra GPT-2P(humano) = 0,0002 — funciona09
Detector contra LLM de 2026P(humano) = 0,9993 — falha total09
Detector em texto humano formalregulamento: 0,034 — falso positivo09
Tokenizador JS da OpenAI vs PythonIDs idênticos10
Busca semântica com o detectorsimilaridades todas em +0,99 — inútil11

6 Problemas comuns

SintomaCausa e solução
UnicodeEncodeError com \u0120console em cp1252. Rode sempre pelos scripts do lab\ — o common.py já força UTF-8. Se escrever o seu, importe comum na primeira linha.
Memória estourando no lab 06use o modo rapido, que pula o XL.
ConnectionRefused no lab 11o servidor não está de pé. Abra outro terminal e rode server\app.py.
Aviso "pooler.dense.weight UNEXPECTED"inofensivo. É resíduo do pré-treino do RoBERTa; a cabeça de classificação lê o <s> direto (apostila 12).
Aviso "attn.bias UNEXPECTED" no GPT-1inofensivo. É a máscara causal, que o transformers recria em vez de carregar dos pesos.
Modelo tentando baixar algoo common.py liga HF_HUB_OFFLINE=1. Se algo tenta ir à rede, é um modelo fora do catálogo.

7 Para onde ir depois

Você terminou. Quatro caminhos naturais, em ordem de esforço:

  1. Fine-tune o seu próprio classificador. Você viu que 99,5% do detector é RoBERTa reaproveitado. Pegue um roberta-base puro, um conjunto de dados rotulados seu, e repita o processo da apostila 12. É a habilidade prática mais rentável deste curso.
  2. Implemente o GPT-2 do zero em PyTorch e carregue os pesos oficiais nele. Se a saída bater com a do transformers, você entendeu de verdade. O nanoGPT, de Andrej Karpathy, é uma boa referência para esse passo — e agora você consegue lê-lo inteiro.
  3. Compare com um modelo moderno. Você já tem o qwen3:4b e o qwen3:8b instalados. Rode os mesmos testes de perplexidade e decodificação neles e veja o que sete anos mudaram — e o que não mudou (a arquitetura ainda é a mesma).
  4. Monte um RAG de verdade. O lab 11 mostrou por que o detector não serve para embeddings. Baixe um modelo treinado para isso (BAAI/bge-small-en, intfloat/e5-small) e refaça a seção 4 — dessa vez funcionando.
O que ficou, se tudo o mais for esquecido

Uma linha separa as duas famílias. masked_fill(futuro, -inf). Tudo o mais — o objetivo de treino, o formato da saída, poder ou não cachear, gerar ou compreender — é consequência.

Meça distribuições, não anedotas. O gpt2-large "errou" uma pergunta e parecia pior que o medium. A perplexidade, sobre texto real, mostrou a escala se comportando de forma regular. Uma amostra de tamanho 1 não é evidência.

Um modelo só sabe o que viu. O detector funciona muito bem com texto do GPT-2 e falha com texto de 2026 — e, pior, confiante nos dois casos. Fora da distribuição de treino, a confiança de um modelo não significa nada.

Referências

As fontes primárias dos conceitos deste capítulo. Os números do texto foram medidos no laboratório; as ideias vêm daqui.

Os termos técnicos têm aqui o sentido de aprendizado de máquina. O glossário do curso mostra esse sentido ao lado dos outros que as mesmas palavras têm na TI.

  1. Radford, A., Wu, J., Child, R., Luan, D., Amodei, D. e Sutskever, I. (2019). Language Models are Unsupervised Multitask Learners. Relatório técnico, OpenAI. cdn.openai.com
  2. Hugging Face. openai-community: os pesos do GPT-2 e do detector usados no laboratório. Página dos modelos. huggingface.co/openai-community

Fim do curso. Os scripts continuam aí — mude os prompts, quebre coisas, meça de novo.
Foi assim que cada número destas apostilas apareceu.