Skip to content

English · Español

Lab 02 — Inventario de parámetros: cuenta cada parámetro

Lee theory/02-ffn-and-activations.md (§"FFN parameter count") y PHASE_17_PLAN.md §6 (en la raíz del repo). No consultes solutions/.

Objetivo

Recorre tu Mini-GPT capa por capa y cuenta cada parámetro. Haz coincidir el conteo con una fórmula cerrada. Grafica la distribución como barra apilada (¿dónde vive la masa de parámetros?). Cuando termines este lab deberías ser capaz de escribir el conteo de parámetros de cualquier variante de Mini-GPT sólo desde su configuración.

Background

El conteo de parámetros en forma cerrada para Mini-GPT (tied embeddings, sesgos en FFN, sin sesgos en proyecciones Q/K/V, LayerNorm con scale + shift):

\[ |\theta| = \underbrace{|V| \cdot d_\text{model}}_\text{tied embedding} + n_\text{layers} \Big[ \underbrace{4 d_\text{model}^2}_\text{Q,K,V,O proj} + \underbrace{2 d_\text{model} d_\text{ff} + d_\text{ff} + d_\text{model}}_\text{FFN} + \underbrace{4 d_\text{model}}_\text{2 LN's} \Big] + \underbrace{2 d_\text{model}}_\text{final LN} \]

Para Mini-GPT (\(d_\text{model} = 64, n_\text{heads} = 4, n_\text{layers} = 2, d_\text{ff} = 256, |V| = 64\)):

  • Tied embedding: \(64 \cdot 64 = 4{.}096\)
  • Por bloque: \(4 \cdot 64^2 + 2 \cdot 64 \cdot 256 + 256 + 64 + 4 \cdot 64 = 16{.}384 + 32{.}768 + 256 + 64 + 256 = 49{.}728\)
  • Dos bloques: \(99{.}456\)
  • LN final: \(128\)
  • Total: \(4{.}096 + 99{.}456 + 128 = 103{.}680\) parámetros.

Si tu cuenta a mano anterior fue ~57k, te olvidaste de incluir el sesgo del FFN o los parámetros de LayerNorm. Re-deriva.

Tareas

Tarea 1 — recorrido programático

En un script scripts/phase17_param_inventory.py:

def inventory(model: MiniGPT) -> dict[str, int]:
    """Return {component_name: param_count} for every parameter in the model."""

Componentes a enumerar (claves sugeridas):

  • E (embedding, atado)
  • block_0.attn.W_q, W_k, W_v, W_o
  • block_0.ffn.W_1, b_1, W_2, b_2
  • block_0.ln1.gamma, beta, ln2.gamma, beta
  • (igual para block_1)
  • ln_final.gamma, beta

Suma todas las entradas; comprueba que sea igual a la predicción en forma cerrada (103.680 para la config bloqueada) con error cero — esto es un conteo entero, no un cómputo numérico.

Tarea 2 — derivación de la fórmula en tus notas

En learners/borja/phase-17/notes.md:

  1. Deriva el conteo por componente para un bloque transformer desde primeros principios. Muestra tu trabajo — p. ej., "Proyección Q: mapea \(d_\text{model}\) → \(d_\text{model}\), sin sesgo, así que \(d_\text{model}^2 = 4096\)".
  2. Suma para obtener la fórmula. Sustituye. Haz coincidir con tu recorrido programático.
  3. Repite para la variante con sesgos en las proyecciones Q/K/V (GPT-2 los tiene; LLaMA no). Nueva fórmula. Nuevo total. (Aproximadamente \(+4 d_\text{model} n_\text{layers} = +512\) para Mini-GPT.)

Tarea 3 — visualización de barra apilada

Produce una gráfica de barra apilada con una columna por componente arquitectónico:

grupo de parámetros    params
─────────────────────────────────
embedding (atado)       4.096
attn bloque 0          16.384
FFN bloque 0           33.088
LayerNorms bloque 0       256
attn bloque 1          16.384
FFN bloque 1           33.088
LayerNorms bloque 1       256
LayerNorm final           128
─────────────────────────────────
TOTAL                 103.680

Guarda como experiments/<date>-phase-17-param-inventory/distribution.png. Usa un gráfico de barras horizontal para legibilidad.

Tarea 4 — comparación con GPT-2 small (sólo los números, para escala)

GPT-2 small: \(d_\text{model} = 768, n_\text{heads} = 12, n_\text{layers} = 12, d_\text{ff} = 3072, |V| = 50257\).

Calcula el conteo de parámetros usando tu fórmula. Compáralo con los "117M" publicados. (Nota: a veces se cita 117M, otras veces 124M en otros sitios — la diferencia es si se cuentan los tied embeddings; clarifica qué convención coincide con tu fórmula.)

Este es un ejercicio sólo de papel — no estás construyendo GPT-2, sólo confirmando que tu fórmula generaliza.

Tarea 5 — qué cambia cuando escalas

Para tres variantes Mini-GPT escaladas:

| Variante | \(d_\text{model}\) | \(n_\text{layers}\) | \(d_\text{ff}\) | \(|V|\) | Total de parámetros (tu fórmula) | |---|---|---|---|---|---| | Mini-GPT (bloqueado) | 64 | 2 | 256 | 64 | 103.680 | | Mini-GPT-medium | 128 | 4 | 512 | 64 | ? | | Mini-GPT-large | 256 | 6 | 1024 | 64 | ? |

Calcula y tabula. Observa cómo crece la fracción de parámetros del FFN con la profundidad.

Mediciones a capturar

  • Conteo programático: 103.680 exactos (para la config bloqueada).
  • Coincidencia con la forma cerrada: ✓ o ✗.
  • Gráfica de barra apilada guardada.
  • Tabla de escalado para las tres variantes.

Aceptación

  • scripts/phase17_param_inventory.py devuelve el diccionario por componente.
  • La suma es exactamente igual a la predicción en forma cerrada.
  • Las notas contienen la derivación de la fórmula con tus propias palabras.
  • Gráfica de barra apilada guardada.
  • Tabla de escalado completada.
  • Las notas del lab identifican el FFN como ~64% de los parámetros por bloque y ~64% del total (para la config bloqueada).

Trampas a esperar

  • Olvidar el LayerNorm final. Habitual. Tu cuenta sale 128 corta; investiga antes de cantar victoria.
  • Contar una cabeza LM no atada. Si por accidente creaste self.W_LM como matriz separada en mini_gpt.py, tu cuenta sale \(|V| \cdot d_\text{model} = 4096\) alta. Relee theory/03-tied-embeddings-and-lm-head.md.
  • Off-by-one en la decisión de sesgos. Decide una vez si tus proyecciones Q/K/V tienen sesgos. GPT-2: sí; LLaMA: no; default de Mini-GPT: no (fórmula más limpia). Mantén consistencia entre block.py, mini_gpt.py y este lab.
  • Contar buffers in-place. RoPE pre-calcula una tabla coseno/seno; eso es un buffer, no un parámetro. No lo incluyas en el conteo de parámetros.

Siguiente: 03-causality-perturbation.md