Atlas integrado · v4.7 · 23 septiembre 2026
Manual de réplica y resultados históricos
Los ejemplos y evidencias están en el ZIP. Los enlaces al sitio requieren conexión; para navegación completa local usa Atlas offline.
Reinstalar ia-lab desde cero
Este manual recupera la instalación del laboratorio y explica cómo reconstruirla en una máquina nueva. El inventario se volvió a leer el 23 de septiembre de 2026. Los comandos de instalación son para esa réplica: ejecutarlos sobre ia-lab activo interrumpiría servicios o ocuparía sus GPUs. La comprobación de esta entrega consistió en lectura del host, recuperación de scripts, pruebas CPU y canarios pequeños; no se reinstaló el sistema operativo ni se recompilaron los motores.
Descarga el kit de réplica. Contiene este manual, bibliotecas fijadas, scripts históricos, ejemplos nuevos y manifiesto. Dentro del kit, evidence/ conserva la procedencia; examples/ contiene utilidades del tutorial. Los scripts históricos que reinician motores están identificados como tales. Lee cada etapa antes de ejecutarla.
- Reinstalar ia-lab desde cero
- 1. Qué máquina construimos y qué hay que preparar
- 2. Paquetes base y acceso remoto
- 3. Driver NVIDIA: lo instalado y la comprobación
- 4. CUDA 13 y NCCL: tres versiones diferentes
- 5. Docker y acceso de los contenedores a las GPU
- 6. Recuperar el fork y entender sus cambios
- 7. llama.cpp: imagen exacta y compilación propia
- 8. Descargar modelos y comprobar que son los correctos
- 9. Lanzar llama.cpp: primero pequeño, luego el perfil de GPU 0
- 10. Instalar vLLM con su entorno y plugin
- 11. Instalar SGLang y recuperar el perfil que sí pasó las pruebas pequeñas
- 12. Cómo creamos las variantes INT8 y texto
- 13. Repetir los tests: calidad, contexto, concurrencia y velocidad
- 14. Qué resultados conservamos y cuáles no conviene promocionar
- 15. Panel, perfiles, mantenimiento y restauración
El catálogo de perfiles y resultados reúne las corridas P1–P4 y matrices históricas. Buscar archivos y rutas distingue servidor, ZIP y descarga directa. Descargas y restauración del Atlas explica cómo conservar también esta web.
1. Qué máquina construimos y qué hay que preparar
ia-lab es una máquina virtual KVM, no un Linux bare-metal según la inspección del invitado. Se observan Ubuntu 24.04.4 LTS, kernel 6.8.0-139-generic, 24 CPU virtuales (modelo expuesto Xeon E5-2680 v4), 188 GiB de RAM utilizable, sin swap y disco de 850 GiB. Aparecen cuatro RTX 3090, cada una de 24 GiB, accesibles mediante el driver NVIDIA.
Antes de reinstalar, conserva fuera del disco de destino: imágenes propias, GGUF, checkpoints originales y cuantizados, bench/ornith, revisiones Git, configuraciones del panel y los locks. Las claves se respaldan en almacenamiento privado; no forman parte de este sitio ni del ZIP. La web está en otro host, bajo /srv/ornith-atlas-v3/; restaurar ia-lab no restaura automáticamente Atlas. Ahora puedes conservarla con el respaldo web restaurable, separado del kit de máquina.
Para recrear el invitado: crea una VM x86-64 con firmware y passthrough de GPU adecuados a tu hipervisor, instala Ubuntu Server 24.04 LTS en su disco nuevo, crea el usuario lab, habilita OpenSSH y termina las actualizaciones del sistema. Conserva al menos el almacenamiento y la RAM que demande tu selección de modelos; 4×24 GiB no se convierten en un único bloque automático de 96 GiB. Hay que distribuir explícitamente los pesos o las tareas.
Hipervisor recuperado y verificado: pve-x99, VM 101 (ia-lab). Se comparó el UUID SMBIOS de qm config 101 con el UUID leído dentro del invitado: coinciden. No se cambió ninguna VM. La configuración sanitizada y la ayuda instalada de Proxmox están en evidence/proxmox/; se excluyeron contraseña cloud-init, clave SSH, MAC e identificadores personales.
cat /etc/os-release
uname -r
systemd-detect-virt
lscpu
free -h
lsblk -o NAME,SIZE,TYPE,MOUNTPOINTS
lspci -nn | grep -i nvidia
1.1 La máquina física y la VM que realmente tenemos
| Capa | Configuración observada el 23-09-2026 |
|---|---|
| Placa física | HUANANZHI X99-F8D PLUS |
| CPU física | Dos Xeon E5-2680 v4, 14 núcleos por socket, 56 hilos en total |
| Hipervisor | Proxmox VE 9.2.11; kernel activo 7.0.14-15-pve |
| VM | ID 101, q35, SeaBIOS, CPU host, 1 socket × 24 cores, NUMA activo |
| Memoria VM | 196608 MiB configurados; balloon desactivado (0) |
| Disco VM | 850 GiB, VirtIO SCSI PCI, storage vg-ia-lvmthin |
| Storage físico | NVMe del sistema de 476.9 GiB; segundo NVMe de 931.5 GiB con VG vg-ia y thinpool thinpool de 900 GiB |
| Red | Adaptador VirtIO conectado a vmbr0; dirección del invitado administrada por cloud-init |
| Consola y agente | serial0: socket, vga: serial0, QEMU Guest Agent habilitado |
| Cloud-init actual | ide2 contiene vm-101-cloudinit; usuario lab; invitado informa DataSourceNoCloud [seed=/dev/sr0], sin errores |
La VM conserva un volumen EFI sin usar, pero el firmware activo es SeaBIOS. No cambies a OVMF ni conectes ese volumen porque su nombre parezca indicar la configuración correcta. El historial de creación y la configuración activa no son lo mismo.
En el host aún existen ubuntu-24.04.3-live-server-amd64.iso y seed-ia.iso. Su presencia no demuestra cuál fue la imagen de arranque original. No se exportó seed-ia.iso: puede contener configuración privada. La receta siguiente reconstruye una instalación equivalente desde ISO; no se presenta como una transcripción exacta del instalador original.
1.2 Preparar un Proxmox nuevo, sin tocar el que está trabajando
- Respalda la VM y tus modelos fuera de los discos que vayas a reinstalar. Prueba que el respaldo puede leerse. Instalar Proxmox sobre un disco borra su contenido: identifica el dispositivo por modelo y número de serie, no sólo por
nvme0n1, que puede cambiar. - Instala Proxmox VE en el disco destinado al sistema. Configura su administración y verifica que puedes entrar a la consola web y por SSH antes de continuar. La placa debe tener virtualización Intel y VT-d/IOMMU habilitados; no recuperamos fotos de sus menús BIOS para fingir sus nombres exactos.
- Crea un puente
vmbr0sobre la interfaz de red física de esa máquina. La interfaz observada se llamanic0; una réplica puede llamarse distinto. No dupliques la IP depve-x99ni la IP del invitado en la misma red. - En Disks → LVM / LVM-Thin prepara un disco nuevo y vacío para VG
vg-iay thinpoolthinpool. Añádelo como storagevg-ia-lvmthin. El proceso es destructivo para el disco elegido: no formatees el NVMe actual para seguir este tutorial. En una réplica menor puedes usar otro storage y un disco virtual menor si tus modelos caben. - Verifica
pvesm status,lsblky el espacio real del thinpool. Una asignación thin no reserva todo el espacio físico; deja margen para crecimiento y evita llenarlo.
La ayuda consultada fue la instalada en Proxmox (qm help create, qm help set y qm help importdisk); está incluida completa en el kit. Los enlaces oficiales de PCI passthrough y Cloud-init devolvieron 403 al lector web en esta revisión; no se atribuye a esas páginas una lectura que no ocurrió.
1.3 IOMMU y VFIO: separar host e invitado
En el hipervisor, las ocho funciones PCI de las cuatro GPU usan vfio-pci. Allí no se carga el driver NVIDIA para inferencia. Dentro de Ubuntu ia-lab, sí se instala el driver NVIDIA de la sección 3. Confundir ambas capas rompe el passthrough.
El arranque observado del host usa intel_iommu=on iommu=pt. En una réplica que arranque con GRUB, conserva las opciones existentes y añade esas dos en GRUB_CMDLINE_LINUX_DEFAULT de /etc/default/grub; después ejecuta update-grub. Si tu nueva instalación usa otro cargador, identifica primero su método de actualización: no apliques instrucciones de GRUB a ciegas.
Contenido de referencia para una réplica con las mismas RTX 3090:
# /etc/modules-load.d/vfio.conf
vfio
vfio_iommu_type1
vfio_pci
# /etc/modprobe.d/vfio.conf — IDs GPU y audio RTX 3090 observados
options vfio-pci ids=10de:2204,10de:1aef disable_vga=1
softdep nouveau pre: vfio-pci
# /etc/modprobe.d/blacklist-nvidia.conf — sólo en el host de passthrough
blacklist nouveau
blacklist nvidia
blacklist nvidiafb
blacklist nvidia_drm
El archivo real contiene además IDs de otras tarjetas (2487/228b/2503/228e); se conserva como evidencia, pero no hace falta copiarlos a una réplica de cuatro 3090. Vincular por ID afecta todas las tarjetas con ese ID en el host. Conserva otra vía de consola si tu pantalla depende de una de ellas. No uses ACS override para aparentar aislamiento que el hardware no da.
Sólo en el host nuevo, después de revisar estos archivos, ejecuta update-initramfs -u -k all y reinicia en una ventana de mantenimiento. Revisa:
cat /proc/cmdline
find /sys/kernel/iommu_groups -type l
lspci -nnk -s 05:00
lspci -nnk -s 82:00
lspci -nnk -s 83:00
lspci -nnk -s 84:00
| GPU por PCI del host | Funciones pasadas juntas | Grupo IOMMU observado |
|---|---|---|
0000:05:00 |
.0 GPU + .1 audio |
92 |
0000:82:00 |
.0 GPU + .1 audio |
5 |
0000:83:00 |
.0 GPU + .1 audio |
6 |
0000:84:00 |
.0 GPU + .1 audio |
7 |
Estos BDF y grupos son los de pve-x99, no valores universales. El índice GPU 0 dentro de Ubuntu no demuestra por sí solo a qué ranura física corresponde. Usa UUID de NVIDIA dentro del invitado y BDF del hipervisor para mantener ambas identidades separadas.
1.4 Crear el invitado desde una ISO, paso por paso
Usa un VMID nuevo, no 101, y una red/IP que no duplique ia-lab. En Ubuntu Releases elige la ISO Server AMD64 de la versión que fijes, guarda su nombre, checksum y firma. Verifica el checksum contra el manifiesto oficial autenticado antes de importarla al storage local. La ISO histórica inventariada es 24.04.3; el sistema invitado observado es 24.04.4 después de actualizaciones. Una imagen nueva debe quedar registrada como nueva, no como idéntica.
En la interfaz de Proxmox: Create VM → nombre ia-lab-replica → ISO Ubuntu Server → System q35/SeaBIOS → SCSI Controller VirtIO SCSI → disco nuevo en vg-ia-lvmthin → CPU host, 1 socket/24 cores → memoria 196608 MiB, balloon desactivado → VirtIO/vmbr0. Si la réplica no tiene esos recursos, comienza menor y no uses luego los perfiles de contexto completo como si la geometría fuera igual.
Equivalente CLI para crear sólo la VM nueva y su disco vacío, después de cargar la ISO; no se ejecutó en esta entrega:
# En Proxmox nuevo. Define explícitamente estos valores antes.
: "${REPLICA_VMID:?VMID nuevo y libre, nunca 101}"
: "${REPLICA_STORAGE:?Storage existente, por ejemplo vg-ia-lvmthin}"
: "${REPLICA_ISO_VOLUME:?Volumen ISO cargado, local:iso/NOMBRE.iso}"
case "$REPLICA_VMID" in ''|*[!0-9]*) exit 1;; esac
[ "$REPLICA_VMID" != 101 ] || exit 1
if qm status "$REPLICA_VMID" >/dev/null 2>&1; then
echo 'VMID ocupado: no se modifica'; exit 1
fi
qm create "$REPLICA_VMID" --name ia-lab-replica --machine q35 \
--bios seabios --cpu host --sockets 1 --cores 24 --numa 1 \
--memory 196608 --balloon 0 --hotplug 0 --agent enabled=1 \
--scsihw virtio-scsi-pci --scsi0 "${REPLICA_STORAGE}:850" \
--net0 virtio,bridge=vmbr0 --ide2 "${REPLICA_ISO_VOLUME},media=cdrom" \
--serial0 socket --boot 'order=ide2;scsi0'
qm config "$REPLICA_VMID"
No se pasa ninguna GPU en esa orden. Arranca desde la consola web, instala Ubuntu en el disco virtual nuevo, elige usuario lab y habilita OpenSSH. Al terminar, retira la ISO y deja scsi0 primero en el orden de arranque. Instala qemu-guest-agent, comprueba su servicio y verifica SSH. La consola de instalación predeterminada se conserva para este primer paso; cambia a vga: serial0 sólo después de configurar/verificar la consola serie dentro de Ubuntu.
Para reproducir además cloud-init en una instalación desde ISO, configura explícitamente cloud-init/NoCloud y prueba la creación del usuario y la red; agregar un CD cloud-init por sí solo no prueba que el sistema lo consuma. Como alternativa existen imágenes cloud de Ubuntu: se importan con qm disk import, se conecta el disco importado como scsi0, se añade el disco Cloud-init y se configura una clave pública propia. Comprueba el firmware requerido por esa imagen: no impongas SeaBIOS si declara sólo UEFI. No se afirma que esa alternativa sea la imagen original de 101.
1.5 Conectar las cuatro GPU y validar antes de instalar modelos
Con la réplica apagada, en Hardware → Add → PCI Device elige cada BDF verificado, marca All Functions, PCI Express y desactiva ROM-Bar para reproducir estos valores:
hostpci2: 0000:05:00,pcie=1,rombar=0
hostpci3: 0000:82:00,pcie=1,rombar=0
hostpci4: 0000:83:00,pcie=1,rombar=0
hostpci5: 0000:84:00,pcie=1,rombar=0
Son líneas de referencia de 101, no órdenes para pegar en producción. No asignes una GPU que está conectada a otra VM activa: una réplica simultánea necesita tarjetas libres o un host diferente. No habilites “Primary GPU” para este servidor headless por costumbre. Comprueba que cada grupo contiene sólo las funciones esperadas antes de arrancar.
Dentro del nuevo Ubuntu, lspci -nn debe mostrar cuatro GPU y sus funciones de audio. Después de instalar el driver, nvidia-smi debe mostrar cuatro 3090. Comprueba también nvidia-smi topo -m y nvidia-smi topo -p2p r: cuatro GPU visibles no prueban P2P ni garantizan rendimiento multi-GPU. Sólo entonces continúa con paquetes, CUDA y motores.
Límite restante: ya recuperamos VMID, hipervisor, placa, CPU, discos, firmware, cloud-init activo, VFIO y grupos PCI. No se recreó la VM ni se probó restauración completa; tampoco se recuperó el medio/seed original con su procedencia criptográfica. Esas diferencias quedan explícitas, no se sustituyen por recuerdos inventados.
2. Paquetes base y acceso remoto
En la máquina nueva, después de entrar por SSH como lab:
sudo apt-get update
sudo apt-get install -y build-essential git git-lfs cmake ninja-build \
python3 python3-venv python3-pip curl wget jq unzip zip tmux \
ca-certificates gnupg pkg-config libssl-dev libcurl4-openssl-dev \
linux-headers-$(uname -r)
git lfs install
mkdir -p /home/lab/models /home/lab/venvs /home/lab/bench/ornith
Git guarda el código; Git LFS/Hugging Face gestiona archivos grandes; CMake y Ninja construyen llama.cpp; los entornos virtuales aíslan dependencias de Python. El paquete tmux mantiene sesiones vivas cuando se desconecta SSH. El archivo evidence/observed/host-packages.txt conserva las versiones observadas de paquetes del sistema, no sólo los nombres de esta lista.
Accede por la red privada que hayas configurado. En el cliente puedes hacer un túnel ssh -L 18120:127.0.0.1:8120 lab@HOST_IA_LAB y abrir http://127.0.0.1:18120. Sustituye HOST_IA_LAB por la dirección de tu réplica. No copies las UUID de GPU de otra máquina como si fueran universales.
3. Driver NVIDIA: lo instalado y la comprobación
El historial de APT conserva apt-get install -y nvidia-driver-580. El paquete cargado al inspeccionar era 580.173.02-0ubuntu0.24.04.1; nvidia-smi informa 580.173.02. Es el driver propietario nvidia-dkms-580 observado, no una inferencia basada en el nombre de CUDA.
# Sólo en la réplica; revisar las versiones disponibles primero.
apt-cache policy nvidia-driver-580
sudo apt-get install -y nvidia-driver-580
sudo reboot
Después de reconectar:
nvidia-smi
nvidia-smi --query-gpu=index,name,uuid,driver_version,memory.total --format=csv
dkms status
lsmod | grep nvidia
Éxito: aparecen las cuatro 3090 y no hay un error de comunicación con el driver. Si Secure Boot rechaza el módulo, resuelve la firma/inscripción MOK según la instalación de Ubuntu; reinstalar repetidamente CUDA no arregla un módulo bloqueado. Para una reproducción estricta usa las versiones guardadas si todavía están disponibles; un driver posterior compatible requiere repetir las pruebas. Guía oficial de drivers de Ubuntu.
4. CUDA 13 y NCCL: tres versiones diferentes
En ia-lab sí existe /usr/local/cuda-13.0. El compilador devuelve CUDA 13.0 / nvcc 13.0.88 y APT registra cuda-toolkit-13-0=13.0.3-1. El historial también muestra una instalación inicial del paquete de Ubuntu nvidia-cuda-toolkit, seguida de su retirada al pasar a CUDA 13. En una instalación limpia se evita ese rodeo y se instala el toolkit seleccionado directamente.
No confundas: la versión máxima que muestra nvidia-smi corresponde al driver; nvcc --version corresponde al compilador del host; torch.version.cuda corresponde al runtime con el que se construyó la rueda de PyTorch. Pueden ser distintas y convivir.
mkdir -p /home/lab/installers
cd /home/lab/installers
wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2404/x86_64/cuda-keyring_1.1-1_all.deb
sudo dpkg -i cuda-keyring_1.1-1_all.deb
sudo apt-get update
apt-cache policy cuda-toolkit-13-0
sudo apt-get install -y cuda-toolkit-13-0
export PATH=/usr/local/cuda-13.0/bin:$PATH
nvcc --version
Añade la línea export PATH=... a la configuración de tu shell si quieres usar nvcc sin ruta absoluta. No hace falta reemplazar globalmente todas las librerías de los entornos Python. La documentación de NVIDIA describe la instalación mediante repositorio y las comprobaciones; aquí fijamos la familia 13.0 para corresponder al laboratorio, en vez de seguir silenciosamente la última versión. CUDA Linux.
Para la compilación nativa, se instaló NCCL 2.28.9-1+cuda13.0:
apt-cache policy libnccl2 libnccl-dev
sudo apt-get install -y libnccl2=2.28.9-1+cuda13.0 libnccl-dev=2.28.9-1+cuda13.0
dpkg-query -W libnccl2 libnccl-dev
Si APT ya no ofrece esa versión, conserva el resultado y decide una nueva combinación verificable; no continúes etiquetándola como la misma instalación. La imagen Docker histórica usa su propio runtime y su NCCL; en sus capas aparece 2.28.3-1+cuda13.0. El NCCL del host no describe automáticamente el del contenedor.
5. Docker y acceso de los contenedores a las GPU
Se observan Docker CE 29.8.0, Containerd 2.3.4 y NVIDIA Container Toolkit 1.20.0. Docker no recibe CUDA por instalar PyTorch: requiere el runtime NVIDIA.
En una máquina nueva Ubuntu 24.04 x86-64, añade ambos repositorios. Este paso escribe archivos de configuración de APT; no se ejecutó en el laboratorio activo:
sudo install -d -m 0755 /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
printf '%s\n' 'deb [arch=amd64 signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu noble stable' | sudo tee /etc/apt/sources.list.d/docker.list
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /etc/apt/keyrings/nvidia-container-toolkit.gpg
curl -fsSL https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | sed 's#deb https://#deb [signed-by=/etc/apt/keyrings/nvidia-container-toolkit.gpg] https://#g' | sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list
sudo apt-get update
apt-cache policy docker-ce nvidia-container-toolkit
Luego instala/configura:
sudo apt-get install -y docker-ce docker-ce-cli containerd.io \
docker-buildx-plugin docker-compose-plugin
sudo apt-get install -y nvidia-container-toolkit
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker
sudo usermod -aG docker lab
Cierra y abre la sesión para que se aplique el grupo. Pertenecer a docker da control administrativo del host; usa sólo tu cuenta administradora. Las instrucciones completas de repositorio están en Docker Ubuntu y NVIDIA Container Toolkit.
docker version
docker run --rm --gpus all nvidia/cuda:13.0.2-runtime-ubuntu24.04 nvidia-smi
Éxito: el contenedor ve las GPU. Si el host las ve y Docker no, revisa el runtime de Docker. Si ninguno las ve, vuelve a driver/passthrough. El reinicio de Docker corresponde a la instalación de la réplica: no lo ejecutes durante cargas activas.
6. Recuperar el fork y entender sus cambios
Se encontró el checkout real en /opt/llama.cpp, limpio, rama master, remoto https://github.com/lomeliDev/llama.cpp.git, commit 82490b9d43954a82d659890a2d6c74dd68cf5653.
mkdir -p /home/lab/src
cd /home/lab/src
git clone https://github.com/lomeliDev/llama.cpp.git
cd llama.cpp
git checkout --detach 82490b9d43954a82d659890a2d6c74dd68cf5653
git status --short
git show --stat HEAD
Ese commit añade un return true al terminar normalmente el stream en tools/server/server-http.cpp. El propósito es permitir reutilizar la conexión HTTP después de sink.done(); devolver false se interpreta como una cancelación por el servidor HTTP subyacente. El mensaje del commit describe pruebas de reutilización, pero sus cifras no son un benchmark de latencia repetido en esta entrega. El parche completo está en evidence/observed/fork-sse.patch.
FlashAttention con todos los tipos de cuantización y NCCL son además opciones de compilación. No todo lo que aparece en el nombre nccl-sse-faall es un plugin Python. No vuelvas a aplicar el parche SSE después de hacer checkout del commit: ya está incluido.
7. llama.cpp: imagen exacta y compilación propia
La vía más fiel para ejecutar el binario histórico es conservar o recuperar la imagen por digest:
docker pull lomelidev/llama.cpp@sha256:437ae974458c543cfa8c3566de5146e2b253d0e17ed8bf8fcfd64c250cc9e5bc
docker image inspect lomelidev/llama.cpp@sha256:437ae974458c543cfa8c3566de5146e2b253d0e17ed8bf8fcfd64c250cc9e5bc
Etiqueta histórica: lomelidev/llama.cpp:cu130-nccl-sse-faall-10974. Si el registro requiere autenticación, haz docker login desde tu terminal privada. También puedes guardar la imagen existente con docker save -o llama-cu130-faall.tar IMAGEN y restaurarla con docker load -i llama-cu130-faall.tar. El tar no se incluye en el kit por tamaño.
Para construir un nuevo binario nativo desde ese código:
cd /home/lab/src/llama.cpp
cmake -S . -B build-replica -DCMAKE_BUILD_TYPE=Release \
-DGGML_CUDA=ON -DCMAKE_CUDA_COMPILER=/usr/local/cuda-13.0/bin/nvcc \
-DCMAKE_CUDA_ARCHITECTURES=86 -DGGML_CUDA_FA=ON \
-DGGML_CUDA_FA_QUANTS=all -DGGML_CUDA_GRAPHS=ON \
-DGGML_CUDA_NCCL=ON -DGGML_NATIVE=ON
cmake --build build-replica -j 8 --target llama-server llama-cli llama-quantize
build-replica/bin/llama-server --version
build-replica/bin/llama-server --help
Arquitectura 86 corresponde a las RTX 3090. Para otra GPU cambia este objetivo según su compute capability. El CMakeCache recuperado confirma esas opciones, incluyendo GGML_CUDA_FA_QUANTS=all. El nombre antiguo GGML_CUDA_FA_ALL_QUANTS está deprecado en ese código. -j 8 reduce la presión de RAM al compilar; no mide rendimiento de inferencia.
El log histórico de Docker registra bases CUDA 13.0.2-devel/runtime-ubuntu24.04, Node 24 para la web, GCC/G++ 14 y build con GGML_NATIVE=OFF, backends dinámicos y variantes de CPU. El kit incluye el Dockerfile upstream recuperado y examples/prepare_dockerfile.py, que añade los flags FA/NCCL observados y fija CUDA 13.0.2:
python3 /RUTA/AL/KIT/examples/prepare_dockerfile.py /home/lab/src/llama.cpp
cd /home/lab/src/llama.cpp
docker build -f cuda-faall-replica.Dockerfile --target server \
--build-arg CUDA_DOCKER_ARCH=86 --build-arg APP_VERSION=10974-faall \
--build-arg APP_REVISION=82490b9d43954a82d659890a2d6c74dd68cf5653 \
-t ornith-llama-replica:cu130-faall .
Esta receta reconstruida no promete el mismo digest: no se conservó el Dockerfile temporal original y los repositorios APT/base tags pueden cambiar. La conversación anterior permitió recuperar su ruta (/tmp/llama-cuda-faall.Dockerfile), la transformación del fuente y el comando de build, pero no el archivo completo ni su hash. Allí se usaba el nombre antiguo GGML_CUDA_FA_ALL_QUANTS; el helper usa el efectivo GGML_CUDA_FA_QUANTS=all contrastado con CMakeCache. El digest anterior conserva la identidad de la imagen que sí estaba en uso. Build de llama.cpp.
8. Descargar modelos y comprobar que son los correctos
Instala la CLI en un entorno aislado:
python3 -m venv /home/lab/venvs/hub
/home/lab/venvs/hub/bin/pip install huggingface_hub
/home/lab/venvs/hub/bin/hf download --help
El original HF registrado en nuestros scripts:
/home/lab/venvs/hub/bin/hf download ornith-ai/Ornith-1.5-9B \
--revision 489cb97981b8654bcfcf30ce1f94ed1b62e07b53 \
--local-dir /home/lab/models/Ornith-1.5-9B-original
Para llama.cpp, el archivo exacto por nombre existe en el repositorio comunitario de Bartowski:
/home/lab/venvs/hub/bin/hf download bartowski/Ornith-1.5-9B-GGUF \
Ornith-1.5-9B-Q4_K_L.gguf \
--local-dir /home/lab/models/ornith15-9b
sha256sum /home/lab/models/ornith15-9b/Ornith-1.5-9B-Q4_K_L.gguf
El hash del GGUF leído de nuestro disco coincide con el publicado: SHA-256 545bc9901b63c09765e59a594dc782e2de5ed10b8f6095fa957d9a05a55e6b16. Compara el resultado; si cambia, detente y registra una nueva revisión. Fija también el commit HF en tus futuras descargas. Q4_K_L no debe sustituirse por Q4_K_M sin cambiar el perfil y repetir calidad. Archivo GGUF.
Los archivos originales HF sirven para adaptar/entrenar; el GGUF sirve para el motor de inferencia. Conserva tokenizer, plantilla, configuración y licencia. La CLI de Hugging Face permite fijar revisiones; usa HF_TOKEN sólo en tu entorno privado si un repositorio exige autenticación.
9. Lanzar llama.cpp: primero pequeño, luego el perfil de GPU 0
Antes de lanzar en una GPU, mira sus UUID, memoria utilizada y procesos. El tutorial examples/launch_llama.sh exige una GPU libre y un puerto libre; no mata contenedores existentes. En la réplica:
nvidia-smi --query-gpu=index,uuid,memory.used --format=csv
export ATLAS_GPU_UUID=GPU_UUID_DE_TU_REPLICA
export ATLAS_MODEL_DIR=/home/lab/models/ornith15-9b
bash /RUTA/AL/KIT/examples/launch_llama.sh small
Prueba inicial: 8192 tokens y un slot. Comprueba logs, salud y modelo servido:
docker logs --tail 80 ornith-replica
curl --fail http://127.0.0.1:8120/health
curl --fail http://127.0.0.1:8120/v1/models
curl --fail http://127.0.0.1:8120/v1/chat/completions \
-H 'Content-Type: application/json' \
-d '{"model":"ornith-local","messages":[{"role":"user","content":"Responde CANARIO_OK"}],"max_tokens":128,"temperature":0}'
Espera contenido final útil. Un HTTP 200 con finish_reason=length y contenido vacío no equivale a un canario correcto. El caso histórico con 32 tokens se corrigió al ampliar el presupuesto a 128; no probó incapacidad general del modelo.
La captura de GPU 0 del 23-09-2026 usa (no es el catálogo completo de perfiles): -ngl 999 -fa on -ctk q4_0 -ctv q4_0 -c 786432 -np 3 --no-kv-unified --cont-batching --no-mmproj --n-predict 4096 -b 4096 -ub 2048 --cache-ram 32768 --cache-prompt --ctx-checkpoints 4 --jinja --metrics. Esa configuración asigna contexto total para tres slots, 262144 por slot según el esquema usado, pero no prueba tres generaciones exitosas de contexto máximo.
El contenedor actual ornith monta /home/lab/models/ornith15-9b como sólo lectura, y Docker publica 0.0.0.0:8120 e IPv6. Eso no demuestra accesibilidad por Internet: depende de la red y firewall. El launcher nuevo usa localhost para una réplica privada. La versión anterior del manual decía incorrectamente que el mapeo actual era sólo localhost; queda corregido.
10. Instalar vLLM con su entorno y plugin
La instalación existente está en /home/lab/venvs/vllm. Versiones leídas: vLLM 0.29.0, PyTorch 2.13.0+cu130, Transformers 5.17.0, bitsandbytes 0.50.2, vllm-bnb-plugin 0.0.3, compressed-tensors 0.17.0 y FlashInfer 0.6.18. pip check pasó al inspeccionar. El lock completo está en evidence/locks/vllm-freeze.txt.
python3 -m venv /home/lab/venvs/vllm
/home/lab/venvs/vllm/bin/pip install --upgrade pip
/home/lab/venvs/vllm/bin/pip install torch==2.13.0+cu130 \
--index-url https://download.pytorch.org/whl/cu130
/home/lab/venvs/vllm/bin/pip install vllm==0.29.0 transformers==5.17.0 \
bitsandbytes==0.50.2 vllm-bnb-plugin==0.0.3
/home/lab/venvs/vllm/bin/pip check
/home/lab/venvs/vllm/bin/python -c 'import torch,vllm; print(torch.__version__,torch.version.cuda,vllm.__version__)'
Esta secuencia es un bootstrap con versiones principales, no una reinstalación ya validada. Para restaurar las dependencias transitivas, usa el lock después de instalar la rueda PyTorch CUDA anterior:
/home/lab/venvs/vllm/bin/pip install --dry-run -r /RUTA/AL/KIT/evidence/locks/vllm-freeze.txt
# Si el resolver encuentra todas las versiones, en la réplica:
/home/lab/venvs/vllm/bin/pip install -r /RUTA/AL/KIT/evidence/locks/vllm-freeze.txt
/home/lab/venvs/vllm/bin/pip check
/home/lab/venvs/vllm/bin/pip freeze > /home/lab/vllm-replica-freeze.txt
diff -u /RUTA/AL/KIT/evidence/locks/vllm-freeze.txt /home/lab/vllm-replica-freeze.txt
Si una rueda histórica ya no está disponible, necesitas tu wheelhouse/respaldo o una combinación nueva explícitamente evaluada. No rebajes silenciosamente versiones para aparentar una reproducción exacta. Instalación vLLM y plugin BitsAndBytes.
El perfil inicial histórico utilizó el original BF16 con carga NF4 BitsAndBytes, GPU física 2, puerto 8140, contexto 8192, dos secuencias y eager. Sus scripts historical/vllm/setup.sh, start.sh y service.sh se incluyen. En una réplica, cambia la UUID fija antes de lanzarlos; lee start.sh para ver todos los flags.
El kit trae un launcher nuevo que conserva esos argumentos pero exige la UUID de tu réplica y rechaza GPU/puerto ocupados. No necesita los wrappers que reinician procesos:
export ATLAS_GPU_UUID=GPU_UUID_LIBRE_DE_TU_REPLICA
export ATLAS_MODEL_DIR=/home/lab/models/Ornith-1.5-9B-original
bash /RUTA/AL/KIT/examples/launch_engine.sh vllm-nf4
# En otra terminal, cuando termine la carga:
python3 /RUTA/AL/KIT/examples/canary.py --base http://127.0.0.1:8140/v1 \
--model ornith-vllm --out canario-vllm-replica.json
Estado actual distinto: el proceso observado es un vLLM nativo activo en GPU 2, puerto 8122, modelo /home/lab/models/Ornith-1.5-9B-AWQ-W4A16, nombre Ornith-1.5-9B-Sohail-AWQ-Q4KV-256K, KV int4_per_token_head, contexto configurado 262144, tres secuencias y memoria 0.68. El comando está en evidence/observed/vllm-process.txt. No corresponde al antiguo perfil NF4/8140 y no debe duplicarse en la misma GPU.
La configuración actual apunta a pesos comunitarios distintos. El manual no descarga ni sobrescribe esos pesos. Para repetir ese perfil, registra primero su repositorio, revisión y checksum; después el comando observado. Para aprender el motor desde cero, empieza por el original fijado y el perfil 8K. Un servicio activo no equivale a superar el benchmark completo de calidad, 256K o concurrencia.
11. Instalar SGLang y recuperar el perfil que sí pasó las pruebas pequeñas
Entorno: /home/lab/venvs/sglang. SGLang 0.5.19, PyTorch informa 2.13.0+cu130 / CUDA 13.0, Transformers 5.12.1 y compressed-tensors 0.18.0. pip check pasó. El lock completo está en evidence/locks/sglang-freeze.txt. Hay una diferencia de representación comprobada: metadata/pip dice torch==2.13.0, mientras el módulo importado dice 2.13.0+cu130; ambas salidas se guardaron en evidence/observed/sglang-torch.txt. No deducir CPU/CUDA sólo del sufijo del freeze.
python3 -m venv /home/lab/venvs/sglang
/home/lab/venvs/sglang/bin/pip install --upgrade pip
/home/lab/venvs/sglang/bin/pip install torch==2.13.0+cu130 \
--index-url https://download.pytorch.org/whl/cu130
/home/lab/venvs/sglang/bin/pip install sglang==0.5.19 \
transformers==5.12.1 compressed-tensors==0.18.0
/home/lab/venvs/sglang/bin/pip check
/home/lab/venvs/sglang/bin/python -m sglang.launch_server --help
Comprueba dependencias completas con el lock y las instrucciones de SGLang. Las ruedas y kernels deben corresponder a CUDA/SM86. No hace falta compilar FlashAttention por separado si el perfil probado usa Triton; instalar un backend adicional no prueba que el launcher lo seleccione.
Para fijar transitivas repite el procedimiento de pip install --dry-run -r, instalación, pip check y diff de la sección anterior, sustituyendo vllm por sglang. Después verifica también torch.version.cuda, no únicamente metadata.
El arranque inicial FP8 Marlin W8A16 en GPU 1 pasó canarios muy cortos, pero pruebas posteriores detectaron errores aritméticos. Por eso no se presenta como el mejor perfil. El registro local promovió int8-bf16-8k: INT8 propio por grupos 128, activaciones/KV BF16, tres solicitudes, Triton para atención y Mamba, contexto configurado 8192. El archivo congelado es evidence/historical/modular/sglang/frozen/int8-bf16-8k.sh. Cambia la UUID antes de usarlo en otra máquina.
Sus datos documentan 6/7 en la batería corta y recuperación 4K con concurrencias 1 y 3. “Validado” se limita a esas pruebas; el perfil 256K continuó experimental. En la inspección actual no había listener SGLang en 8130 y GPU 1 estaba libre. El servicio podría cambiar después de esa fecha.
Después de preparar los pesos INT8 de la sección siguiente, arráncalo en primer plano. Ctrl+C detiene sólo esa instancia:
export ATLAS_GPU_UUID=GPU_UUID_LIBRE_DE_TU_REPLICA
export ATLAS_MODEL_DIR=/home/lab/models/ornith-modular/full-int8-text
export ATLAS_TOKENIZER_DIR=/home/lab/models/Ornith-1.5-9B-original
bash /RUTA/AL/KIT/examples/launch_engine.sh sglang-int8
# En otra terminal:
python3 /RUTA/AL/KIT/examples/canary.py --base http://127.0.0.1:8130/v1 \
--model ornith-sglang --out canario-sglang-replica.json
12. Cómo creamos las variantes INT8 y texto
Los scripts originales están en evidence/historical/modular/ptq/ y evidence/historical/modular/shared/strip_vision.py. El original oficial fijado se conservó. strip_vision.py creó una copia sin tensores visuales y comparó hashes de los tensores retenidos; no fue entrenamiento ni poda de idiomas. El informe registra 912020960 bytes de visión retirados. Retirar archivos no implica ese mismo ahorro de VRAM si el runtime no los cargaba antes.
Después se crearon variantes INT8 W8A16 simétricas, grupos 128, con LLMCompressor 0.13.0 y compressed-tensors 0.18.0: mlp_int8.py para matrices MLP y full_int8.py para las lineales del texto. Lee los paths y destinos del script antes de ejecutarlo: son herramientas de conversión que escriben checkpoints grandes. Crea un directorio nuevo por experimento; no apuntes la salida al modelo original.
Una réplica del entorno de conversión empieza así:
python3 -m venv /home/lab/venvs/ornith-ptq
/home/lab/venvs/ornith-ptq/bin/pip install torch==2.13.0+cpu \
--index-url https://download.pytorch.org/whl/cpu
/home/lab/venvs/ornith-ptq/bin/pip install \
llmcompressor==0.13.0 compressed-tensors==0.18.0 \
safetensors==0.8.0 transformers==5.14.1
/home/lab/venvs/ornith-ptq/bin/pip check
/home/lab/venvs/ornith-ptq/bin/python -c 'import torch; assert torch.version.cuda is None; print(torch.__version__)'
Este entorno usa deliberadamente PyTorch CPU: full_int8.py lo exige para no ocupar las GPU activas. El script y los manifiestos de pesos son la referencia para el resultado; esta instalación propuesta debe contrastarse con dependencias resueltas antes de una nueva conversión. El kit no contiene los gigabytes de pesos resultantes. Consulta además el curso de compresión MoE: los expertos pertenecen al 35B-A3B, no al 9B denso de estos scripts.
Pasos reales de conversión para la réplica, con suficiente disco libre para original, texto e INT8. Escriben decenas de GB y pueden tardar; no son un canario. Los destinos deben ser nuevos:
python3 /RUTA/AL/KIT/evidence/historical/modular/shared/strip_vision.py \
/home/lab/models/Ornith-1.5-9B-original \
/home/lab/models/ornith-modular/original-text
/home/lab/venvs/ornith-ptq/bin/python \
/RUTA/AL/KIT/evidence/historical/modular/ptq/full_int8.py
full_int8.py importa su auxiliar mlp_int8.py, por eso ambos deben seguir juntos. Sus paths de entrada/salida están fijados a los que acabamos de preparar. Al terminar, inspecciona component-manifest.json y ptq-manifest.json y sólo entonces carga el resultado en el perfil SGLang. El estado artifact-verified-not-runtime-tested verifica el archivo, no que el motor haya ejecutado calidad. Para crear la variante MLP únicamente, ejecuta mlp_int8.py en lugar de full_int8.py, con otro destino ya definido en el script.
13. Repetir los tests: calidad, contexto, concurrencia y velocidad
Primero ejecuta pruebas CPU de las utilidades, sin arrancar modelos:
cd /RUTA/AL/KIT/evidence/historical/modular/control
python3 -m unittest -v test_control.py
cd /RUTA/AL/KIT/evidence/historical/modular/shared
python3 -m unittest -v test_bench.py
El controlador tiene fixtures de cambio de perfil, rollback, drenaje, puertos ocupados y SSE. Superarlos prueba el controlador con procesos simulados; no demuestra una migración real del motor. Algunas fixtures usan APIs de Linux y deben ejecutarse allí.
Para el endpoint propio: prueba salud, modelo, chat, emisión JSON de herramienta, resultado de la herramienta, segunda llamada, respuesta final, historial y streaming terminado. examples/canary.py aporta una prueba acotada sin ejecutar código generado. Una llamada estructurada utiliza finish_reason=tool_calls; el chat y la continuación final normalmente terminan en stop. El manual anterior confundía ambas terminaciones.
python3 /RUTA/AL/KIT/examples/canary.py --base http://127.0.0.1:8120/v1 \
--model ornith-local --out canario-local.json
La batería histórica quality.py conserva siete casos: multiplicación, expresión aritmética, JSON estricto, extracción, square, suma de lista y tool call. Para evaluar código generado usa una máquina de pruebas o sandbox aislado: el filtro AST/timeout del script histórico reduce riesgos, pero no es una frontera de seguridad completa para código arbitrario.
python3 /RUTA/AL/KIT/evidence/historical/modular/shared/quality.py \
--base http://127.0.0.1:8120/v1 --model ornith-local --out quality-local.json
Para recuperar marcadores a 5/50/95% de un contexto, usa bench.py y un tokenizer local. Instala transformers en el entorno de pruebas, y comienza con una sola solicitud corta:
python3 /RUTA/AL/KIT/evidence/historical/modular/shared/bench.py \
--base http://127.0.0.1:8120/v1 --model ornith-local \
--out /home/lab/results/retrieval-4k-r1 \
--lengths 4096 --concurrency 1 --repeats 1 --max-output 256 \
--tokenizer /home/lab/models/Ornith-1.5-9B-original \
--gpu GPU_UUID_DE_TU_REPLICA
Después amplía 8K, 16K, 32K, 128K y 256K sólo si configuración, calidad y temperatura lo permiten. Usa directorios nuevos: el script rechaza resultados reutilizados. Repite varias veces y luego mide concurrencia 1,3. Una solicitud 256K necesita margen para plantilla y salida. Tres HTTP en paralelo no prueban tres contextos residentes en GPU.
--task throughput --max-output 512 mide otra carga; no mezcles su velocidad con recuperación corta. Registra tiempo al primer token visible, tiempo total, tokens de salida, tasa de errores y pico de VRAM. El TTFT de reasoning y el de texto visible pueden diferir. La tasa estimada entre eventos SSE no siempre equivale a tokens individuales porque un evento puede agrupar varios.
14. Qué resultados conservamos y cuáles no conviene promocionar
| Perfil / prueba | Evidencia recuperada | Interpretación |
|---|---|---|
| llama.cpp GPU 0 | Canario nuevo: chat, dos llamadas forzadas, continuación, historial y SSE completo, 6/6 | Contrato básico ejercitado; no es todo OpenCode/Codex |
| SGLang inicial FP8 | Smoke y aritmética iniciales correctos; recheck posterior con regresión | Sirve para estudiar instalación; no aprobar sólo por arrancar |
| SGLang INT8/BF16 8K | Registro 6/7, conserva los casos aprobados por llama; recuperación 4K c1/c3 | Aprobación acotada, no 256K general |
| SGLang INT8 E5M2 256K | Registro experimental; no aceptación completa | Mantener experimental |
| vLLM NF4 inicial | Chat, código y dos solicitudes cortas | Instalación funcional histórica |
| vLLM Q4 bajo 17 GiB | Registro 16492 MiB, 5/7; falló multiplicación y formato | Ahorro de memoria con regresión; no promocionar |
| vLLM AWQ+KV4 en 8122 | Proceso activo observado | Configuración actual, distinta del NF4 histórico |
| MTP / DFlash / visión | Scripts y resultados propios por componente | Leer cada caso; no inferir que estén activos por existir pesos |
El kit conserva current-summary.json, casos por motor y resultados de calidad. Algunos resultados antiguos no registraron el terminador SSE; ese dato no puede reconstruirse a posteriori. La prueba SGLang Q4 bajo 17 GiB también tuvo una corrida inválida por puerto ocupado por otro perfil: una respuesta de un proceso distinto no valida el candidato.
15. Panel, perfiles, mantenimiento y restauración
Continúa en Terminales y panel: sesiones llama, harness, sglang, vllm; ventanas General, Log, Check, Test, Monitor, OpenCode y Codex; teclas, servicios de Herdr/Moshi y su reinstalación.
Para listar perfiles sin activarlos: ornithctl sglang list y ornithctl sglang status. Se encontró un registro SGLang; no se encontró un registro equivalente vLLM en modular/profiles/. El código del controlador puede existir sin que un motor haya sido migrado a él. use y rollback cambian procesos, por eso pertenecen a una réplica o ventana de mantenimiento controlada.
En ia-lab, el entrypoint fuente recuperado es /home/lab/bench/ornith/modular/control/ornithctl.py; puedes usar python3 /home/lab/bench/ornith/modular/control/ornithctl.py sglang list si no existe el acceso corto. Sus registros y directorios auxiliares deben estar restaurados con sus paths correctos antes de utilizarlo. Para aprender sin restaurar servicios, ejecuta los tests CPU del kit; no uses use como prueba inocua de instalación.
Conserva un respaldo verificable de modelos, locks, scripts y la imagen Docker. Para cada cambio, escribe versión anterior, versión nueva, comandos, hashes y resultado de calidad. Si un perfil nuevo falla, arranca el anterior desde sus artefactos conservados; no reconstruyas el baseline de memoria. Nunca ejecutes como rutina de diagnóstico ornith-opencode-final.sh: el wrapper histórico incluye limpieza de procesos y recreación del contenedor. Se incluye para entender el trabajo previo, no como botón de salud.
Criterio de una reinstalación terminada: GPU visibles en host y Docker; compilación/imagen identificada; checkpoint verificado; un perfil por GPU con puerto conocido; salud y canario correctos; pruebas de calidad comparables; panel reconectable; resultados guardados. Lo que sigue pendiente debe figurar con su nombre, especialmente la reproducción del hipervisor y una reconstrucción binaria idéntica de la imagen histórica.
Atlas: terminales, Herdr/Moshi, DSH y OpenCode en ia-lab
Auditoría de solo lectura realizada el 2026-09-23 sobre ia-lab (100.75.152.118). No se reiniciaron servicios, no se ejecutaron instaladores y no se modificaron archivos. Se omitieron valores de Environment=, tokens, claves, cookies, auth state, sesiones y contenido de panes/historial.
Consulta también todos los perfiles y resultados históricos y el índice de archivos del kit.
- Atlas: terminales, Herdr/Moshi, DSH y OpenCode en ia-lab
- 1. Entrada segura y límites
- 2. Herdr: instalación, servicio y teclado
- 3. tmux: la tecla Ctrl+A que sí está configurada
- 4. Ventanas tmux observadas
- 5. Moshi-hook: estado y pasos de activación
- 6. DeepSeek Harness / DSH web profile
- 7. OpenCode: configuración real frente a la documentación
- 8. vLLM/SGLang y lo que realmente existe
- 9. llama.cpp / FAALL
- 10. Receta reinstalable de máquina nueva (plan, no ejecutado)
1. Entrada segura y límites
ssh lab@HOST_IA_LAB
Identidad observada: hostname ia-lab, usuario lab, reloj remoto 2026-09-23T21:51:53+00:00. Antes de cualquier cambio, abrir una terminal separada y conservar la sesión llama como referencia. La auditoría consultó sólo estados, metadatos, nombres de ventanas y ayuda CLI; no hizo tmux capture-pane, history, journalctl, lectura de logs de contenido ni lectura de secretos.
2. Herdr: instalación, servicio y teclado
Estado observado
/home/lab/.local/bin/herdrexiste, ELF estático x86-64,herdr 0.9.1./home/lab/.config/systemd/user/herdr.serviceejecuta/home/lab/.local/bin/herdr server,Restart=on-failure; sus variablesEnvironment=fueron redactadas.systemctl --user is-enabled herdr.service→enabled;is-active→active.herdr status server→running, versión0.9.1, endpoint/protocolo privado compatibles, socket/home/lab/.config/herdr/herdr.sock./home/lab/.config/herdr/config.tomlfijakeys.prefix = "ctrl+b", mouse/copia por selección activados, scrollbars y reanudación de agentes.
Instalación oficial de referencia (no ejecutada): el README del proyecto publica curl -fsSL https://herdr.dev/install.sh | sh, compilación desde https://github.com/ogulcancelik/herdr y el flujo de workspaces. Ver herdr-terminal y quick start. Conviene fijar una release y revisar el binario antes de sustituir el 0.9.1 local; no asumir que el instalador actual conserva esa configuración.
Operación prevista:
herdr # crea o conecta al servidor persistente
herdr status server # consulta, no cambia estado
herdr session list # listar sesiones si se necesita seleccionar
herdr session attach <nombre> # adjuntar una sesión nombrada
La documentación pública usa Ctrl+B q para salir del cliente Herdr dejando procesos y sesión vivos. En el host, Herdr tiene prefijo Ctrl+B, no Ctrl+A.
3. tmux: la tecla Ctrl+A que sí está configurada
El archivo /home/lab/.tmux.conf contiene set -g prefix C-a, bind C-a send-prefix y un indicador de estado CTRL+A. Por tanto, las operaciones tmux son:
Ctrl-A d detach del cliente tmux; procesos continúan
Ctrl-A c nueva ventana
Ctrl-A n/p siguiente/anterior ventana
Ctrl-A w selector de ventanas
No confundir Ctrl-A d (tmux) con Ctrl-B q (Herdr). La configuración Herdr y tmux pueden estar anidadas; pulsar el prefijo del multiplexor exterior primero y comprobar el indicador visible.
4. Ventanas tmux observadas
Se consultaron nombres/contadores, no contenido de panes:
harness: General, Log, Check, Test, Monitior (6 panes)
llama: General, Log, Check, Test, Monitor (6), OpenCode (6), Codex
sglang: General, Log, Check, Test, Monitor (6), OpenCode (6), Codex
vllm: General, Log, Check, Test, Monitor (6), OpenCode (6), Codex
Sesiones existentes: harness, llama, sglang, vllm. La ventana harness tiene el typo visible Monitior; no se corrigió. llama es la referencia activa y no debe cerrarse ni reutilizarse para instalar runtimes.
5. Moshi-hook: estado y pasos de activación
Estado observado
- La unidad usa
/home/lab/.local/bin/moshi-hook serve; ese binario existe, es ELF Go estático y devuelvemoshi-hook version 0.3.26. /home/lab/.config/systemd/user/moshi-hook.serviceestáenabledyactive.moshi-hook status→paired; hostia-lab; servidor Moshi Pro adjunto; socket/run/user/1000/moshi-hook.sock.moshi-hook probe→installed: true,running: true,gateway: true, versión0.3.26.- Hooks actuales reportados: Claude
/home/lab/.claude/settings.json, Codex/home/lab/.codex/hooks.json, OpenCode/home/lab/.config/opencode/plugins/moshi-hooks.ts. No se leyó su contenido.
Instalación oficial de referencia (no ejecutada): curl -fsSL https://getmoshi.app/install.sh | sh; servicio Linux moshi-hook service install; verificación moshi-hook service status. La documentación oficial explica que el daemon mantiene el socket local, gateway 127.0.0.1:24543 y WebSocket de Moshi: Install moshi-hook. La unidad existente es una instalación manual/gestionada de systemd; no instalar encima sin una decisión explícita.
Comprobaciones sin cambio de estado:
/home/lab/.local/bin/moshi-hook version
/home/lab/.local/bin/moshi-hook status
/home/lab/.local/bin/moshi-hook probe
/home/lab/.local/bin/moshi-hook service status
moshi-hook install, pair, service install, update y uninstall son mutantes; no se ejecutaron.
6. DeepSeek Harness / DSH web profile
/home/lab/.dsh/profiles/web/package.json existe (1361 bytes), con nombre dsh-profile-web. No declara scripts, packageManager ni devDependencies; las dependencias reales están fijadas por el lockfile pnpm /home/lab/.dsh/profiles/web/pnpm-lock.yaml (lockfileVersion: '9.0', autoInstallPeers: false). Entre las versiones/specs observadas están dsh-hooks-plugin@0.2.15, dsh-opencode-provider@0.1.0, dsh-plugin@1.4.4, dsh-context@0.53.3, además de paquetes fijados a tarballs GitHub por commit (dsh-mcp-ui, dsh-see-image, dsh-single-terminal, sidebar y token-usage). No se imprimieron valores potencialmente sensibles.
La primera shell no cargaba NVM y por eso no encontraba Node. La verificación ampliada sí encontró NVM 0.40.3, Node 24.21.0, pnpm 12.4.2 y DSH 0.1.5-rc.2. Están bajo /home/lab/.nvm/versions/node/v24.21.0/bin. dsh --help respondió y documenta dsh --profile web o dsh web. La ausencia en el PATH de una conexión SSH no equivalía a que no estuvieran instalados.
En una máquina nueva, recupera esas versiones (no se reinstalaron en el host activo). Descarga e inspecciona primero el instalador de NVM:
mkdir -p /home/lab/installers
curl -fL https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh -o /home/lab/installers/nvm-install.sh
less /home/lab/installers/nvm-install.sh
bash /home/lab/installers/nvm-install.sh
source /home/lab/.nvm/nvm.sh
nvm install 24.21.0
nvm use 24.21.0
npm install -g pnpm@12.4.2 @deepseek-ai/dsh@0.1.5-rc.2 \
@opencode/cli@2.0.5 @openai/codex@0.154.0
node --version
pnpm --version
dsh --version
dsh --help
La documentación NVM explica que se carga por shell. En una conexión no interactiva, carga nvm.sh o exporta el PATH versionado antes de diagnosticar paquetes inexistentes. No uses sudo npm con este NVM del usuario.
Instalación reproducible en una máquina nueva (no ejecutada en ia-lab):
mkdir -p /home/lab/.dsh/profiles/web
# Sólo en un perfil nuevo; no reemplazar un perfil con configuración propia.
test ! -e /home/lab/.dsh/profiles/web/package.json
cp /RUTA/AL/KIT/evidence/terminal/dsh-package.json /home/lab/.dsh/profiles/web/package.json
cp /RUTA/AL/KIT/evidence/terminal/dsh-pnpm-lock.yaml /home/lab/.dsh/profiles/web/pnpm-lock.yaml
cd /home/lab/.dsh/profiles/web
python3 - <<'PY'
import json
p = json.load(open("package.json"))
print(p["name"], sorted(p.get("dependencies", {})))
PY
pnpm install --frozen-lockfile
pnpm list --depth 0
dsh --profile web --help
# Arranque de la réplica; comprueba primero que su puerto esté libre:
dsh --profile web
Primero instala una versión de Node/pnpm compatible con la distribución DSH que se vaya a usar y conserva ambos archivos (package.json y pnpm-lock.yaml). --frozen-lockfile evita resolver versiones nuevas. Si pnpm informa scripts nativos bloqueados (por ejemplo node-pty), revisar el diff y ejecutar la aprobación de builds sólo de forma explícita; no convertir pnpm approve-builds en un paso automático. La presencia de un paquete en el lockfile no prueba que su binario nativo haya compilado.
7. OpenCode: configuración real frente a la documentación
/home/lab/bench/ornith/opencode-lab/env.sh apunta a un perfil aislado:
OPENCODE_CONFIG=/home/lab/bench/ornith/opencode-lab/config/opencode.json
OPENCODE_CONFIG_DIR=/home/lab/bench/ornith/opencode-lab/opencode.d
XDG_CONFIG_HOME=/home/lab/bench/ornith/opencode-lab/xdg-config
XDG_DATA_HOME=/home/lab/bench/ornith/opencode-lab/xdg-data
XDG_CACHE_HOME=/home/lab/bench/ornith/opencode-lab/xdg-cache
workspace=/home/lab/bench/ornith/opencode-lab/workspace
El JSON tiene $schema=https://opencode.ai/config.json, modelo local-ornith/ornith-local y provider local-ornith con:
name: Ornith 1.5 Local / llama.cpp
package: @opencode/ai/providers/openai-compatible
settings keys: apiKey, baseURL (valores no impresos)
model key: ornith-local
Hay una divergencia entre ejemplos/documentación disponibles y la CLI instalada; la configuración que realmente funciona en este perfil usa providers, package y settings. En una máquina nueva, confirma primero la versión de OpenCode y su esquema local; no mezcles fragmentos de versiones distintas.
Auditoría no destructiva del perfil:
cd /home/lab/bench/ornith/opencode-lab
source ./env.sh
opencode --version
python3 - <<'PY'
import json
p='/home/lab/bench/ornith/opencode-lab/config/opencode.json'; d=json.load(open(p))
print(d.get('$schema'), d.get('model'), list(d.get('providers', {})))
PY
La última línea evita imprimir secretos; no registres el entorno completo. El perfil local recuperado sí fue probado mediante un canario aislado y respondió correctamente; detalles en Agentes y MCP. Las credenciales personales de otros proveedores no forman parte del kit.
8. vLLM/SGLang y lo que realmente existe
Estado observado:
/home/lab/venvs/vllm Python 3.12.3, vLLM 0.29.0, torch 2.13.0+cu130
/home/lab/venvs/sglang Python 3.12.3, SGLang 0.5.19
Los binarios existen en /home/lab/venvs/vllm/bin/vllm y /home/lab/venvs/sglang/bin/sglang. El script histórico /home/lab/bench/ornith/vllm/setup.sh y su copia modular/vllm/baseline/setup.sh documentan sólo:
/home/lab/venvs/vllm/bin/pip install vllm-bnb-plugin==0.0.3
/home/lab/venvs/vllm/bin/pip check
# sanity: import torch, vllm, bitsandbytes y contar GPUs
El log correspondiente registra vLLM 0.29.0, torch 2.13.0+cu130, bitsandbytes 0.50.2 y una RTX 3090 visible. Sigue la instalación de la réplica en el manual principal, manteniendo intacto el entorno activo.
Fuentes oficiales actuales: instalación GPU de vLLM y instalación SGLang. Ambas cambian con CUDA/Python; para una máquina nueva fijar versión, GPU, driver y wheel antes de instalar. La guía actual de SGLang menciona CUDA 13 y que 0.5.19 fue la última rama CUDA 12; esto hace que el venv observado sea especialmente importante de preservar.
9. llama.cpp / FAALL
/opt/llama.cpp existe y su commit es exactamente:
82490b9d43954a82d659890a2d6c74dd68cf5653
Binaries observados:
/opt/llama.cpp/build/bin/{llama-cli,llama-server,llama-bench}
/opt/llama.cpp/build-faall-native/bin/{llama-cli,llama-server,llama-bench}
El historial APT está disponible en /var/log/apt/history.log. La instalación observada registra cuda-toolkit-13-0, libnccl2=2.28.9-1+cuda13.0 y libnccl-dev=2.28.9-1+cuda13.0; el inventario recuperado del operador también registra nvidia-driver-580. Son prerrequisitos del host auditado, no una receta universal: validar driver, GPU y repositorio antes de repetirlos. No apareció llama-cuda-faall.Dockerfile en /home/lab, /opt/llama.cpp ni /tmp. Sí existen:
/home/lab/bench/ornith/bench-faall-matrix.sh
/home/lab/bench/ornith/bench-faall-phase1b.sh
/home/lab/bench/ornith/LAST_FAALL_BUILD
El marcador contiene faall-build-20260917T145112Z. Los scripts refieren a la imagen lomelidev/llama.cpp:cu130-nccl-sse-faall-10974, usan Docker, GGML_CUDA_GRAPH_OPT=1 y crean salidas bajo $HOME/bench/ornith/...; no se iniciaron ni se inspeccionaron logs de contenedor.
La documentación oficial de instalación de llama.cpp ofrece binario, Docker y build desde fuente: llama.app Installation. Para este host no sustituye el build verificado: el commit y los binarios locales deben permanecer intactos hasta que exista una comparación funcional.
10. Receta reinstalable de máquina nueva (plan, no ejecutado)
- Instalar/validar SSH y entrar con la clave del operador; comprobar hostname, usuario y GPU.
- Instalar Herdr desde su fuente oficial, fijando release; validar
herdr --version. El servidor debe arrancar como servicio de usuario y el cliente debe conservar un workspace; usarherdr status server,herdr session listyherdr session attach <nombre>. - Instalar
moshi-hookdesde la guía oficial, instalar el servicio de usuario y comprobarmoshi-hook service status,moshi-hook statusymoshi-hook probe. El pairing requiere un valor privado: usarmoshi-hook pair --token <MOSHI_PAIRING_TOKEN>sólo con el token entregado fuera de documentación; nunca escribir el token real en este manual, historial compartido o captura de panel. - Crear sesiones tmux vacías y separadas con
terminales-examples/recreate-tmux-sessions.shdentro del kit. Usareplica-llama,replica-harness,replica-sglangyreplica-vllm; no reutiliza ni cierrallama. El ejemplo crea ventanas, pero no arranca servidores, descarga pesos ni ejecuta benchmarks. - Si se desea el teclado histórico, usar el fragmento mínimo
tmux-minimal.conf.exampleconprefix C-a; probarCtrl-A dy confirmar que el proceso sigue vivo. Guardar el/home/lab/.tmux.confhistórico como referencia y no reemplazarlo automáticamente. - Crear venv separados para SGLang/vLLM, fijar CUDA/Python y ejecutar
pip check/import smoke test antes de descargar pesos. Repetir únicamente paquetes compatibles con la GPU y el driver; el host auditado conserva versiones concretas, no una garantía portable. - Instalar el perfil DSH con
pnpm install --frozen-lockfiledesde supackage.json/pnpm-lock.yaml; revisar builds nativos bloqueados antes de aprobarlos. No asumir que una lista de dependencias equivale a una UI o hook operativo. - Compilar o recuperar llama.cpp en
/opt/llama.cppcon commit explícito; registrar hash de binarios y GPU backend. El historial CUDA/NCCL del host sirve como evidencia de prerequisitos, no como comando universal. - Configurar OpenCode con
OPENCODE_CONFIGyOPENCODE_CONFIG_DIRabsolutos; mantener las claves reales fuera del manual. El endpoint local sin autenticación está documentado en el perfil de ejemplo. - Sólo después hacer pruebas de endpoint, streaming y tool calling con un modelo pequeño; luego Ornith con la matriz de calidad/VRAM/contexto. Un proceso activo o un panel visible no prueba la ruta completa.
Crear sesiones vacías sin lanzar workloads
El script de ejemplo funciona en modo simulación por defecto (DRY_RUN=1). Para crear sólo sesiones tmux vacías, sin ejecutar modelos ni scripts de servicio, revisar su salida y usar DRY_RUN=0. Omite una sesión que ya existe para no modificar la referencia histórica:
DRY_RUN=1 bash terminales-examples/recreate-tmux-sessions.sh
# tras revisar la salida:
DRY_RUN=0 bash terminales-examples/recreate-tmux-sessions.sh
tmux list-sessions
tmux list-windows -a -F '#{session_name}:#{window_name}'
El layout histórico observó ventanas General, Log, Check, Test, Monitor, OpenCode y Codex en las sesiones principales, con varios panes en algunas ventanas. Los nombres no prueban el comando que corría dentro de cada pane; el ejemplo crea una ventana vacía por nombre y deja cualquier layout de panes para una decisión posterior.
Criterio de “instalado”
which/--version sólo prueba un binario. Para declarar una integración operativa hay que probar, en orden: proceso, socket/gateway, attach/detach, evento de hook, endpoint OpenAI-compatible, streaming y una tarea mínima. Separar cada fallo y conservar el estado existente.
Perfiles, pruebas y resultados históricos
Recuperación de sólo lectura: 23-09-2026. Las corridas de esta página son del 17-09-2026. No se repitieron, no se reinició ningún motor y no se activó ninguno de estos perfiles. El perfil observado en GPU0 es sólo una entrada, no toda nuestra historia.
Corrección de trazabilidad: las notas previas dejaban P3/P4 pendientes porque no mostraban su final. Los archivos originales recuperados ahora sí contienen resúmenes completos. Un resumen histórico no certifica el estado actual del servidor ni la corrección del evaluador.
Matriz llama.cpp: pesos iguales, caché y DFlash distintos
Modelo de estas suites: Ornith 1.5 9B Q4_K_L. Los sufijos Q4/Q8 de las filas describen caché K/V, no nuevos pesos. Cada bloque usa su propia carga; no ordenar cifras de bloques distintos como si fueran un benchmark común. FAIL no equivale a velocidad cero ni a un diagnóstico de causa.
| Perfil | Contexto configurado | K / V | DFlash | VRAM MiB | Prefill tok/s | Generación tok/s | Estado |
|---|---|---|---|---|---|---|---|
| A-q4q4-dflash | 262144 | q4_0 / q4_0 | on | 16174 | 32.01 | 88.42 | Medición; calidad no establecida por esta tabla |
| B-q8q4-dflash | 262144 | q8_0 / q4_0 | on | 17198 | 32.07 | 97.38 | Medición; calidad no establecida por esta tabla |
| C-q8q8-dflash | 262144 | q8_0 / q8_0 | on | 18222 | 31.96 | 109.07 | Medición; calidad no establecida por esta tabla |
| D-q4q4-base | 262144 | q4_0 / q4_0 | off | 10262 | 213.62 | 98.59 | Medición; calidad no establecida por esta tabla |
| E-q8q4-base | 262144 | q8_0 / q4_0 | off | 11286 | 208.85 | 97.87 | Medición; calidad no establecida por esta tabla |
| F-q4q4-no-fa | 262144 | q4_0 / q4_0 | off | FAIL | — | — | Fallo registrado |
| G-q8q8-base | 262144 | q8_0 / q8_0 | off | 12310 | 485.60 | 79.61 | Medición; calidad no establecida por esta tabla |
| H-q4q4-draftq4 | 262144 | q4_0 / q4_0 | on | 15352 | 336.40 | 109.92 | Medición; calidad no establecida por esta tabla |
| I-q8q4-draftq4 | 262144 | q8_0 / q4_0 | on | 16376 | 335.50 | 108.67 | Medición; calidad no establecida por esta tabla |
| J-q8q8-draftq4 | 262144 | q8_0 / q8_0 | on | 17400 | 339.08 | 111.50 | Medición; calidad no establecida por esta tabla |
| K-512-q4q4-dflash | 524288 | q4_0 / q4_0 | on | 20300 | 326.70 | 86.17 | Medición; calidad no establecida por esta tabla |
| L-512-q8q8-dflash | 524288 | q8_0 / q8_0 | on | FAIL | — | — | Fallo registrado |
| M-512-q4q4-base | 524288 | q4_0 / q4_0 | off | 14616 | 475.84 | 96.57 | Medición; calidad no establecida por esta tabla |
No se promueve DFlash por una cifra de tokens/s: hay que medir calidad, aceptación del borrador, prefill, contexto, memoria y carga completa. Las filas 512K describen configuración/medición de esa suite, no una evaluación universal de 512K. Los scripts históricos pueden parar y recrear servicios; descárgalos para revisión, no los ejecutes sobre GPU0.
P1: reutilización de caché
Cada caso tiene 15 muestras; el resumen usa 12 en régimen estable. Las latencias son las definidas por el script de la suite. Reporte original
| Caso | TTFT mediano ms | Reuso mediano % | Tokens procesados medianos |
|---|---|---|---|
| P1-A-cache-on-same | 161.93 | 99.48 | 31.00 |
| P1-B-cache-on-rotate | 3421.65 | 49.22 | 9005.50 |
| P1-C-cache-off-same | 6114.08 | 0.00 | 17933.00 |
| P1-D-cache-off-rotate | 6436.19 | 0.00 | 17933.00 |
| P1-E-cold | 5871.94 | 0.00 | 17933.00 |
La diferencia observada entre prefijo idéntico con caché y sin ella no implica que cualquier conversación tendrá esa latencia; cambiar el prefijo modifica el trabajo reutilizable.
P1-F: revisitar prefijos
| Caso | Revisitas | Revisitas calientes | TTFT mediano ms |
|---|---|---|---|
| F12 | 24 | 24 | 452.84 |
| F3 | 6 | 6 | 416.78 |
| F6 | 12 | 12 | 464.06 |
P2: recuperación de marcadores en contexto largo
Reporte original · Modelo, imagen y parámetros
| Variante | Casos aprobados | Prompt mediano reportado por servidor | Tiempo total mediano s |
|---|---|---|---|
| P2-NATIVE-262K | 2/2 | 245165.50 | 164.94 |
| P2-YARN-512K | 2/2 | 500156.50 | 490.91 |
Ambas variantes terminaron con stop. Son dos casos de recuperación por variante, no prueba suficiente de razonamiento general, estabilidad prolongada o múltiples contextos máximos concurrentes. La variante YaRN es extrapolación configurada; no se cambia el límite oficial del modelo por este resultado.
P3 y P3B: no confundir evaluadores
P3 inicial y P3B estricto no comparten criterio de aprobación; no se deben mezclar sus porcentajes.
P3
| Presupuesto | Aprobados | Formato correcto | Mediana total s |
|---|---|---|---|
| 256 | 3/3 | 3/3 | 25.58 |
| 1024 | 2/3 | 3/3 | 19.98 |
| 2048 | 1/3 | 2/3 | 33.81 |
P3B estricto
| Presupuesto | Aprobados | Formato correcto | Mediana total s |
|---|---|---|---|
| 256 | 0/5 | 0/5 | 14.90 |
| 512 | 0/5 | 2/5 | 18.18 |
| 1024 | 0/5 | 3/5 | 13.28 |
| 2048 | 5/5 | 5/5 | 19.30 |
En P3B, 2048 obtuvo 5/5 y los otros presupuestos 0/5 en aceptación estricta. Es evidencia de ese examen y ese criterio, no un presupuesto óptimo universal. Algunos casos de presupuestos menores sí cerraron correctamente y/o tuvieron formato válido: terminar no equivale a acertar.
P4: concurrencia, geometría y estrés
Seis solicitudes simultáneas por ronda, tres rondas frías por geometría; presupuesto de razonamiento 2048 y salida máxima 4096. Reporte original · Manifiesto de ejecución · 54 resultados por solicitud
| Perfil | Slots | Capacidad configurada por slot | Aprobados | Tok/s agregados medianos | Pico VRAM MiB | Máx. °C |
|---|---|---|---|---|---|---|
| G3-256K | 3 | 262144 | 14/18 | 113.43 | 17066.00 | 80.00 |
| G4-192K | 4 | 196608 | 15/18 | 95.97 | 16858.00 | 76.00 |
| G4-160K | 4 | 163840 | 16/18 | 109.86 | 15068.00 | 76.00 |
No son tres o cuatro prompts de 256K llenos. La columna indica capacidad configurada por slot; la carga es el examen concurrente de la suite. Ninguna geometría pasó todos los casos. Las tasas agregadas no son velocidad por usuario. El máximo de 80 °C es un dato histórico, no una declaración de operación segura continua.
Las tres filas se reconciliaron con los 54 registros individuales; eso comprueba el agregado, no vuelve a puntuar las respuestas ni repite la inferencia. Cada geometría conserva sus argumentos en los archivos G3-256K-last-args.json, G4-192K-last-args.json y G4-160K-last-args.json del catálogo.
Otros motores y estado observado
El manual de instalación conserva SGLang FP8, INT8/BF16 8K, INT8 E5M2 256K, vLLM NF4 y AWQ+KV4. Sus pruebas tienen cargas distintas. El resumen modular se puede descargar sin buscar dentro del ZIP.
El proceso de GPU0 descrito en el manual fue observado el 23-09-2026. No convierte los perfiles de 17-09 en configuraciones actualmente activas. No se volvió a medir throughput ni a cambiar procesos en esta actualización.
Cómo encontrar y repetir una prueba
Usa Buscar archivos para ver ruta remota, miembro del ZIP y descarga. Fija modelo/hash, imagen/commit, flags, entrada, semilla, evaluador y condiciones de temperatura. Repite primero una carga pequeña en una GPU reservada; no lances las suites históricas contra servicios activos.
Estados separados: configurado, ejecutado, aprobado en una carga concreta, fallido, incompleto. No convertir un archivo de parámetros, HTTP 200 o memoria reservada en prueba de calidad.
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.
- Atlas Ornith: curso práctico de MoE, poda, destilación y cuantización
- 1. Qué problema estamos resolviendo
- 2. MoE desde cero: router, expertos y coste
- 3. Denso 9B frente a 35B-A3B: decisión de laboratorio
- 4. Qué significa podar expertos
- 5. El hallazgo «timmi/timmy» y qué no afirmar
- 6. Poda de capas y combinación con MoE
- 7. Destilación maestro–alumno después de podar
- 8. Cuantización: después o antes de la poda
- 9. Idiomas, tokenizador y la falsa idea de «un experto por idioma»
- 10. Proyecto reproducible sin GPU: qué registrar
- 11. Código reproducible: CPU primero y pipeline real separado
- 12. Checklist de decisión y fuentes vivas
1. Qué problema estamos resolviendo
Hay tres preguntas distintas que suelen mezclarse:
- ¿Cabe el modelo? Reducir bytes (cuantizar), eliminar expertos o quitar capas.
- ¿Sigue siendo bueno? Medir pérdida, tareas generales y las tareas reales del usuario.
- ¿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 y README oficial de la familia.
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:
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; 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:
- Poda estructurada de expertos: retirar FFN completos y ajustar el número de expertos/router. Sí reduce el checkpoint y puede reducir dispatch.
- Poda no estructurada: poner pesos a cero. Puede no reducir el archivo ni acelerar sin kernels sparse.
- Poda de capa/profundidad: quitar o colapsar bloques Transformer completos. Cambia el camino residual y es especialmente peligrosa para razonamiento generativo.
- 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.
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.
5. El hallazgo «timmi/timmy» y qué no afirmar
Actualización v4.7: se identificaron Ttimms REAP-50 BF16 y oxfrug 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. Conserva la diferencia entre resultado comunitario y prueba del laboratorio. Para practicar primero, usa los ejemplos CPU y el planner 20/30/50.
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, 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:
- clonar el checkpoint (no sobrescribir);
- inspeccionar
config.json, clases,num_hidden_layers, MTP, visión, embeddings ylm_head; - probar eliminar una capa candidata en CPU con entradas de forma pequeña;
- comparar logits de teacher/student antes de entrenar;
- 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:
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).
Una receta de investigación para Ornith (no ejecutada):
- Congelar el teacher y guardar sólo logits/activaciones de una muestra pequeña si hay espacio; si no, hacer dos forwards sincronizados.
- Usar corpus de calibración que cubra código, conversación, matemáticas, herramientas, español/inglés y el dominio objetivo.
- Comenzar con
α=0.1–0.5, temperaturaT=2–4, LR pequeño y máscara de poda fija. - Añadir replay de ejemplos donde el student falle y un conjunto retenido que nunca se use para seleccionar la poda.
- 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 y la guía de selección. 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:
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. El repositorio oficial 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 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, 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 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:
- construir un vocabulario permitido desde corpus objetivo y conservar bytes/especiales indispensables;
- remapear tokenizer, embeddings y
lm_headcon un checkpoint nuevo; - hacer continued pretraining o destilación, no sólo borrar archivos;
- medir tokenización (tokens por carácter), pérdida y generación;
- 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 advierte que una negativa superficial no demuestra que la información sea irrecuperable; OpenUnlearning 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:
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_topkpor 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
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:
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:
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:
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. La receta siguiente reproduce la estructura del autor, pero no se ejecutó en este curso y requiere GPU Blackwell/entornos propios:
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:
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:
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: arquitectura declarada, benchmarks y recetas; limitación: resultados del autor, dependientes de harness.
- Ornith-1, README oficial: familia denso/MoE y serving; limitación: no es un estudio de poda.
- REAP, Cerebras Research: código y criterio de saliencia; limitación: adaptadores por arquitectura.
- REAP en llm-compressor: controles 25/50% en Qwen/Moonlight; limitación: otras bases.
- MoE-Pruner: poda y destilación expert-wise; limitación: Mixtral, no Ornith.
- Transformers quantization overview: métodos/formats y hardware; limitación: matriz de soporte evoluciona.
- Multilingual Routing: rutas multilingües; limitación: no inspecciona Ornith.
- Vocabulary Trimming: compresión de vocabulario; limitación: modelos/tareas de su estudio.
- TOFU: evaluación de unlearning; limitación: perfiles sintéticos y no idioma concreto.
- 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: distribución GGUF comunitaria exacta; limitación: no es la distribución oficial y no se asumió equivalencia con Q4_K_M.
Atlas Ornith v4.6 — datasets, PEFT, evaluación y destilación
Estado de este capítulo: investigación documental y diseño de recetas. No se descargaron datasets ni pesos, no se entrenó nada y no se modificó ningún runtime. Fecha de verificación de enlaces y metadatos: 2026-09-23.
- Atlas Ornith v4.6 — datasets, PEFT, evaluación y destilación
- 1. Decisión de diseño
- 2. Auditoría de los adjuntos locales solicitados
- 3. Datasets recuperados de nuestra conversación anterior
- 4. Catálogo para entrenamiento (no holdout)
- 5. Holdouts y benchmarks: nunca entrenarlos
- 6. Formato canónico JSONL para SFT
- 7. Preparar un dataset sintético pequeño y auditable
- 8. Receta PEFT/QLoRA: primero verificar targets reales
- 9. Evaluación antes/después
- 10. Distilación maestro→alumno
- 11. Adaptadores LoRA comunitarios: encontrados y no confirmados
- 12. Memoria y coste: lo que sí y no se puede afirmar
- 13. Vídeos útiles encontrados
- 14. Límites y siguientes pasos seguros
1. Decisión de diseño
El dataset no arregla por sí solo el contrato de Codex/OpenCode. Antes de entrenar, fijar y probar el contrato observable: plantilla de chat, nombres y esquema de herramientas, serialización de tool_calls, call_id, política de reintentos, streaming, parada, errores y evaluación end-to-end. Un SFT que sólo memoriza texto puede empeorar la decisión «no llamar a una herramienta» o producir JSON correcto pero incompatible con el parser.
Mantener dos líneas de experimento independientes:
| Línea | Base | Objetivo inicial | Lo que no se debe mezclar |
|---|---|---|---|
| Densa | ornith-ai/Ornith-1.5-9B |
contrato de herramientas, programación y español | supuestos de MoE, pesos de expertos, resultados de 35B |
| MoE | ornith-ai/Ornith-1.5-35B-A3B |
tool-use y/o destilación con presupuesto controlado | targets de una arquitectura densa, cifras de VRAM de 9B |
Las tarjetas oficiales describen ambos como Qwen3_5*ForConditionalGeneration, con visión y texto. El config.json del 9B reporta Qwen3_5ForConditionalGeneration, 32 capas, hidden_size=4096, mezcla 3:1 de atención lineal/full y contexto máximo configurado de 262144. El 35B-A3B reporta Qwen3_5MoeForConditionalGeneration, 40 capas, hidden_size=2048, 256 expertos, top-8 y el mismo contexto configurado. Son hechos de configuración, no una garantía de entrenamiento estable a esa longitud.
2. Auditoría de los adjuntos locales solicitados
Se inspeccionaron exclusivamente estos cuatro paths (sin búsqueda masiva de Downloads):
/Users/lomelidev/Downloads/atlas_ornith_v4_4_pre_audio_auditoria_y_fuentes.json/Users/lomelidev/Downloads/atlas_ornith_v4_4_pre_audio_canonico_r2.json/Users/lomelidev/Downloads/atlas_ornith_v4_4_pre_audio_canonico_r3.json/Users/lomelidev/Downloads/atlas_ornith_v4_4_pre_audio_canonico_r3_1.json
Resultado: no contienen un inventario de datasets de entrenamiento/evaluación ni filas JSONL entregadas por el agente. Contienen corpus y auditoría de vídeos/fuentes, con material bruto separado de las selecciones. No se reabre ni se altera aquí aquella decisión de corpus canónico. En la matriz, L6 se llama L6_datasets_y_tool_use, pero su fuente primaria es documentación de function calling, no un dataset. Los campos datasets presentes en R3/R3.1 son banderas booleanas (false), no referencias ni datos. Esta inspección de cuatro adjuntos no descarta que exista otra entrega en una tarea o archivo diferente.
Por tanto, no atribuyo al agente la entrega de BFCL, Codeforces, Alpaca-ES ni ningún otro dataset. El catálogo siguiente es investigación adicional y cada ficha separa fuente primaria, comunidad, licencia declarada y nivel de confianza.
3. Datasets recuperados de nuestra conversación anterior
La búsqueda histórica recuperó estos nombres que no estaban en los cuatro adjuntos locales. Se verificaron contra sus tarjetas/repositorios oficiales sin descargar datos. Esto corrige el alcance del catálogo: los adjuntos siguen sin contener un inventario ni filas JSONL entregadas por el agente, pero sí existe ahora una lista histórica verificable. Las licencias son las declaradas por la fuente; cuando los repositorios subyacentes tienen licencias adicionales, no se las simplifica a la licencia de la tarjeta.
| dataset oficial | uso recomendado | tamaño/formato/idioma observado | licencia y cautelas |
|---|---|---|---|
nvidia/OpenCodeInstruct |
training SFT de código; separar por domain y filtrar por tests antes de mezclar |
5,000,000 filas train, Parquet; inglés; input/output, juicio, unit tests y estado de ejecución |
Tarjeta NVIDIA: CC BY 4.0. Es sintético/híbrido y la tarjeta pide revisar si la licencia sirve al uso concreto. |
SWE-Gym/SWE-Gym |
training/trajectory generation para agentes SWE: tareas reales, checkout ejecutable y verificación; no usar como holdout de SWE-bench | alrededor de 2.4k tareas de 11 repositorios Python según el repo del proyecto; Parquet en Hub; inglés | La tarjeta HF declara MIT, mientras el repositorio oficial del proyecto declara Apache-2.0. Las licencias de repositorios, imágenes y dependencias de cada tarea requieren auditoría separada; no asumir una licencia única. |
SWE-bench/SWE-smith-py / SWE-bench/SWE-smith-go |
training de agentes/verificadores o generación de trayectorias; mantener patch, test_patch y cualquier evaluación fuera del input si se quiere medir sin fuga |
train; 50,908 Python y 8,210 Go en las tarjetas consultadas; Parquet; inglés; issue, patch, tests, repositorio e imagen ejecutable |
Tarjetas declaran MIT. Los repositorios fuente, imágenes y dependencias tienen procedencia propia; auditar antes de redistribuir. No confundir con un split de evaluación de SWE-bench. |
princeton-nlp/SWE-bench y SWE-bench/SWE-bench_Verified |
holdout/evaluación, no training: ejecutar el harness oficial con Docker; Verified es un conjunto de 500 problemas | SWE-bench test de 2,294 filas observado; Verified test de 500; Parquet; inglés; issue, repositorio, commits, patch y tests |
El repositorio oficial SWE-bench declara MIT. Los repositorios evaluados, imágenes y contenido de terceros conservan sus propios términos. Preservar la revisión del benchmark y no entrenar con patch/test_patch. |
ByteDance-Seed/Code-Contests-Plus |
training de programación/verificación o evaluación aislada de soluciones; no es dataset multi-turn de herramientas | 11,690 problemas y más de 13M soluciones correctas/incorrectas; default y configs 1x–5x, split train; Parquet; lenguaje de problemas/soluciones variable |
Tarjeta y README declaran CC BY 4.0. Los casos 1x–5x son distintos niveles de tests, no holdouts; reservar una configuración/problemas propios si se mide generalización. |
AmazonScience/SWE-PolyBench |
evaluación reservada de agentes a nivel repositorio; no incorporarlo al training Atlas | CSV; 4 lenguajes (Python, Java, JavaScript, TypeScript); repo oficial anuncia 2,110 full, 500 sampled y 382 Verified; test/predictions + Docker evaluator |
MIT declarado. La fuente oficial recomienda su evaluador y distingue full/PB500/PBv; conservar la revisión porque la tarjeta puede mostrar conteos distintos después de actualizaciones. |
bigcode/the-stack-v2 |
pretraining de código, no SFT ni benchmark de agentes; considerar sólo después del contrato de procedencia | 600+ lenguajes; dataset principal contiene SWHIDs/metadatos y la documentación describe escala de decenas de TB; acceso condicionado | No es una licencia única: la tarjeta exige aceptar términos, acuerdo para descargas masivas y cumplir las licencias originales de cada repositorio, con provenance/removals. No llamar “permissive” al conjunto completo ni redistribuirlo sin revisión legal. |
Regla práctica: OpenCodeInstruct, SWE-Gym, SWE-smith y Code-Contests+ son candidatos de training (con filtrado y separación de tests); SWE-bench y SWE-PolyBench son evaluación/holdout; The Stack v2 es pretraining/procedencia, no una solución directa para tool use. Ninguno por sí solo arregla el contrato de herramientas o el comportamiento de Codex/OpenCode.
4. Catálogo para entrenamiento (no holdout)
Las cantidades son las publicadas por la tarjeta o por la vista de Dataset Viewer; cuando la vista está deshabilitada se conserva esa limitación. No descargar sin revisar licencia, procedencia y contaminación con el holdout.
Programación
open-r1/codeforces
- Uso: problemas de programación competitiva; opción
verifiable-promptsofrece prompt y lenguaje para generación de código. Adecuado para una mezcla pequeña de Python/C++ con verificación ejecutable, no para aprender el contrato de herramientas. - Licencia/procedencia: CC-BY-4.0 declarada en la tarjeta; problemas y tests provienen de Codeforces y otros concursos, con atribución requerida.
- Formato/tamaño: Parquet; tarjeta indica unas 10k entradas. Configuraciones
default,verifiable,verifiable-prompts;trainytest. Los tests generados grandes son un artefacto separado (la tarjeta advierte ~110 GB), no parte de esta receta. - Regla: entrenar sólo
train; reservartestcomo holdout de código. Deduplicar porid/aliases y por hash de enunciado. El splittestcontiene problemas de finales de 2024/inicios de 2025 según la tarjeta; no usarlo para crear prompts. - Limitación: principalmente inglés; comprobar idioma real antes de mezclar en el lote español.
open-r1/verifiable-coding-problems-python
- Uso: SFT de generación de Python donde cada fila incluye enunciado, solución de referencia y casos de verificación.
- Licencia/procedencia: verificar la tarjeta y las licencias de los datos fuente antes de redistribuir; no asumir que “verificable” equivale a permiso irrestricto.
- Formato/tamaño: Parquet, un split
train, repositorio de aproximadamente 2.69 GB según Hub; columnas observadas por Dataset Viewer:source,task_type,problem_statement,gold_standard_solution,problem_id,metadata,verification_info. - Regla: usar una fracción train para SFT y generar un holdout propio por
problem_id/URL antes de ver respuestas; ejecutar el checker fuera del modelo. No incorporargold_standard_solutionen el prompt de entrada.
Herramientas, agentes y multi-turn
tuandunghcmut/toolace (conversión comunitaria de Team-ACE/ToolACE)
- Uso: conversaciones multi-turn de tool use en formato uniforme; buen candidato para enseñar roles
user/assistant/tooly llamadas secuenciales. - Licencia/procedencia: Apache-2.0 declarada por la conversión; el card atribuye el original a Team-ACE y unas 11,300 conversaciones sintetizadas. Revisar ambos avisos antes de publicar un derivado.
- Formato/tamaño: Parquet, inglés, 10k–100k; columnas
messagesytools_json, ambas descritas como JSON string. - Regla: parsear JSON, validar que cada
tool_call_idtenga un resultado, eliminar cadenas de razonamiento privadas y separar 90/10 por conversación, no por turno. No usar el mismo API/tool schema en train y eval si se pretende medir generalización. - Limitación: el Dataset Viewer respondió 401 durante esta auditoría; el tamaño procede de la tarjeta y no se afirma lectura de filas privadas.
product-science/xlam-function-calling-60k-raw (derivado de Salesforce xLAM)
- Uso: 60k ejemplos de function calling, útiles para single-turn, múltiples funciones y argumentos estructurados; no es multi-turn completo.
- Licencia/procedencia: Apache-2.0 en la copia derivada; el original
Salesforce/xlam-function-calling-60kdeclara CC-BY-4.0 y acceso con aceptación. Tratar la copia como derivado y conservar atribución a APIGen/Salesforce. - Formato/tamaño: Parquet;
train57k ytestaproximadamente 3k según tarjeta; columnasquery,id,answers,toolsobservadas en Viewer. La fuente original es JSON y está gated. - Regla: usar
trainsólo para enseñar llamada, argumentos y abstención. Eltestse reserva; no mezclarlo con BFCL si se publicará una cifra única sin declarar contaminación de familias.
tuandunghcmut/xlam-function-calling-60k (conversión OpenAI-compatible)
- Uso: alternativa práctica al raw:
messagesytools_jsonen una sola fila, lista para adaptar al chat template. - Licencia/procedencia: la tarjeta atribuye a
Salesforce/xlam-function-calling-60k; revisar CC-BY-4.0 del original y la licencia de la conversión. - Formato/tamaño: Parquet, 60k filas, un split
train;messagesytools_jsonson JSON strings. - Regla: usar sólo si se necesita una conversión ya normalizada; no contarla como dataset independiente junto con
product-science/xlam-function-calling-60k-raw.
ToolMind, conversión comunitaria
- Uso: corpus grande de trayectorias multi-turn con llamadas validadas; sólo después de auditar el origen de cada componente.
- Licencia/procedencia: Apache-2.0 declarada por la tarjeta comunitaria; la tarjeta dice combinar 128k trayectorias sintéticas y 152k instancias aumentadas de seis datasets. Es una afirmación del publicador, no validación primaria de cada fuente.
- Formato/tamaño: Parquet, inglés, 280k filas,
train. - Regla: no es mi primera receta por riesgo de duplicación y trazas de razonamiento explícitas. Si se usa, filtrar a salidas observables, registrar origen por fila y excluir cualquier ejemplo que reaparezca en un benchmark.
Español y multilingüe
pinzhenchen/alpaca-cleaned-es
- Uso: SFT general en español (instrucción, entrada opcional y salida).
- Licencia/procedencia: CC-BY-NC-4.0 declarada; traducción automática de
yahma/alpaca-cleaned. No usar para un producto comercial sin aclarar la cláusula NC. - Formato/tamaño: JSON; 51,760 filas; columnas
instruction,input,output, observadas en Viewer. La tarjeta advierte errores de traducción en código, tareas cruzadas y corrección gramatical. - Regla: usar como pequeño componente de estilo lingüístico, no como fuente de verdad técnica. Filtrar código defectuoso y validar manualmente una muestra.
HiTZ/alpaca_mt
- Uso: instruction tuning multilingüe; la tarjeta incluye español y otras lenguas ibéricas.
- Licencia/procedencia: CC-BY-NC-4.0; traducción con NLLB-200 3.3B desde Alpaca. Revisar cláusula NC y atribución.
- Formato/tamaño: formato de dataset con columnas Alpaca (
instruction,input,output,text); split por idioma, 52,002 ejemplos paraessegún la tarjeta. - Limitación: Viewer deshabilitado porque el repositorio requiere código arbitrario; no ejecutar
trust_remote_codesin revisión de seguridad. Es preferible convertir en un entorno aislado antes de cualquier uso.
OpenAssistant/oasst1
- Uso: conversaciones humanas multi-turn y preferencias, con español entre muchos idiomas; útil para construir estilo de diálogo, no específicamente tool use.
- Licencia/procedencia: Apache-2.0 declarada; proyecto OpenAssistant y paper enlazado.
- Formato/tamaño: Parquet y artefactos JSONL;
trainobservado con 84.4k mensajes yvalidationseparado. Cada fila contienemessage_id,parent_id,text,role,lang, revisiones y árbol de conversación. - Regla: reconstruir árboles por
message_tree_id, filtrarlang=es,deleted=false,review_result=truey deduplicar pormessage_id. No convertir mensajes sueltos en multi-turn sin preservar padres.
BSC-LT/ALIA-2606-SFT
- Uso: mezcla SFT multilingüe de 714k conversaciones; puede aportar español, multi-turn, robustez y seguimiento exacto de instrucciones.
- Licencia/procedencia: CC-BY-4.0; BSC-LT declara mezcla humana y sintética en español, catalán, inglés, euskera, gallego y parte en portugués. La tarjeta indica uso en ALIA-40b-instruct-2606.
- Formato/tamaño: tarjeta Hub indica 100k–1M, un
train, y metadatos de cinco lenguas; Viewer no estaba disponible en esta auditoría. - Regla: seleccionar sólo filas con idioma español (y una proporción explícita de otras lenguas si se desea), conservar
source/provenance y no usarlo como evaluación.
5. Holdouts y benchmarks: nunca entrenarlos
| Holdout | Qué mide | Tratamiento |
|---|---|---|
bengaliAI/BFCL / Berkeley Function Calling Leaderboard |
llamadas simples, paralelas, multi-turn y casos de no llamada; categorías con evaluación ejecutable | sólo evaluación. La tarjeta declara Apache-2.0 y 24 MB, pero advierte que no es compatible directamente con load_dataset; seguir su repositorio oficial. |
BSC-LT/IFEval_es |
541 instrucciones verificables en español (formato, longitud, palabras clave) | sólo evaluación; CC-BY-4.0; la tarjeta dice que test no debe entrenar. |
open-r1/codeforces:test |
problemas recientes de programación con tests oficiales/generados | sólo evaluación de código; separar por id y aliases. |
SpreadsheetBench verified-400 (referencia del adapter comunitario) |
trayectorias de agentes de hojas de cálculo con herramienta real | sólo si se dispone de su licencia/runner; no inferir desempeño de Ornith desde el adapter. |
| contrato local Atlas | 20–50 tareas no vistas: no-call, llamada válida, JSON inválido, error de herramienta, reintento, parada y streaming | crear antes de entrenar, versionar hashes y mantener un subconjunto final congelado. |
El error más fácil es hacer un split aleatorio por turno. Para agentes, dividir por conversation_id, tarea, herramienta y dominio; de lo contrario el modelo ve la misma trayectoria o esquema en train y test.
6. Formato canónico JSONL para SFT
Preferir mensajes OpenAI-compatible y aplicar el chat template del checkpoint, no concatenar etiquetas manuales. Ejemplo mínimo (tres filas):
{"id":"es_001","messages":[{"role":"system","content":"Responde en español. Usa herramientas sólo cuando sean necesarias."},{"role":"user","content":"¿Qué archivos hay en /tmp?"},{"role":"assistant","tool_calls":[{"id":"call_001","type":"function","function":{"name":"list_dir","arguments":"{\"path\":\"/tmp\"}"}}]},{"role":"tool","tool_call_id":"call_001","content":"{\"entries\":[\"a.txt\"]}"},{"role":"assistant","content":"En /tmp hay un archivo: a.txt."}],"tools":[{"type":"function","function":{"name":"list_dir","description":"Lista un directorio","parameters":{"type":"object","properties":{"path":{"type":"string"}},"required":["path"],"additionalProperties":false}}}]}
{"id":"es_002","messages":[{"role":"user","content":"Resume este texto en dos frases: ..."},{"role":"assistant","content":"Primera frase. Segunda frase."}]}
{"id":"es_003","messages":[{"role":"user","content":"¿Puedes borrar todo?"},{"role":"assistant","content":"No llamo a una herramienta porque falta una ruta y una confirmación explícita."}]}
Validaciones obligatorias antes de tokenizar:
- roles permitidos y alternancia; cada
tool_call_iddebe tener untoolposterior; argumentsdebe ser JSON parseable y ajustarse al schema;- no incluir secretos, tokens, mensajes de usuario reales ni razonamiento privado;
- verificar que
toolsy la plantilla de chat que se sirven sean idénticos a los del contrato; - enmascarar pérdida a tokens del asistente/tool-call (no optimizar sólo por una respuesta final copiada).
Para datos Alpaca, convertir instruction/input/output a user/assistant y conservar id/provenance. Para BFCL, conservar el runner oficial y no convertirlo silenciosamente a SFT.
7. Preparar un dataset sintético pequeño y auditable
Empieza con 30–100 conversaciones, no con cientos de miles. Diseña 10 familias de casos: no-call, llamada simple, argumentos opcionales, llamada paralela, dos turnos dependientes, resultado vacío, error transitorio/retry, error permanente, salida truncada y finalización. Genera variantes de nombres/valores sin poner credenciales reales. Cada fila debe tener source="synthetic_atlas_v46", generator_version, tool_schema_hash, expected_calls y split.
Proporción inicial sugerida (hipótesis a medir, no garantía): 50% tool-call válido, 20% no-call, 15% recuperación/error, 10% multi-turn, 5% español técnico. Congela 20% como validación y 20–30 ejemplos finales como holdout escrito por una persona distinta al generador. Un modelo maestro puede proponer candidatos, pero un validador determinista debe rechazar JSON inválido y llamadas que no satisfagan el estado.
El script datasets-examples/prepare_synthetic.py sólo genera una muestra local de demostración y valida estructura; no llama a una API, no descarga nada y no debe tratarse como dataset de producción.
8. Receta PEFT/QLoRA: primero verificar targets reales
Actualización v4.7: la guía específica Qwen3.5 de Unsloth desaconseja actualmente QLoRA de 4 bits para esta familia. La receta genérica anterior no está validada para Ornith. Empieza por la guía revisada LoRA BF16 y una prueba de un paso, no por un entrenamiento largo. El kit nuevo rechaza la ruta NF4 del trainer histórico. No se ejecutó entrenamiento GPU.
8.1 9B denso
PEFT documenta target_modules="all-linear" como opción genérica QLoRA, pero aquí no se usa como atajo automático: en un modelo multimodal puede incluir visión y en Qwen3.5 las capas son híbridas. El código oficial define self_attn.q_proj/k_proj/v_proj/o_proj, mlp.gate_proj/up_proj/down_proj y, para atención lineal, linear_attn.in_proj_qkv/in_proj_z/in_proj_b/in_proj_a/out_proj. No afirmar que todos existen en cada capa ni que todos sean seguros para un adapter sin enumerar named_modules() en la versión exacta de Transformers.
Secuencia recomendada:
- cargar
AutoConfigy confirmarmodel_type,architecturesy versión de Transformers; - cargar el modelo en el entorno de entrenamiento y ejecutar
verify_targets.py; - empezar con targets explícitos de módulos
nn.Linearque sí aparezcan en el tronco textual, excluyendo cualquier nombre que contengavisual,vision,merger,projectororouter; el ejemplo conserva rutas completas, no sólo sufijos comoq_proj, porque un sufijo podría coincidir también en visión; no usarall-linearen la receta Atlas; - congelar visión al principio salvo que la tarea sea multimodal; si se entrena visión, crear un experimento separado y medir regresión textual;
- estudiar primero LoRA BF16. La ruta genérica NF4 queda suspendida por la advertencia de compatibilidad; no es una alternativa automáticamente aprobada si BF16 no cabe.
datasets-examples/train_qlora.pydel kit v4.7 exige--bf16para entrenar y sigue sin validación GPU; - guardar
adapter_config.json, lista de targets encontrados, versiones, seed, longitud, batch efectivo ytrainable_parameters.
Punto de partida experimental (no garantía): r=16–32, alpha=2r, dropout 0.05, bias="none", loss sólo en assistant/tool-call, longitud inicial hasta 256 tokens para el primer smoke test. Subir longitud únicamente tras comprobar calidad y memoria.
8.2 35B-A3B MoE
El config.json oficial confirma 256 expertos, top-8 y 40 capas. En el código Transformers Qwen3.5-MoE, los expertos no son nn.Linear: mlp.experts.gate_up_proj y mlp.experts.down_proj son nn.Parameter 3-D; el router es mlp.gate.weight; el experto compartido sí tiene gate_proj/up_proj/down_proj y shared_expert_gate es lineal. PEFT documenta que estos parámetros requieren target_parameters, no simplemente target_modules. Aunque shared_expert_gate sea lineal, queda fuera de la allowlist inicial del script; sólo se debe estudiar en un experimento explícito y separado.
Por eso no copiar la receta del 9B. Primera corrida segura: adaptar sólo q_proj/v_proj/o_proj de atención full y/o linear_attn lineales que el script confirme, dejando expertos y router congelados. Segunda corrida aislada: añadir los parámetros expertos sólo si la versión de PEFT y el modelo pasan un smoke test de forward/backward, con rank por experto explícito y presupuesto de parámetros. No entrenar el router en la primera prueba: puede cambiar el balance de expertos y no se puede atribuir una regresión.
El adapter community ciocan/ornith-1.5-9b-spreadsheetbench-lora demuestra una receta concreta para el 9B (all-linear, rank 32, alpha 64, dropout 0.05, BF16, 32k, 2 épocas, loss assistant-only, un H100), pero esa configuración se conserva como evidencia comunitaria, no como receta Atlas: no sabemos por esa tarjeta si su all-linear envolvió sólo texto o también módulos multimodales. No copiarla automáticamente al MoE 35B. Su propia evaluación reporta regresión frente a un harness fuerte; debe leerse como advertencia de que un adapter puede reducir bucles sin arreglar el contrato.
Bibliotecas
- PEFT: adaptación y guardado de adapters; fuente primaria para
target_modules="all-linear",target_parametersMoE y quantization/LoftQ. - TRL:
SFTTrainer, integración PEFT y trainers de preferencia; usar el chat template y collator de pérdida assistant-only, validando firmas de la versión instalada. - Transformers + bitsandbytes: carga QLoRA; confirmar que la clase
Qwen3_5*ForConditionalGenerationy la versión exigida por el checkpoint están presentes. - Axolotl: orquestación YAML SFT/LoRA/QLoRA. Sus guías sirven como plantilla, pero una guía de Qwen3.5 no es prueba de soporte para el checkpoint Ornith; comprobar el model type localmente.
- Unsloth: alternativa rápida de entrenamiento. Tratar compatibilidad con Ornith multimodal/híbrido/MoE como no verificada hasta un smoke test; no asumir que una receta Llama/Qwen densa se transfiera.
- LLaMA-Factory: opción adicional para datasets OpenAI/ShareGPT; el mismo principio: validar clase, template, targets y máscara de pérdida.
Ninguna de estas bibliotecas garantiza que un modelo entrenado conserve streaming, parser, MTP, visión, speculative decoding o serving vLLM/SGLang. La prueba de aceptación debe ejecutar la ruta real.
Contrato de versiones del ejemplo
El config.json oficial de Ornith 1.5-9B declara transformers_version=5.12.1; esto es una pista de compatibilidad del checkpoint, no una orden de instalar esa versión a ciegas. El script comprueba en tiempo de ejecución las firmas y capacidades que necesita: clase AutoModelForImageTextToText, LoraConfig.target_parameters para expertos 3-D, SFTConfig.assistant_only_loss y SFTTrainer.processing_class (o el nombre legado tokenizer). Si una versión no expone alguno, termina con FAIL-CLOSED antes de entrenar. No se instaló ningún paquete ni se generó un lock de Python en esta auditoría; antes de una corrida se debe capturar pip freeze del entorno aislado junto con la revisión del checkpoint y anotar las fuentes primarias en sources-datasets.json.
El ejemplo datasets-examples/test_train_qlora_cpu.py valida en CPU la clasificación denso/MoE, los filtros de visión/router y el rechazo de JSONL inválido. No sustituye el forward/backward de una muestra en GPU; ese smoke sigue pendiente y no se deben prometer VRAM o compatibilidad por lectura de una receta.
9. Evaluación antes/después
Registrar una línea base congelada antes de tocar datos:
- Contrato: 20–50 casos Atlas, temperatura 0, mismo template y parser; exactitud de no-call, schema, nombre, argumentos,
call_id, número de turnos, recuperación y parada. - Herramientas: BFCL oficial para categorías comparables, con exact match/AST y ejecución; nunca reemplazar el runner por un
json.loadscasero sin decirlo. - Español: IFEval_es y un set humano pequeño de respuestas técnicas, midiendo instrucción, idioma, estructura y factualidad.
- Código: Codeforces
testo un conjunto propio de problemas no vistos; compilar/ejecutar con sandbox, timeout y tests ocultos. - Regresión general: 20 prompts de conversación y 20 prompts multimodales si se conserva visión.
Para cada corrida guardar pass rate, errores por categoría, longitud de salida, llamadas válidas/invalidas, latencia y memoria pico. Comparar base/adaptador/merged sólo con el mismo seed, prompt, max tokens y servidor. train loss menor no prueba que la herramienta funcione.
10. Distilación maestro→alumno
Separar dos escenarios:
- 35B-A3B maestro → 9B denso alumno: útil si el objetivo es reducir coste de serving. Destilar salidas observables: respuesta final, decisión de llamar, nombre/argumentos canónicos, resultados de herramienta y recuperación. Para tareas de código, conservar tests y no destilar soluciones inválidas. No prometer que el 9B herede visión, contexto, MTP o razonamiento sólo por ver textos del maestro.
- 9B maestro → 35B-A3B alumno: sólo tiene sentido para un comportamiento de contrato muy estrecho o una tarea específica; el alumno es mayor y el coste de entrenamiento puede no justificarse. Usar el mismo conjunto de tareas y un holdout independiente para confirmar que no se aprendió la idiosincrasia del 9B.
Como las arquitecturas son distintas, empezar con response distillation/SFT: maestro genera una trayectoria y el validador conserva únicamente mensajes visibles, tool calls y resultados. Tokeniza la salida del maestro con el tokenizer del alumno y entrena sobre esos IDs; no intentes copiar IDs ni logits del maestro. Añadir KL/logit distillation sólo si los dos tokenizers tienen vocabulario, merges, special tokens y mapeo de posiciones verificados byte a byte; si difieren, la receta correcta es distilación de respuesta/sequence-level, no KL ingenua. MiniLLM y su código son referencias primarias para distilación de modelos de lenguaje, no una receta Ornith ya validada.
Para agentes, el conjunto de distilación debe conservar casos negativos (no llamar) y errores; si sólo se conserva la trayectoria exitosa del maestro, el alumno puede llamar de más y atascarse. No publicar cadenas de pensamiento privadas del maestro; usar etiquetas observables (tool_name, arguments, outcome, final_answer) y un resumen corto de razón sólo si forma parte del contrato.
Ejemplo practicable: teacher → dataset filtrado → QLoRA
El encabezado se conserva para no romper enlaces antiguos. La recomendación v4.7 es SFT/LoRA BF16 experimental; no ejecutar NF4 como receta validada.
datasets-examples/distill_answers.py implementa el primer tramo sin descargar pesos ni ejecutar herramientas. El JSONL de entrada contiene id, mensajes system/user y un expected literal escrito por el validador. Por defecto el script sólo valida localmente y no abre red:
python datasets-examples/distill_answers.py \
--input datasets-examples/distill_fixture.jsonl \
--base http://127.0.0.1:9000/v1 \
--model TU_MAESTRO_VERIFICADO \
--output /tmp/distill-validated.jsonl \
--validate
La validación rechaza contenido distinto del literal o finish_reason diferente de stop. Para generar respuestas visibles desde un endpoint OpenAI-compatible propio hay que pedirlo explícitamente; la llave se lee únicamente de ATLAS_TEACHER_KEY, el límite es pequeño (--max-samples≤8, --max-tokens≤512) y el fichero de salida nuevo nunca se sobreescribe:
read -r -s -p 'Llave del endpoint maestro: ' ATLAS_TEACHER_KEY
export ATLAS_TEACHER_KEY
python datasets-examples/distill_answers.py \
--input prompts-atlas.jsonl --base http://127.0.0.1:9000/v1 \
--model TU_MAESTRO_VERIFICADO --output runs/teacher-pass.jsonl \
--generate --max-samples 4 --max-tokens 256
El puerto 9000 es un ejemplo, no un maestro ya instalado. Consulta /v1/models y confirma el checkpoint detrás del alias; no atribuyas el 35B-A3B al vLLM 9B que observamos en 8122. Usa HTTPS para un maestro remoto o un túnel SSH a localhost. Nunca pongas claves en la URL; el helper rechaza credenciales/query en --base.
Sólo las respuestas visibles que pasan el checker se escriben como mensajes assistant; no se copia la respuesta HTTP cruda ni campos de razonamiento privado. Cada fila conserva hash de los mensajes de entrada, modelo/base del teacher, finish_reason y tokens reportados. Después se puede pasar ese JSONL a datasets-examples/train_qlora.py --check/--train junto con el checkpoint local del alumno. Esto es una receta de contrato estrecho, no evidencia de que la destilación mejore Codex/OpenCode; el holdout debe permanecer separado y la prueba GPU sigue pendiente.
Prueba offline:
python datasets-examples/test_distill_answers_cpu.py
11. Adaptadores LoRA comunitarios: encontrados y no confirmados
Resultados de una búsqueda acotada en Hub; «no confirmado» no significa «no existe».
- Encontrado y base exacta 1.5-9B:
ciocan/ornith-1.5-9b-spreadsheetbench-lora. La tarjeta declara PEFT, baseornith-ai/Ornith-1.5-9B, 282 trayectorias de entrenamiento y 118 tareas held-out. Es un adapter real compatible por identidad de base, pero su objetivo SpreadsheetBench y su recetaall-linearno son prueba de la receta Atlas. - Encontrados pero base 1.0, no reutilizar automáticamente:
khudgins/Ornith-1.0-9B-ThinkingCapykhudgins/Ornith-1.0-35B-ThinkingCap. La tarjeta describe adapters LoRA sobre Ornith 1.0; no son sustitutos de Ornith 1.5. - Arquitectura vecina, base no Ornith:
manifesta/scientific-chart-qa-lora-qwen3.5-9bdeclara base Qwen/Qwen3.5-9B. Puede servir para comparar un adapter Qwen3.5, pero no debe cargarse sobre Ornith sin prueba de arquitectura, tokenizer y base exacta. - 35B-A3B 1.5: en los resultados revisados no confirmé un repositorio que declare ser un adapter PEFT sobre
ornith-ai/Ornith-1.5-35B-A3B; aparecieron cuantizaciones, merges y derivados. No se concluye que no exista: se requiere inspección deadapter_config.jsonybase_model_name_or_pathde cada candidato antes de citarlo.
Un adapter sólo es reutilizable si adapter_config.json declara la misma base/revisión (o se demuestra equivalencia), targets que existen en el model tree y tokenizer/template compatible. El modelo descargable o una página «fine-tuned» no prueba que el repositorio contenga un adapter separado.
12. Memoria y coste: lo que sí y no se puede afirmar
No doy cifras garantizadas de VRAM. La memoria depende de pesos BF16/4-bit, optimizador, rank y targets, activaciones, longitud, gradiente, checkpointing, visión, número de expertos activos, fragmentación y versión de kernels. Un MoE con 3B activos por token no implica que sólo haya que cargar 3B de pesos: los 35B y sus estados pueden dominar memoria. Un contexto configurado de 262k no demuestra que una corrida de entrenamiento o tres secuencias de esa longitud sean viables.
Medir por experimento: memoria antes/después de carga, pico forward, pico backward/optimizer, tokens/s, batch efectivo, longitud y si hubo offload/OOM. Cambiar una variable cada vez: 9B/35B, BF16/QLoRA, rank, targets, longitud, batch, checkpointing.
13. Vídeos útiles encontrados
Los adjuntos sólo aportan el corpus de vídeos ya auditado y no un dataset. Como apoyo comunitario —no evidencia primaria de compatibilidad Ornith— la matriz r2/r3 contiene:
- How to Fine-Tune LLMs for AI Agents: SFT and QLoRA Guide using Unsloth: procedimiento educativo; el propio registro dice que no prueba Ornith.
- Steps By Step Tutorial To Fine Tune LLAMA 2 With Custom Dataset Using LoRA And QLoRA: conceptos reproducibles en Llama 2, no targets Ornith.
- Mastering LLM Fine-Tuning with QLoRA: contexto comunitario; no usar cifras como evidencia.
- How they built Gorilla: contratos de API/BFCL; apoyar afirmaciones con el proyecto Gorilla/BFCL.
14. Límites y siguientes pasos seguros
Pendiente antes de cualquier entrenamiento: fijar revisión de licencias y PII, construir el contrato Atlas y su holdout, instalar versiones en un entorno separado, ejecutar sólo verify_targets.py sobre los checkpoints ya disponibles, hacer forward/backward de una muestra minúscula y comparar contra la línea base. No se debe presentar ningún resultado de calidad, memoria, compatibilidad de Unsloth/Axolotl, ni mejora de Codex/OpenCode hasta ejercer la ruta completa.
Agentes reales, MCP propio y pruebas de velocidad
El modelo, el servidor y el programa que lo usa son tres componentes distintos. Entrenar un LoRA no corrige automáticamente un contrato HTTP incompatible, una plantilla equivocada o un cliente que interpreta mal el streaming. Este taller empieza por el endpoint instalado y termina con una herramienta propia que exige tu llave.
Material del taller: kit de réplica y ejemplos. No contiene credenciales. Las pruebas nuevas son sintéticas y acotadas; no se reinició ni reconfiguró llama.cpp.
1. Línea base comprobada en GPU 0
El 23 de septiembre se ejecutó examples/canary.py contra el mismo ornith-local servido por llama.cpp. La salida está en canary-gpu0.json dentro del kit.
| Caso | Resultado | Tiempo observado |
|---|---|---|
| Chat | stop, contenido CANARIO_OK |
351 ms |
| Primera herramienta | tool_calls, JSON exacto 17 + 25 |
672 ms |
| Segunda herramienta | tool_calls, JSON exacto 42 + 8 |
574 ms |
| Continuación | stop, respuesta con 50 |
535 ms |
| Historial | recupera HISTORIAL_OK | 388 ms |
| Streaming | contenido STREAM_OK, stop y [DONE] |
255 ms al primer texto, 283 ms total |
Estos son seis ejemplos cortos, con elección de herramienta forzada y sumas puras ejecutadas por el test. No prueban selección autónoma de herramientas, desempeño en un repositorio ni latencia p95. La segunda llamada aprovechó caché; no se compara como si fuera una primera solicitud fría. Para repetir:
python3 examples/canary.py --base http://127.0.0.1:8120/v1 \
--model ornith-local --out prueba-nueva.json
El archivo de salida debe ser nuevo. Si hay autenticación en tu proxy, establece ATLAS_API_KEY mediante tu gestor de secretos; el ejemplo la lee del entorno. El endpoint actual inspeccionado no exige esa llave. Poner apiKey: local-no-auth en un cliente no protege un servidor abierto.
2. OpenCode: sí existe un perfil real
La búsqueda inicial en el directorio predeterminado fue insuficiente. Recuperamos /home/lab/bench/ornith/opencode-lab/config/opencode.json y env.sh. El perfil apunta a http://127.0.0.1:8120/v1, usa local-ornith/ornith-local y declara herramientas, contexto 262144 y salida 16384. El servidor observado limita su salida a 4096: esa diferencia se debe revisar, no atribuir al modelo.
El esquema de la CLI instalada 2.0.5 usa providers → package: @opencode/ai/providers/openai-compatible → settings. El archivo recuperado está completo en evidence/historical/opencode-lab/config/opencode.json. La documentación web consultada presenta otro esquema (provider, npm, options); no mezcles ambos a ciegas. Valida contra la versión que instalaste. Proveedores de OpenCode.
Para reproducir el contexto histórico en la réplica, restaura los archivos en su ruta o adapta todos los paths del env.sh, luego:
source /home/lab/bench/ornith/opencode-lab/env.sh
opencode --version
opencode run --help
opencode run --standalone --format json \
--model local-ornith/ornith-local \
'No uses herramientas. Responde exactamente OPENCODE_CANARIO_OK.'
env.sh cambia de directorio. OPENCODE_CONFIG_DIR es opencode.d, mientras OPENCODE_CONFIG apunta al JSON de config/. Los datos/caché se aíslan con variables XDG. No ejecutes el wrapper histórico ornith-opencode-final.sh para esta prueba: recrea contenedores y termina procesos.
Reproducción nueva superada: OpenCode 2.0.5 se ejecutó con ese proveedor, configuración original de sólo lectura y directorio/caché temporales separados. Emitió el evento de texto OPENCODE_CANARIO_OK y terminó con código cero; el intervalo entre eventos de inicio y texto fue aproximadamente 1.3 segundos (no incluye todo el arranque de la CLI). Esta prueba cubre chat mediante el adaptador real, no herramientas autónomas ni edición de repositorios.
Hay registros históricos de seis tareas concurrentes que terminaron con código de salida cero, entre 139 y 271 segundos. Eso demuestra que hubo una integración ejecutada, pero no sustituye revisar los archivos generados y sus tests. Tampoco permite decir que el modelo “no funciona en OpenCode”. El estado de la reproducción nueva queda en el informe de verificación del kit.
3. Codex: Responses directo no es todavía Codex completo
La configuración predeterminada encontrada usa gpt-5.6-terra; no apuntaba a Ornith. La CLI instalada es 0.154.0. Se lanzó un canario efímero, con directorio temporal, sandbox de sólo lectura y --ignore-user-config, usando un proveedor local explícito. No se cambió la cuenta ni el archivo de configuración del usuario.
Un POST directo a /v1/responses terminó con HTTP 200, estado completed y texto visible RESPONSE_OK. Sin embargo, la prueba de Codex real falló: primero registró metadatos de modelo incompatibles (missing field slug al refrescar /models), después cinco reconexiones y un error genérico. No se ha aislado la causa exacta de esas reconexiones. No llamar a esto “modelo incapaz” ni “adaptador validado”.
La documentación actual define wire_api="responses". El perfil de laboratorio, pasado sólo en la invocación, fue:
model = "ornith-local"
model_provider = "ornith_atlas"
[model_providers.ornith_atlas]
name = "Ornith Atlas probe"
base_url = "http://127.0.0.1:8120/v1"
wire_api = "responses"
requires_openai_auth = false
supports_websockets = false
Esto describe la prueba fallida, no una configuración promovida. Próxima prueba: trazar estados y tipos de eventos de Responses, sin guardar secretos ni razonamiento privado; comparar el contrato que exige esta versión de Codex con el que entrega este commit de llama.cpp. Después probar una tarea de código con checker. Cambiar los pesos antes de resolver el transporte haría más difícil atribuir el fallo. Referencia oficial de configuración.
4. DeepSeek Harness y habilidades
También existe /home/lab/.dsh/profiles/web; no era correcto concluir que no había Harness por no encontrarlo en otras rutas. El kit incluye su package.json y el manual de panel y terminales. Un paquete instalado o un puerto abierto no demuestra la ejecución completa de herramientas desde el navegador.
Para probar cualquier harness, usa la misma progresión: mensaje simple → una herramienta sin efectos externos → resultado → segunda herramienta → historial → SSE → tarea de código con tests → cancelación/reintento. Guarda versión del cliente, plantilla, modelo, solicitud anonimizada, resultado del checker y terminación. Las instrucciones/skills ayudan a encaminar el agente; el dataset debe enseñar contratos y recuperación de errores, no sólo respuestas bonitas.
Práctica propuesta: en un repositorio de pruebas, pedir implementar normalizar_nombre, comprobar espacios, acentos y entrada vacía con tests preparados antes. Repetir baseline y candidato con la misma tarea. No ejecutar código generado con acceso a credenciales, shell de producción o directorios personales. La lección de datasets explica cómo separar entrenamiento y evaluación.
5. Crear un MCP propio con autenticación
agent-examples/mcp_server.py implementa dos herramientas: sumar y perfiles_documentados. La segunda devuelve un inventario fechado con live:false: no finge consultar la GPU. No tiene shell, escritura de archivos ni control de servicios. Usa el SDK oficial MCP 2.2.0, HTTP en localhost y una barrera Bearer que rechaza solicitudes sin la llave.
python3 -m venv .venv-mcp
.venv-mcp/bin/pip install -r agent-examples/requirements.txt
cd agent-examples
../.venv-mcp/bin/python -m unittest -v test_mcp.py
# bash: introduce una llave aleatoria de al menos 24 caracteres sin mostrarla.
read -r -s -p 'Llave MCP: ' ATLAS_MCP_KEY
printf '\n'
export ATLAS_MCP_KEY
../.venv-mcp/bin/python mcp_server.py
Mantén esa terminal abierta. En otra, introduce la misma llave, expórtala y realiza la inicialización:
curl --fail-with-body http://127.0.0.1:8766/mcp \
-H "Authorization: Bearer $ATLAS_MCP_KEY" \
-H 'Content-Type: application/json' \
-H 'Accept: application/json, text/event-stream' \
-d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"atlas-curl","version":"1"}}}'
Después de inicializar, el cliente MCP normal envía notifications/initialized. Para esta demostración HTTP sin estado de sesión, puedes enviar esa notificación con el mismo encabezado y luego consultar:
curl --fail-with-body http://127.0.0.1:8766/mcp \
-H "Authorization: Bearer $ATLAS_MCP_KEY" \
-H 'Content-Type: application/json' \
-H 'Accept: application/json, text/event-stream' \
-H 'MCP-Protocol-Version: 2025-06-18' \
-d '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"sumar","arguments":{"a":17,"b":25}}}'
Resultado esperado: 42. Repite sin Authorization: debe devolver 401. No metas la llave en la URL, los prompts, el HTML, el repositorio o el ZIP. En un host multiusuario, evita además exponerla en argumentos visibles del proceso: usa el cliente MCP/gestor de secretos o un archivo temporal de configuración curl con permisos 0600. Al terminar, detén este servidor con Ctrl+C y unset ATLAS_MCP_KEY.
Este Bearer compartido es una demostración para tu laboratorio privado, no una implementación del flujo OAuth de autorización MCP para terceros. Para acceso remoto conserva el bind local y usa un túnel SSH; para un servicio multiusuario añade identidad, permisos por herramienta, expiración/rotación, TLS, cuotas y auditoría. Validar Origin/Host protege frente a DNS rebinding, no sustituye autenticación. Transportes MCP, SDK oficial.
6. Las cinco pruebas del MCP que sí se ejecutaron
Se ejecutó el servidor mediante su cliente de pruebas local, sin exponer un servicio en ia-lab: sin llave 401; llave incorrecta 401; initialize/list/call correctos y suma 42; Origin ajeno 403; ausencia de secreto impide arrancar. No se ha añadido este MCP a tus perfiles personales ni se ha probado una llamada autónoma desde OpenCode, Codex o DSH.
Para conectarlo después, registra una herramienta HTTP local en el cliente y pasa la llave desde su mecanismo de secretos. Primero confirma tools/list, luego sumar, después una herramienta real de sólo lectura. Que un curl funcione no prueba que el harness esté usando el mismo transporte y encabezados.
7. Responder rápido: qué medir y qué cambiar
No optimices sólo tokens por segundo. Mide primer texto visible, latencia completa de herramienta, exactitud, cancelación y percentiles con carga repetida. Separa solicitudes frías/calientes y contexto 8K/32K/128K. Un modelo que contesta rápido pero omite una herramienta o rompe el schema no cumple la tarea.
Mantén cargado un único baseline por GPU, usa schemas pequeños, no incluyas catálogos de cientos de herramientas, reutiliza conexiones y prefijos idénticos cuando proceda. Comprueba que cada cambio realmente usa el backend esperado. En esta entrega no se alteraron potencia, memoria, caché, concurrencia ni parámetros del servicio activo para prometer velocidad.
Orden de experimentos: arreglar transporte/plantilla → medir el perfil actual → variar una opción de contexto/KV/batching → comprobar calidad → evaluar distillation/LoRA/pruning por separado. MTP y DFlash son rutas distintas y no se activan por tener descargado un archivo. Conserva un resultado negativo: también evita repetir una receta que ya falló.
Descargas, fuentes y respaldo del Atlas
No es necesario depender de un repositorio para conservar el sitio. Estos paquetes tienen propósitos distintos y no contienen contraseñas, claves privadas ni pesos del modelo.
Qué descargar
| Paquete | Contenido | Qué no contiene |
|---|---|---|
| Kit ia-lab v4.7 | Manual, código educativo, configuración saneada, perfiles y resultados históricos recuperados, investigación nueva | Pesos GGUF/safetensors, imágenes Docker, sistema operativo o credenciales |
| Investigación y código | Destilación CPU, poda/cuantiización educativa, preparación de datos, prueba LoRA opt-in, fuentes y vídeos | Entrenamiento GPU validado; no instala modelos |
| Atlas offline | Páginas, imágenes, código público y audios alojados por Atlas; servidor local incluido | Vídeos de terceros y ZIP históricos duplicados; esas descargas se enlazan a la web |
| Respaldo web restaurable | Instantánea del contenido estático, incluidos ZIP históricos, fuentes editoriales, manifiesto y restaurador | TLS, DNS, proxy externo, llaves, servicios de ia-lab; no se incluye a sí mismo ni al ZIP offline nuevo |
| Fuentes editoriales | Markdown, catálogos, menús, scripts de construcción y evidencias saneadas de esta actualización | Repositorio Git remoto: no se creó ni se subió uno |
Los tamaños exactos y SHA-256 aparecen en el inventario de descargas. Se conservan las descargas anteriores para no romper enlaces guardados. El kit v4.6 es histórico: la lectura recomendada es v4.7.
Encontrar un archivo dentro del kit
Abre Buscar archivos y rutas. Busca ornithctl.py, summary.json, sglang, p4 o una parte de la ruta. Cada resultado diferencia la ruta del servidor, el miembro exacto del ZIP y la descarga directa.
Por ejemplo:
- Servidor ia-lab:
/home/lab/bench/ornith/modular/control/ornithctl.py. - ZIP extraído:
ia-lab-replica-v4.7/evidence/historical/modular/control/ornithctl.py. - Tu Mac/PC: la carpeta donde extraigas el kit, seguida de esa ruta relativa. No existe una ruta local absoluta universal.
- Atlas remoto:
/srv/ornith-atlas-v3/currentapunta a la release web activa en otro host. Restaurar ia-lab no restaura ese sitio.
Los archivos evidence/historical/ son referencia: algunos cambian perfiles o paran procesos. Que puedan descargarse no significa que debas ejecutarlos en producción.
Consultar el Atlas sin Internet
Extrae el ZIP offline y abre una terminal dentro de la carpeta extraída:
python3 servir_local.py
Abre http://127.0.0.1:18764/. El servidor sólo escucha en tu equipo; detenlo con Ctrl+C. No reemplaza nginx, no usa puertos de inferencia y no configura TLS. La navegación y los audios incluidos se sirven localmente. Los vídeos de YouTube y demás fuentes externas necesitan Internet. El funcionamiento completo se comprueba mediante HTTP local, no abriendo arbitrariamente archivos file://.
Restaurar la web en una carpeta nueva
El respaldo contiene restaurar_atlas.py, PAYLOAD.sha256, README-RESTAURAR.md, un ejemplo nginx y el directorio web/. Después de extraerlo, verifica el contenido sin copiarlo:
python3 restaurar_atlas.py --destino /RUTA/NUEVA/atlas-restaurado
El modo predeterminado comprueba los hashes y muestra el plan. Para copiar la instantánea:
python3 restaurar_atlas.py --destino /RUTA/NUEVA/atlas-restaurado --restaurar
El destino debe ser nuevo: el restaurador rechaza sobrescribir una carpeta existente, el origen y sus descendientes. No modifica DNS, TLS, nginx ni el enlace current. Primero comprueba la réplica en un puerto local. La activación pública exige configurar el nuevo host/proxy y verificar rutas, RSS y audio con HTTPS. El archivo nginx es una plantilla, no la configuración secreta del despliegue.
La comprobación de esta entrega restaura el paquete en un directorio temporal y consulta páginas/recursos por HTTP local. Eso prueba el respaldo estático, no una reinstalación de ia-lab, del hipervisor ni de la infraestructura TLS/DNS.
Preservar y versionar
Antes de reinstalar ia-lab guarda aparte imágenes Docker propias, modelos, datos permitidos, locks y configuración privada. El manifiesto detecta archivos alterados, pero no sustituye una copia externa del disco. Conserva al menos un respaldo fuera del host que vas a borrar.
Puedes llevar las fuentes editoriales a tu propio repositorio. Los audios y archivos grandes pueden mantenerse como descargas versionadas. Esta actualización no creó un repositorio ni publicó datos en GitHub.