O código original
da OpenAI

1 O que está em repos/

Clonamos as fontes primárias. Elas não são para rodar — são para ler. Depois de doze apostilas, você tem o vocabulário para entender cada linha, e ler o original tem um valor que nenhuma explicação de segunda mão substitui.

2 O bloco inteiro, no original

Aqui está a função block de gpt-2/src/model.py, sem uma linha alterada:

def block(x, scope, *, past, hparams):
    with tf.variable_scope(scope):
        nx = x.shape[-1].value
        a, present = attn(norm(x, 'ln_1'), 'attn', nx, past=past, hparams=hparams)
        x = x + a
        m = mlp(norm(x, 'ln_2'), 'mlp', nx*4, hparams=hparams)
        x = x + m
        return x, present

Leia devagar e reconheça tudo:

• x = x + a e x = x + m — as conexões residuais (apostila 05). O x nunca é destruído, só acrescido. O quadro-negro.
• norm(x, 'ln_1') dentro da chamada de attn, e a soma fora — isto é Pre-LN (apostila 05, seção 4). A diferença que permitiu 48 camadas está nesta ordem exata.
• nx*4 — o fator de expansão 4× do MLP, ali, literal.
• present — os K e V desta camada, devolvidos para serem cacheados. O cache KV (apostila 04) já estava no código original de 2019.

Sete linhas. É o bloco Transformer inteiro.

3 A máscara causal, no original

def attention_mask(nd, ns, *, dtype):
    """1's in the lower triangle, counting from the lower right corner.
    Same as tf.matrix_band_part(tf.ones([nd, ns]), -1, ns-nd), but doesn't
    produce garbage on TPUs."""
    i = tf.range(nd)[:,None]
    j = tf.range(ns)
    m = i >= j - ns + nd
    return tf.cast(m, dtype)

def mask_attn_weights(w):
    _, _, nd, ns = shape_list(w)
    b = attention_mask(nd, ns, dtype=w.dtype)
    b = tf.reshape(b, [1, 1, nd, ns])
    w = w*b - tf.cast(1e10, w.dtype)*(1-b)
    return w

4 Três achados de quem lê o original

Achado 1: a GELU é a aproximação por tanh, escrita à mão

def gelu(x):
    return 0.5*x*(1+tf.tanh(np.sqrt(2/np.pi)*(x+0.044715*tf.pow(x, 3))))

A GELU exata usa a função de distribuição acumulada da normal, que é cara. Esta é a aproximação por tangente hiperbólica — e aquele 0.044715 é uma constante ajustada empiricamente. Está no código original, escrita na mão. Se você usar nn.GELU() do PyTorch sem argumentos, terá a versão exata, ligeiramente diferente desta.

Achado 2: as três matrizes Q, K, V realmente são uma só

c = conv1d(x, 'c_attn', n_state*3)
q, k, v = map(split_heads, tf.split(c, 3, axis=2))

Uma única projeção para 3 × 768 = 2304, depois um corte em três. Exatamente o que a apostila 03 descreveu como detalhe de implementação — e aqui está a evidência.

O nome conv1d engana: leia a implementação e você verá que é uma matmul comum. É convolução de kernel 1, que é matematicamente idêntica a uma camada densa. Herança de convenção da época.

Achado 3: o cache KV, em duas linhas

present = tf.stack([k, v], axis=1)
if past is not None:
    pk, pv = tf.unstack(past, axis=1)
    k = tf.concat([pk, k], axis=-2)
    v = tf.concat([pv, v], axis=-2)

Empilha os K e V novos, concatena com os antigos. É toda a otimização que, no lab 04, você mediu valer um ganho de ~1,7× na geração — e que cresce para ordens de grandeza em textos longos.

E ela só é possível porque o modelo é causal (apostila 11). Num encoder, não haveria o que cachear.

5 O tokenizador: GPT-3-Encoder

Apesar do nome, é o tokenizador do GPT-2 — o GPT-3 reusou o mesmo. E é útil por dois motivos.

Primeiro, os arquivos de vocabulário estão ali, em texto puro:

• encoder.json — o mapa token → ID, todos os 50 257.
• vocab.bpe — as 50 000 fusões, na ordem em que foram aprendidas. A primeira linha é a primeira fusão do treino do BPE.

Você pode abrir esses arquivos num editor. É o merges.txt da apostila 01, e ver as primeiras linhas é ver a estatística do inglês.

Segundo, ele roda — em Node, que você tem. É útil quando você precisa contar tokens no navegador ou num serviço JavaScript, sem carregar Python.

6 O repositório gpt-3: dados, não código

Não há implementação — o GPT-3 nunca foi aberto. Mas há coisas valiosas:

• 175b_samples.jsonl — saídas cruas do modelo de 175 bilhões. Compare com o que o gpt2-xl produz e você vê, com os próprios olhos, o que 112× mais parâmetros compram.
• overlap_frequency.md — análise de contaminação: quanto dos conjuntos de avaliação vazou para o corpus de treino. É um documento honesto e raro, e um bom lembrete de que benchmarks de LLM são mais frágeis do que parecem.
• dataset_statistics/ — composição do corpus.

7 No laboratório

.venv\Scripts\python.exe lab\10_original_code.py

1. Mostra trechos do model.py original lado a lado com a implementação PyTorch equivalente, para você ver a correspondência linha a linha.
2. Abre o vocab.bpe e mostra as 20 primeiras fusões que o BPE aprendeu. As primeiras são as mais frequentes do inglês.
3. Confirma que o tokenizador JS e o Python produzem os mesmos IDs — roda o Encoder.js via Node e compara.
4. Extrai amostras do GPT-3 de 175b_samples.jsonl e mostra ao lado de uma geração do gpt2-xl com o mesmo tema.

Você leu a fonte. A apostila 14 fecha o laboratório com a última peça prática:
como servir esses modelos por HTTP — e o que o TGI e o TEI fazem que o nosso servidor não faz.