# Atlas Ornith: curso práctico de MoE, poda, destilación y cuantización

**Estado de este capítulo:** investigación documental cerrada el 23-09-2026. No se descargó ningún modelo, no se entrenó nada y no se modificó ningún servidor. Las afirmaciones que llevan «hecho» o «medido» son resultados publicados por la fuente enlazada; no son mediciones de esta máquina. Las recetas marcadas «propuesta» son un plan reproducible para un laboratorio posterior, no una promesa de que funcionen en Ornith.

[TOC]

## 1. Qué problema estamos resolviendo

Hay tres preguntas distintas que suelen mezclarse:

1. **¿Cabe el modelo?** Reducir bytes (cuantizar), eliminar expertos o quitar capas.
2. **¿Sigue siendo bueno?** Medir pérdida, tareas generales y las tareas reales del usuario.
3. **¿Qué capacidad se perdió?** Idioma, visión, herramientas, código, razonamiento, contexto y seguridad tienen regresiones distintas.

La compresión no convierte automáticamente un modelo en otro «equivalente». El objetivo práctico es una frontera de Pareto: memoria/latencia/energía frente a calidad, con una regresión aceptable y conocida.

### Lo que sí sabemos de Ornith-1.5

La ficha oficial publica una familia con un **Ornith-1.5-9B denso** y un **Ornith-1.5-35B-A3B MoE**. El 35B-A3B activa aproximadamente 3B parámetros por token, conserva aproximadamente 35B de pesos totales y declara ventana de 262 144 tokens; su receta bf16 ronda 70 GB y está pensada para paralelismo entre GPUs. La ficha también publica benchmarks con cinco repeticiones y especifica harness, temperatura y límites de contexto. Eso es evidencia de la ficha, no una garantía de igual resultado en otra versión del runtime o hardware: [model card oficial del 35B-A3B](https://huggingface.co/ornith-ai/Ornith-1.5-35B-A3B) y [README oficial de la familia](https://github.com/ornith-ai/Ornith-1).

El 9B denso aplica todos sus bloques a cada token. El 35B-A3B no «carga sólo 3B»: normalmente los pesos de los expertos siguen residentes, pero el router ejecuta sólo una fracción por token. Por eso el MoE puede ahorrar FLOPs de cómputo sin ahorrar automáticamente RAM/VRAM de pesos. La ficha oficial dice explícitamente que los MoE se fragmentan en varios GPUs; una cuantización o poda estructural es lo que cambia el tamaño residente.

## 2. MoE desde cero: router, expertos y coste

En un bloque Transformer, el FFN/MLP se sustituye por varios FFN. Para un estado de token `h`, un router produce logits `r = W_r h`, selecciona los `k` expertos con mayor puntuación y combina sus salidas:

```text
g = softmax(top_k(r))
y = sum(g_i * Expert_i(h))       para i en los k expertos elegidos
```

La atención, normalización, embeddings y `lm_head` siguen siendo compartidos (la arquitectura exacta puede variar). El router decide **por token y por capa**, no una vez por conversación. Un mismo token puede ir al experto 7 en la capa 4 y al 103 en la capa 18.

Tres contadores deben mantenerse separados:

* **Parámetros totales:** todos los expertos + partes compartidas. Determinan sobre todo el almacenamiento.
* **Parámetros activos:** los expertos realmente computados por token. Aproximan el coste de FLOPs, pero no incluyen todo el overhead de dispatch, atención ni KV cache.
* **Parámetros residentes:** lo que debe estar en RAM/VRAM (o moverse desde CPU/SSD). La inferencia puede ser lenta aunque sólo se activen 3B si se hace offload.

El router puede saturarse (muchos tokens hacia los mismos expertos), perder capacidad por límites de batch, o aprender rutas que parecen «especializadas» sin corresponder a categorías humanas como «experto de Python». La clase de Stanford CS336 advierte precisamente que el nombre *expert* no prueba una especialización semántica. Para una introducción visual, usar la [clase 4 de Stanford CS336](https://www.youtube.com/watch?v=LPv1KfUXLCo); el enlace y su descripción fueron verificables, pero no se afirma aquí que se haya visto el vídeo ni se inventa una transcripción.

## 3. Denso 9B frente a 35B-A3B: decisión de laboratorio

| Propiedad | 9B denso | 35B-A3B MoE |
|---|---|---|
| Cálculo | Todos los MLP en cada token | `k` expertos por token, más dispatch/router |
| Huella de pesos | Menor en bf16 y en Q4 | Todos los expertos cuentan; A3B no significa 3B en disco |
| Dependencia del runtime | Sencilla | Arquitectura, kernels, TP y soporte MoE importan mucho |
| Paralelismo | Una GPU grande o una fracción | Normalmente varias GPUs; depende de cuantización y contexto |
| Riesgo de poda | Se podan capas/canales/pesos, no «expertos» | Se puede podar expertos, pero router, expertos compartidos y MTP deben coincidir |
| Uso pedagógico | Buen baseline y estudiante | Buen profesor/capacidad total; buen sujeto de poda |

**Propuesta de comparación:** fijar la misma plantilla de chat, tokens máximos, temperatura, top-p, presupuesto de razonamiento y semillas. Medir el 9B bf16/Q4 y el 35B-A3B bf16/Q4 sin cambiar el servidor a mitad del experimento. Una mejora del MoE en un benchmark ajeno no prueba mejora en el agente real.

Métricas mínimas:

* `loss`/perplexity en un conjunto de texto retenido por idioma y dominio;
* exactitud de problemas cortos (matemáticas, extracción, clasificación);
* tests de código ejecutables (HumanEval+/MBPP+ o un repositorio propio);
* éxito de herramienta con argumentos JSON válidos;
* tareas agentic de varias rondas (tiempo límite, tasa de entrega y corrección);
* tokens/s de prefill y decode, p50/p95, VRAM/RAM y fallos de contexto;
* ruta de expertos: frecuencia, entropía y cobertura por capa y por idioma.

## 4. Qué significa podar expertos

Hay que distinguir cuatro operaciones:

1. **Poda estructurada de expertos:** retirar FFN completos y ajustar el número de expertos/router. Sí reduce el checkpoint y puede reducir dispatch.
2. **Poda no estructurada:** poner pesos a cero. Puede no reducir el archivo ni acelerar sin kernels sparse.
3. **Poda de capa/profundidad:** quitar o colapsar bloques Transformer completos. Cambia el camino residual y es especialmente peligrosa para razonamiento generativo.
4. **Poda de vocabulario:** eliminar filas del embedding y columnas/filas correspondientes del `lm_head`, además del tokenizer. No elimina el conocimiento interno de una lengua.

Para expertos, no usar sólo frecuencia. Un experto poco frecuente puede ser crítico para una lengua minoritaria o para un formato raro. REAP (Router-weighted Expert Activation Pruning) combina la compuerta del router con la norma de activación media; su repositorio explica que selecciona los expertos con contribución menor por capa. La implementación y el artículo publican calibración y scripts, pero soportar un `model_type` nuevo requiere adaptar nombres de módulos: [repo oficial de REAP](https://github.com/CerebrasResearch/reap).

La documentación de `llm-compressor` ofrece un ejemplo con **Qwen3-30B-A3B** y **Moonlight-16B-A3B**, calibrado con 512 muestras de UltraChat y evaluado con LM Eval. En Qwen, 25% y 50% de sparsity retuvieron 98.86% y 99.80% de su resultado estricto de GSM8K en esa configuración; en Moonlight, 50% cayó a 16.99% de recuperación. La lección reproducible es la variabilidad entre bases, no una cifra transferible a Ornith: [ejemplo oficial REAP de vLLM](https://docs.vllm.ai/projects/llm-compressor/en/latest/examples/reap_expert_pruning/).

## 5. El hallazgo «timmi/timmy» y qué no afirmar

Actualización v4.7: se identificaron [Ttimms REAP-50 BF16](https://huggingface.co/Ttimms/Ornith-1.5-35B-A3B-REAP-50-bf16) y [oxfrug REAP-20pct](https://huggingface.co/oxfrug/Ornith-1.5-35B-A3B-REAP-20pct). El primero conserva 128 de 256 expertos; el segundo 205. El 30% sigue como candidato experimental, no checkpoint localizado.

Las salidas BF16, GGUF y NVFP4 no son intercambiables: la BF16 de Ttimms conserva visión según su card; la salida NVFP4 es text-only y se orienta a Blackwell/SM120, no a una 3090. `sleepyeldrazi ...20B` describe parámetros, no 20% de poda. No probamos esos pesos localmente.

Abre [el catálogo actualizado de variantes, revisiones y límites](/laboratorio/moe/variantes/). Conserva la diferencia entre resultado comunitario y prueba del laboratorio. Para practicar primero, usa [los ejemplos CPU y el planner 20/30/50](/laboratorio/investigacion/).

## 6. Poda de capas y combinación con MoE

Quitar expertos y quitar capas no son versiones equivalentes del mismo ajuste. La capa contiene atención, normalización, residual y quizá MTP; un experto suele ser una rama FFN dentro de una capa. En Ornith, el proyecto comunitario inspeccionó que el MTP tenía su propia ruta experta y que un campo de configuración era compartido; su solución fue desactivarlo y recargar con un forward real. Eso es una advertencia operativa, no una receta universal.

Hay literatura de profundidad como [LaCo: Layer Collapse](https://arxiv.org/abs/2402.11187), que reporta 25–30% de reducción en determinados LLM y tareas, y trabajos de *greedy-layer pruning*. También existe evidencia de que el razonamiento generativo puede ser más sensible a reducir profundidad que la clasificación. Antes de tocar Ornith:

1. clonar el checkpoint (no sobrescribir);
2. inspeccionar `config.json`, clases, `num_hidden_layers`, MTP, visión, embeddings y `lm_head`;
3. probar eliminar una capa candidata en CPU con entradas de forma pequeña;
4. comparar logits de teacher/student antes de entrenar;
5. sólo entonces medir una escalera de 10/20/30% de profundidad con destilación.

En un MoE, una reducción sensata suele ser: primero medir expertos; luego elegir poda por capa, preservando capas tempranas/tardías si los datos lo sugieren; mantener un baseline de poda uniforme; y no mezclar a la vez poda de expertos, capas, vocabulario y cuantización.

## 7. Destilación maestro–alumno después de podar

El **teacher** es el Ornith sin podar; el **student** es el checkpoint podado. La idea es entrenar al student para que conserve la distribución del teacher además de acertar el token objetivo:

```text
L = (1 - α) * CE(student_logits, labels)
    + α * T² * KL(softmax(teacher_logits/T), softmax(student_logits/T))
```

Para poda de expertos se puede añadir una pérdida de representación/activación cuando exista correspondencia de dimensiones. `MoE-Pruner` propone una destilación **expert-wise** y publica la fórmula de CE + MSE entre salidas de expertos correspondientes; en Mixtral-8x7B, su experimento reporta subir la media de nueve tareas de 67.23 a 68.40 frente a 69.16 del teacher, usando 1 000 muestras C4 y tres épocas a `2e-5`. Es evidencia de Mixtral, no prueba de Ornith: [MoE-Pruner (artículo)](https://arxiv.org/abs/2410.12013).

Una receta de investigación para Ornith (no ejecutada):

1. Congelar el teacher y guardar sólo logits/activaciones de una muestra pequeña si hay espacio; si no, hacer dos forwards sincronizados.
2. Usar corpus de calibración que cubra código, conversación, matemáticas, herramientas, español/inglés y el dominio objetivo.
3. Comenzar con `α=0.1–0.5`, temperatura `T=2–4`, LR pequeño y máscara de poda fija.
4. Añadir replay de ejemplos donde el student falle y un conjunto retenido que nunca se use para seleccionar la poda.
5. Detenerse si mejora la pérdida pero empeora herramientas, idiomas o regresión de seguridad.

El teacher no tiene que ser otro modelo gigantesco; sí debe ser una referencia mejor y evaluada en la misma plantilla. Destilar desde un checkpoint ya cuantizado mezcla error de teacher con error de compresión: para una atribución limpia, usar teacher bf16/fp16 y cuantizar al final.

## 8. Cuantización: después o antes de la poda

Cuantizar aproxima pesos/activaciones con menos bits. **Q4, AWQ, GPTQ, FP8, NVFP4 y GGUF son formatos/métodos**, no sinónimos de un modelo distinto. AWQ y GPTQ suelen necesitar calibración; bitsandbytes ofrece cuantización práctica de 4/8 bits; `compressed-tensors` se usa para formatos específicos como FP8. La tabla y limitaciones de hardware cambian, por lo que se debe consultar la [documentación oficial de Transformers](https://github.com/huggingface/transformers/blob/main/docs/source/en/quantization/overview.md) y la [guía de selección](https://github.com/huggingface/transformers/blob/main/docs/source/en/quantization/selecting.md). El artefacto Ornith REAP-NVFP4 de t-timms está documentado para RTX 5070 Ti **SM120**; una RTX 3090 **SM86** no debe asumirse compatible con kernels NVFP4 nativos. En 3090 la ruta prudente es probar GGUF/Q4 o AWQ con el runtime concreto y medir, no trasladar la receta FP4 por nombre.

Secuencia recomendada para comparar, manteniendo una variable:

```text
teacher bf16
  ├─ baseline bf16
  ├─ baseline cuantizado (AWQ/GPTQ/GGUF/FP8 según backend)
  ├─ poda 20/30/50% en bf16 → student podado
  ├─ student podado + destilación → student healed
  └─ student healed → cuantización final
```

También es legítimo probar poda después de cuantizar, pero entonces la saliencia puede reflejar error de redondeo y hay que reportarlo como otra rama. En el proyecto `t-timms`, la cadena reportada es poda primero, después GPTQ-NVFP4A16; un resultado anterior del mismo autor encontró que dos variantes de cuantización no mostraban diferencia estadísticamente significativa, evidencia útil para no suponer que un nombre de cuantizador implica calidad superior.

La memoria de pesos es sólo una parte: KV cache, activaciones, batch y contexto pueden dominar. Una prueba de «cabe a 16 GB» debe incluir el contexto, `max_num_seqs`, servidor real y margen; no basta con el tamaño del archivo.

**Artefacto GGUF concreto para el laboratorio:** el archivo `Ornith-1.5-9B-Q4_K_L.gguf` aparece en la colección comunitaria [bartowski/Ornith-1.5-9B-GGUF](https://huggingface.co/bartowski/Ornith-1.5-9B-GGUF/blob/main/Ornith-1.5-9B-Q4_K_L.gguf). El repositorio oficial [ornith-ai/Ornith-1.5-9B-GGUF](https://huggingface.co/ornith-ai/Ornith-1.5-9B-GGUF) lista Q4_K_M, Q5_K_M, Q6_K y Q8_0, pero no Q4_K_L. Son artefactos diferentes: no se debe sustituir uno por otro ni llamar «equivalente» a Q4_K_L y Q4_K_M sin comparar metadatos, bytes, hash y evaluación. La receta propuesta es sólo registrar el repositorio, commit, tamaño/hash y backend `llama.cpp`; no se descargó ni se ejecutó aquí.

## 9. Idiomas, tokenizador y la falsa idea de «un experto por idioma»

Un router puede mostrar rutas con correlación lingüística, pero **correlación no significa que exista un experto español localizado**. El estudio ICLR 2026 [Multilingual Routing in Mixture-of-Experts](https://openreview.net/pdf?id=ZoZR0x7tTD) reporta rutas más específicas de idioma en capas tempranas/tardías y mayor alineamiento entre idiomas en capas intermedias; dirigir a expertos «multilingües» sólo en ciertas capas mejoró 1–2% en sus tareas. Otro trabajo, [MoE-LPR](https://ojs.aaai.org/index.php/AAAI/article/view/34805), propone añadir expertos para idiomas ampliados, congelar parámetros originales y usar menos de 1% de replay para recuperar lenguas previas. Son diseños entrenados para estudiar el problema, no evidencia de que Ornith tenga separación equivalente.

**Borrar un idioma no equivale a extraer un idioma localizado en expertos.** El conocimiento puede estar distribuido en embeddings, `lm_head`, atención, capas intermedias y expertos compartidos; además el tokenizer puede fragmentar varios idiomas con los mismos bytes. Eliminar filas del vocabulario puede ahorrar memoria o impedir producir tokens concretos, pero no garantiza borrar representaciones, hechos ni rutas internas.

La [Vocabulary Trimming](https://aclanthology.org/2023.findings-emnlp.981/) conserva alrededor de 50% del vocabulario en algunos modelos y tareas de siete idiomas, pero es un estudio de LMs multilingües concretos. Para una variante monolingüe de Ornith habría que:

1. construir un vocabulario permitido desde corpus objetivo y conservar bytes/especiales indispensables;
2. remapear tokenizer, embeddings y `lm_head` con un checkpoint nuevo;
3. hacer continued pretraining o destilación, no sólo borrar archivos;
4. medir tokenización (tokens por carácter), pérdida y generación;
5. correr regresión en idiomas eliminados, idiomas retenidos y código mixto.

La regresión debe incluir prompts traducidos, *code-switching*, nombres propios, URLs, JSON y caracteres no ASCII. Si el objetivo es **unlearning** y no sólo tamaño, usar métricas de olvido y utilidad: [TOFU](https://arxiv.org/abs/2401.06121) advierte que una negativa superficial no demuestra que la información sea irrecuperable; [OpenUnlearning](https://github.com/locuslab/open-unlearning) reúne TOFU, MUSE, WMDP y múltiples métricas. Para un idioma, añadir ataques de paráfrasis, transliteración y traducción inversa. Declarar «el modelo ya olvidó español» sólo después de esa batería; incluso una batería amplia acota el comportamiento observado, no garantiza eliminación absoluta de representaciones o recuperación futura.

## 10. Proyecto reproducible sin GPU: qué registrar

El objetivo de la primera fase es producir un **plan**, no pesos. Guardar:

```text
experiment_id, base_revision, tokenizer_revision, runtime_revision
method, calibration_manifest_sha256, seed, compression_ratio
layers_before/after, experts_before/after, mtp/vision flags
dtype, quantizer, group_size, backend, context, batch
task, n, score, stderr_or_ci, latency_p50/p95, peak_memory
```

### A. Baseline

* Congelar revisiones y plantilla de chat.
* Ejecutar 20–50 ejemplos por tarea antes de un benchmark grande.
* Guardar prompt, semilla, parámetros de muestreo, respuesta y resultado automático.
* Separar smoke test, evaluación de calidad y prueba agentic. Un servidor que inicia no prueba tool calling.

### B. Calibración y saliencia

* Formar un manifiesto con proporciones por idioma/dominio; no seleccionar sólo por frecuencia.
* Medir `router_topk` por capa, frecuencia, entropía y norma de activación.
* Comparar importancia de REAP, frecuencia simple y aleatoria como controles.
* Probar ratios 20%, 30% y 50% en la **misma** calibración, semilla y backend.

### C. Validación de checkpoint

* Recargar en un proceso nuevo; validar shapes de expertos, router, MTP, visión, embeddings y `lm_head`.
* Hacer forward determinista de 1–4 tokens y comprobar que logits no sean NaN/constantes.
* Comprobar que el tokenizer de salida es exactamente el esperado.
* Convertir sólo después de una recarga bf16/fp16 exitosa.

### D. Matriz mínima de regresión

```text
                 teacher  student20  student30  student50  healed  quant
PPL general          ✓        ✓          ✓          ✓         ✓       ✓
PPL español          ✓        ✓          ✓          ✓         ✓       ✓
tool JSON             ✓        ✓          ✓          ✓         ✓       ✓
HumanEval/MBPP        ✓        ✓          ✓          ✓         ✓       ✓
agente real           ✓        —          —          ✓         ✓       ✓
VRAM/tok/s             ✓        ✓          ✓          ✓         ✓       ✓
```

Esta tabla es **un diseño de pruebas, no resultados**: cada `✓` significa “medición requerida”, nunca “aprobado”. `—` significa prueba diferida, no cero. No rellenar celdas con estimaciones. Reportar intervalos o bootstrap cuando el conjunto sea pequeño y conservar fallos de infraestructura separados de fallos del modelo.

## 11. Código reproducible: CPU primero y pipeline real separado

Los ejemplos de `moe-examples/` son ejecutables en CPU y no descargan pesos ni llaman a un servidor. Sirven para comprobar el contrato de evaluación antes de gastar GPU:

```sh
cd /RUTA/AL/KIT/moe-examples
python3 -m unittest discover -s . -p 'test_*.py' -v       # 3 tests CPU
python3 check_config.py fixtures/config-mini.json
python3 route_stats.py fixtures/route-events.jsonl
python3 language_regression.py fixtures/language-results.jsonl
```

`check_config.py` muestra `num_experts`, `num_experts_per_tok`, capas, vocabulario y MTP sin cargar tensores. `route_stats.py` resume eventos que un runtime ya exportó; no finge que puede obtener `router_logits` de un endpoint que no los expone. `language_regression.py` calcula tasas a partir de un veredicto externo (`ok`), no de un juez LLM escondido. En una batería real, `language` debe venir del manifiesto del prompt, nunca de una inferencia del modelo.

Para Ornith, el `config` y el smoke test publicados por t-timms verifican **256 expertos y `num_experts_per_tok=8`**. Si el runtime entrega logits, cuenta exactamente `k=8`; `topk(k=2)` sería sólo una ilustración de juguete y no representa el enrutamiento actual:

```python
K_ROUTER = 8  # Ornith-1.5 observado; leer config antes de fijarlo
for layer, logits in enumerate(router_logits):
    top = logits.topk(k=K_ROUTER, dim=-1).indices
    counts[layer].index_add_(0, top.reshape(-1), torch.ones(top.numel()))
```

Una evaluación mínima de un servidor ya encendido puede hacerse sin instalar SDK:

```sh
BASE_URL="${BASE_URL:-http://127.0.0.1:8000/v1}"
export MODEL="${MODEL:?define MODEL after inspecting /v1/models}"
curl -fsS "$BASE_URL/models"
curl -fsS "$BASE_URL/chat/completions" \
  -H 'Content-Type: application/json' \
  -d "$(python3 - <<'PY'
import json
print(json.dumps({
  'model': __import__('os').environ['MODEL'],
  'messages': [{'role':'user','content':'Responde sólo: 2+2=4'}],
  'temperature': 0,
  'max_tokens': 256,
}))
PY
)"
```

Esto sólo prueba `/v1/models` y una respuesta; no prueba calidad MoE. Para comparar base/student, conserva el mismo prompt, tokenizer/chat template, temperatura, semilla si el servidor la acepta, `max_tokens` y timeout; guarda respuesta, latencia, tokens y error. Después alimenta un JSONL normalizado a `language_regression.py` y añade pruebas de español retenido, idiomas que se pretenden eliminar, *code-switching*, nombres propios, JSON y caracteres no ASCII.

### Receta real de t-timms: inspeccionar antes de podar

El repositorio público verificable es [t-timms/ornith-nvfp4](https://github.com/t-timms/ornith-nvfp4). La receta siguiente reproduce la estructura del autor, pero no se ejecutó en este curso y requiere GPU Blackwell/entornos propios:

```sh
git clone https://github.com/t-timms/ornith-nvfp4.git
cd ornith-nvfp4
git rev-parse HEAD                         # registrar el commit que se use
git show --stat --oneline HEAD
sed -n '1,140p' scripts/prune/run_prune.sh
python3 scripts/prune/strip_mtp.py --help
python3 scripts/prune/strip_vision.py --help
sed -n '1,220p' scripts/quantize/quantize_ornith_gptq.py
```

No ejecutar `smoke_ornith.py --help`: ese archivo no define una ayuda CLI, construye un smoke de tres capas y entra directamente en GPU. Se inspecciona con `sed`; el propio código fija `N_EXPERTS_TO_PRUNE=200`, es decir, **256→56 para verificar cableado**, no una poda de producción 50%.

El script real `scripts/prune/run_prune.sh` fija `~/reap-cuda-env/bin/reap`, `~/models/Ornith-1.5-35B-A3B`, dataset `theblackcat102/evol-codealpaca-v1`, semilla 42, ratio `0.50`, backend `bmm`, `--residency cpu_full`, `--batch-size 1`, 64 lotes por categoría y `--no-eval`; invoca `reap prune layerwise` aunque la residencia sea `cpu_full`. No sustituir rutas ni inventar `--compression-ratio 0.2/0.3`: el artefacto publicado y consultado documenta 50% (256→128), no REAP-20/30.

Sólo después de revisar RAM, GPU, commit y checkpoint, y con autorización explícita, el paso de poda del autor es:

```sh
RUN_GPU=1 bash scripts/prune/run_prune.sh
```

El script deja claro que su salida todavía necesita cirugía MTP. La siguiente orden sí tiene una interfaz CLI verificable y hace una comprobación de recarga/forward CPU; usar un directorio de salida nuevo:

```sh
PRUNED="/ruta/al/reap-50"
python3 scripts/prune/strip_mtp.py \
  --checkpoint "$PRUNED" \
  --output-dir "${PRUNED}-mtp-stripped"
```

No usar `--skip-verify` en un resultado real. El script pone `mtp_num_hidden_layers=0`, elimina claves `mtp.*` si existen, copia tokenizer y verifica que el checkpoint recargue y produzca logits. `strip_vision.py` es otra cirugía posterior, deliberada y sólo para texto; quitar la torre visual elimina capacidad, no es una optimización gratuita.

El cuantizador publicado no es una receta universal ni tiene una ayuda CLI propia: lee `ORNITH_PRUNED_SRC`, `GPTQ_DST`, `GPTQ_NUM_CALIB` y `GPTQ_MAX_SEQ` del entorno y ejecuta `llmcompressor`/GPTQ-NVFP4A16. Inspeccionar el archivo antes de ejecutar; exige primero el checkpoint **MTP-stripped** y luego una nueva recarga. El resultado documentado fue en RTX 5070 Ti **SM120**. Una RTX 3090 **SM86** no debe recibir una promesa de kernels NVFP4 nativos por extrapolación: para ella elegir GGUF/Q4 o AWQ sólo con soporte medido del runtime, y comparar calidad/VRAM/latencia. No ejecutar GPU en este capítulo.

Por último, servir el checkpoint sólo cuando haya una ruta reproducible de evaluación. La carpeta `scripts/eval/` del repositorio contiene el harness del autor, pero no se debe inventar un comando a partir del nombre de la carpeta: leer su README/script en el commit fijado y registrar backend, parches, tareas, número de ejemplos y fallos. Los números del README de t-timms son evidencia del autor para ese pipeline, no prueba independiente ni garantía para una 3090.

Para poda, conservar junto al resultado: commit del repositorio, `config.json`, tokenizer/chat template, dataset y semilla de calibración, manifest de tensores eliminados, salida de reload verification y una tabla base/student. No reescribir tensores a mano sin confirmar si los expertos están fusionados (`[n_experts, ...]`) o en módulos separados.

## 12. Checklist de decisión y fuentes vivas

Antes de llamar «mejor» a un Ornith comprimido:

* ¿Se comparó con el mismo Ornith base y revisión?
* ¿La cifra es de la ficha oficial, de un proyecto comunitario o propia?
* ¿Se midió calidad y no sólo carga/VRAM/tokens por segundo?
* ¿Se probó 20/30/50 o se dejó claro que sólo existe 50 publicado?
* ¿Se recargó el checkpoint en el proceso/runtime objetivo?
* ¿Se mantuvieron visión, MTP, tool calling y contexto si forman parte del caso de uso?
* ¿Idiomas y vocabulario tienen regresión explícita?
* ¿«Olvidar» se probó con ataques, no sólo con una negativa?

### Fuentes principales enlazadas en contexto

* [Ornith-1.5-35B-A3B, ficha oficial](https://huggingface.co/ornith-ai/Ornith-1.5-35B-A3B): arquitectura declarada, benchmarks y recetas; limitación: resultados del autor, dependientes de harness.
* [Ornith-1, README oficial](https://github.com/ornith-ai/Ornith-1): familia denso/MoE y serving; limitación: no es un estudio de poda.
* [REAP, Cerebras Research](https://github.com/CerebrasResearch/reap): código y criterio de saliencia; limitación: adaptadores por arquitectura.
* [REAP en llm-compressor](https://docs.vllm.ai/projects/llm-compressor/en/latest/examples/reap_expert_pruning/): controles 25/50% en Qwen/Moonlight; limitación: otras bases.
* [MoE-Pruner](https://arxiv.org/abs/2410.12013): poda y destilación expert-wise; limitación: Mixtral, no Ornith.
* [Transformers quantization overview](https://github.com/huggingface/transformers/blob/main/docs/source/en/quantization/overview.md): métodos/formats y hardware; limitación: matriz de soporte evoluciona.
* [Multilingual Routing](https://openreview.net/pdf?id=ZoZR0x7tTD): rutas multilingües; limitación: no inspecciona Ornith.
* [Vocabulary Trimming](https://aclanthology.org/2023.findings-emnlp.981/): compresión de vocabulario; limitación: modelos/tareas de su estudio.
* [TOFU](https://arxiv.org/abs/2401.06121): evaluación de unlearning; limitación: perfiles sintéticos y no idioma concreto.
* [t-timms/ornith-nvfp4](https://github.com/t-timms/ornith-nvfp4): artefacto comunitario Ornith REAP-50; limitación: un autor, hardware y parches específicos, sin 20/30 publicado en el README consultado.
* [bartowski Ornith-1.5-9B-Q4_K_L](https://huggingface.co/bartowski/Ornith-1.5-9B-GGUF/blob/main/Ornith-1.5-9B-Q4_K_L.gguf): distribución GGUF comunitaria exacta; limitación: no es la distribución oficial y no se asumió equivalencia con Q4_K_M.
