English · Español

Lab 03 — Grafo de conocimiento: visualizando las 40 fases¶

🇪🇸 Un grafo donde los nodos son conceptos clave y las aristas son dependencias entre fases. Un futuro aprendiz puede leer el grafo y entender qué encaja con qué. Es la cartografía del proyecto.

Objetivo¶

Producir un único archivo SVG: docs/phase-40-hardening-postmortem/diagrams/knowledge-graph.svg. Los nodos son conceptos (uno por fase, aproximadamente); las aristas son dependencias ("la comprensión de la Fase N requiere la Fase M"). Anotado para que un extraño pueda leerlo en 5 minutos.

Preparación¶

graphviz (dot) para renderizar, o mermaid si lo prefieres (uv add o instalación de sistema).
Los 40 archivos PHASE_NN_README.md para el concepto principal de cada fase.
Las secciones "What this phase does NOT cover", que a menudo nombran dependencias con fases posteriores.

Tareas¶

Escoge el conjunto de nodos. Apunta a 30-50 nodos. Cada nodo es un concepto, no necesariamente una fase. Muchas fases aportan múltiples conceptos; algunas aportan uno. Ejemplos:
Fase 02 → "representación numérica fp32/fp16/bf16" (un nodo).
Fase 17 → "Bloque transformer Pre-LN" + "embeddings atados" + "ensamblaje Mini-GPT" (tres nodos).
Fase 21 → "Sampling: greedy/temperature/top-k/top-p" (un nodo).
Fase 22 → "KV cache" (un nodo).
Fase 33 → "FastAPI serving" + "continuous batching" + "ley de Little" (tres nodos).
Escoge el conjunto de aristas. Las aristas son relaciones de prerrequisito. Si entender el concepto B requiere el concepto A, dibuja A → B. Ejemplos:
"fp32/fp16/bf16" → "cuantización" (Fase 02 → Fase 26)
"log-sum-exp" → "softmax sampling a temperatura" (Fase 05 → Fase 21)
"Bloque transformer Pre-LN" → "KV cache" (Fase 17 → Fase 22)
"KV cache" → "continuous batching" (Fase 22 → Fase 33)

Apunta a ≤ 3 aristas entrantes por nodo. Si un nodo tiene más, es demasiado central — divídelo en dos conceptos o empuja algunos prerrequisitos para que sean "indirectos" (es decir, pasen por un nodo intermedio).

Renderiza con dot:

digraph LynxCortex {
    rankdir=LR;
    node [shape=box, fontname="Helvetica", fontsize=10];

    // Foundations
    "Reproducibility (P00)" -> "Numerical Representation (P02)";
    "Numerical Representation (P02)" -> "Quantization (P26)";

    "Log-sum-exp (P05)" -> "Softmax sampling at τ (P21)";
    "Cross-entropy (P05)" -> "Training loop (P18)";

    "Tied embeddings (P17)" -> "LM head (P17)";
    "Pre-LN block (P17)" -> "Mini-GPT assembly (P17)";
    "Mini-GPT assembly (P17)" -> "Training loop (P18)";
    "Training loop (P18)" -> "Training dynamics (P19)";
    "Training loop (P18)" -> "Mini-GPT (P17)";

    "KV cache (P22)" -> "Continuous batching (P33)";
    "FastAPI serving (P33)" -> "Continuous batching (P33)";
    "Little's law (P33)" -> "Capacity sizing (P34)";

    // ... continue for ~30-50 nodes total
}

Renderiza:

dot -Tsvg knowledge-graph.dot -o knowledge-graph.svg

Agrupa el grafo. Usa subgraph cluster_X { ... } para agrupar conceptos por tema:
Fundamentos (Fases 00-09): reproducibilidad, matemáticas, autograd.
Tokenización y datos (Fases 11-13): BPE, diseño de corpus, embeddings.
Modelado de secuencias (Fases 14-17): attention, posicional, Mini-GPT.
Entrenamiento y evaluación (Fases 18-20): loops, dinámicas, harness.
Inferencia (Fases 21-22, 27): sampling, KV cache, attention moderna.
Optimización (Fases 23-28): GPU, CUDA, cuantización, LoRA.
Aplicación (Fases 29-32): RAG, generación estructurada, herramientas, agentes.
Operaciones (Fases 33-39): serving, observabilidad, distribuido, seguridad, MLOps.
Renderiza con anotaciones. Usa label= en aristas clave para denotar por qué existe la dependencia:

"KV cache (P22)" -> "Continuous batching (P33)" [label="per-request cache"];

Verifica la legibilidad. Abre el SVG en un navegador. Recórrelo como si nunca lo hubieras visto:
¿Puedes identificar los puntos de entrada (conceptos fundacionales, sin aristas entrantes)?
¿Puedes identificar los nodos terminales (conceptos capstone, sin aristas salientes)?
¿Los clusters agrupan visiblemente conceptos relacionados?
¿Algún nodo está aislado (sin aristas)? Bórralo o arréglalo.
Enlaza desde el README de la fase. Añade a docs/phase-40-hardening-postmortem/README.md:

![Knowledge graph](diagrams/knowledge-graph.svg)

Entregable¶

docs/phase-40-hardening-postmortem/diagrams/knowledge-graph.svg — el grafo renderizado.

Además la fuente: docs/phase-40-hardening-postmortem/diagrams/knowledge-graph.dot (o .mmd para mermaid).

Aceptación¶

30-50 nodos; 50-100 aristas.
Agrupado en 5-8 grupos lógicos.
Renderiza limpio a SVG.
Sin nodos aislados.
Un extraño podría trazar un camino desde "Reproducibility" hasta "Continuous batching" siguiendo las flechas, con cada paso justificado.

Trampas¶

Demasiados nodos. Pasados ~60, el grafo se vuelve ilegible. Agrega. ("Higiene numérica" puede ser un nodo, no tres.)
Pocas aristas. Los conceptos en un sistema de IA (AI) son densos. Si tienes 50 nodos y 10 aristas, estás subconectando. Apunta a ~2-3 aristas por nodo de media.
Ciclos. El grafo debe ser acíclico (es un grafo de dependencias del currículo). Si encuentras un ciclo, es un bug en tu conceptualización — rómpelo siendo más preciso sobre qué subconcepto depende de cuál.
Infierno de renderizado. Los layouts por defecto de Graphviz pueden ser feos. Prueba rankdir=LR (izquierda a derecha) para grafos estilo currículo; usa splines=ortho para aristas ortogonales limpias.
Confundir "fase" con "concepto". Una fase es un capítulo; un concepto es una noción. Algunas fases producen muchos conceptos; otras producen uno.

Extensión¶

Añade color para codificar algo útil: p. ej., rojo para fundamentos, azul para inferencia, verde para ops. No sobrecolorees — 5 categorías máximo.
Añade pesos a las aristas según, digamos, la fuerza de la dependencia. Difumina visualmente las débiles.
Renderiza dos veces: una con todos los nodos (el maestro), otra colapsado por cluster (el resumen ejecutivo). Enlaza ambas desde el README.

Siguiente: 04-final-reflection.md