# Instrucciones para el agente: OpenMythos: experimenta con transformers de profundidad recurrente

Pega este texto a tu agente (Claude Code, Codex, OpenCode, Hermes o el que uses) y dile «ayúdame a montarlo». Son los pasos para ponerlo en marcha; el porqué de cada pieza está en la guía completa.

- Dificultad: avanzado
- Proyecto: https://github.com/kyegomez/OpenMythos (licencia MIT)
- Guía completa: https://lab.wisd.ai/hub/openmythos-recurrent-transformer

---

## Para el agente: cómo acompañar al usuario

1. Pregunta primero para qué lo quiere. Si su objetivo no necesita algún paso, sáltalo.
2. Antes de instalar, comprueba lo que ya tiene (versiones, claves, sistema operativo).
3. Avanza un paso cada vez: explica en una frase qué vas a hacer y deja que el usuario lo ejecute o lo apruebe.
4. Tras cada paso, comprueba que funcionó antes de seguir. Si falla, para y explica el error.
5. No inventes comandos ni opciones: si la documentación del proyecto contradice estos pasos, manda la documentación.
6. Al terminar, haz una prueba real con el objetivo del usuario y dile dónde profundizar.

---

## Pasos de configuración

Comprueba que el entorno usa Python ≥3.10 y <4.0 con pip, según el [pyproject.toml oficial](https://github.com/kyegomez/OpenMythos/blob/main/pyproject.toml). En macOS/Linux crea y activa un entorno con `python -m venv .venv` y `source .venv/bin/activate`. Instala el paquete básico documentado:

```sh
pip install open-mythos
```

Guarda el ejemplo completo de Usage en `prueba.py`:

```python

import torch
from open_mythos.main import OpenMythos, MythosConfig


attn_type = "mla"  # or "gqa"

base = {
    "vocab_size": 1000,
    "dim": 256,
    "n_heads": 8,
    "max_seq_len": 128,
    "max_loop_iters": 4,
    "prelude_layers": 1,
    "coda_layers": 1,
    "n_experts": 8,
    "n_shared_experts": 1,
    "n_experts_per_tok": 2,
    "expert_dim": 64,
    "lora_rank": 8,
    "attn_type": attn_type,
}

if attn_type == "gqa":
    cfg = MythosConfig(**base, n_kv_heads=2)
else:
    cfg = MythosConfig(
        **base,
        n_kv_heads=8,
        kv_lora_rank=32,
        q_lora_rank=64,
        qk_rope_head_dim=16,
        qk_nope_head_dim=16,
        v_head_dim=16,
    )

model = OpenMythos(cfg)
total = sum(p.numel() for p in model.parameters())
print(f"\n[{attn_type.upper()}] Parameters: {total:,}")

ids = torch.randint(0, cfg.vocab_size, (2, 16))
logits = model(ids, n_loops=4)
print(f"[{attn_type.upper()}] Logits shape: {logits.shape}")

out = model.generate(ids, max_new_tokens=8, n_loops=8)
print(f"[{attn_type.upper()}] Generated shape: {out.shape}")

A = model.recurrent.injection.get_A()
rho = torch.linalg.eigvals(A).abs().max().item()
print(
    f"[{attn_type.upper()}] Spectral radius ρ(A) = {rho:.4f} (must be < 1)"
)
```

Ejecuta `python prueba.py` desde esa carpeta y con el entorno activado. Debe imprimir logits de forma `[2, 16, 1000]` y generación de forma `[2, 24]`; son entradas aleatorias y pesos sin entrenar, no una prueba de calidad.

## Comprobación

Verifica que las dimensiones de salida encajan con el lote y vocabulario definidos. Distingue esa comprobación de ejecución de cualquier evaluación de calidad.

## Si algo falla

Si falla la atención optimizada, revisa las dependencias opcionales. Si falta memoria, reduce el experimento siguiendo la configuración documentada.

Consulta [el README oficial](https://github.com/kyegomez/OpenMythos#readme) para requisitos y variantes de instalación.