# Instrucciones para el agente: Natural Language Autoencoders: examina activaciones con texto

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/kitft/natural_language_autoencoders (licencia Apache-2.0)
- Guía completa: https://lab.wisd.ai/hub/natural-language-autoencoders

---

## 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

### Paso 1: prepara la receta de inferencia

Abre el [README](https://github.com/kitft/natural_language_autoencoders) y la [guía de inferencia](https://github.com/kitft/natural_language_autoencoders/blob/HEAD/docs/inference.md). Comprueba Git y descarga el código:

```bash
git clone https://github.com/kitft/natural_language_autoencoders.git
cd natural_language_autoencoders
```

Trabaja en esa raíz, en Linux con GPU NVIDIA y CUDA compatibles con SGLang; esta receta usa CUDA y no es una ruta de CPU/macOS. Empieza con el modelo guardado (checkpoint) de Qwen del ejemplo, sin mezclarlo con parámetros de Gemma o Llama.

### Paso 2: instala las dependencias documentadas

Comprueba que tienes Python ≥3.10 y uv. Desde la raíz del repositorio, crea y activa un entorno antes de instalar. Esta preparación completa la receta según la [documentación de uv](https://docs.astral.sh/uv/pip/environments/); en macOS o Linux:

```bash
uv venv
source .venv/bin/activate
```

Comprueba que el intérprete del entorno cumple el mínimo antes de continuar. El README indica:

```bash
uv pip install "torch<2.11" transformers safetensors httpx orjson pyyaml numpy
uv pip install "sglang[all]>=0.5.6"
```

La [guía de preparación](https://github.com/kitft/natural_language_autoencoders/blob/main/docs/setup.md) advierte que Torch sin fijar puede descargar CUDA 13 y entrar en conflicto con las ruedas CUDA 12 de `sgl-kernel`; se aplica aquí su restricción `torch<2.11`.

Si vas a leer activaciones Parquet, el propio `nla_inference.py` documenta además:

```bash
uv pip install pyarrow
```

### Paso 3: sirve el verbalizador

```bash
python -m sglang.launch_server --model-path kitft/nla-qwen2.5-7b-L20-av     --port 30000 --disable-radix-cache &
```

Espera a que termine de cargar. Para una primera comprobación completa del cliente, el README admite omitir Parquet y usar un vector aleatorio:

```bash
python nla_inference.py kitft/nla-qwen2.5-7b-L20-av --sglang-url http://localhost:30000
```

Debe devolver una descripción AV. Esta salida prueba la ruta de inferencia, no la fidelidad de una explicación sobre texto real. Para activaciones reales, el siguiente paso crea el archivo.

### Paso 4: procesa tus activaciones

Guarda el bloque mínimo de activaciones Qwen del [README](https://github.com/kitft/natural_language_autoencoders#quick-start) en `crear_activaciones.py`. En su carga de modelo, para evitar la dependencia implícita de Accelerate que introduce `device_map="cuda"`, conserva `torch_dtype=torch.bfloat16` y mueve el modelo con `.to("cuda")`. El script completo adaptado es:

```python
import torch
import pyarrow as pa
import pyarrow.parquet as pq
from transformers import AutoModelForCausalLM, AutoTokenizer

tok = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-7B-Instruct")
m = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen2.5-7B-Instruct", torch_dtype=torch.bfloat16
).to("cuda")
ids = tok("El zorro salta sobre el perro.", return_tensors="pt").to("cuda")
with torch.no_grad():
    hs = m(**ids, output_hidden_states=True).hidden_states[20][0]
pq.write_table(pa.table({"activation_vector": hs.float().cpu().tolist()}), "demo.parquet")
```

Ejecuta `python crear_activaciones.py` desde esa raíz. Debe crear `demo.parquet` con vectores de dimensión 3584. La extracción necesita memoria de GPU adicional al servidor AV; dimensiona para ambos o usa equipos separados. Después:

```bash
python nla_inference.py kitft/nla-qwen2.5-7b-L20-av     --sglang-url http://localhost:30000     --parquet demo.parquet
```

## Comprobación

Comprueba que el archivo contiene la columna `activation_vector` y vectores de la dimensión adecuada. Revisa las descripciones devueltas y compáralas con los ejemplos del repo. El error de reconstrucción requiere la parte AR; no presentes solo la salida AV como validación del ciclo completo.

## Si algo falla

Sigue los diagnósticos de `docs/inference.md`: plantilla exacta, metadatos del checkpoint, escala de inyección y posición del token. Si falta PyArrow, instala la dependencia documentada arriba. No ajustes dimensiones a mano para forzar un checkpoint incompatible.