Programar pesos: la tercera palanca para los LLM

El descenso de gradiente nunca fue sagrado. Era un andamio: la única herramienta general que teníamos para moldear miles de millones de números que ningún humano puede leer, así que construimos toda la religión del deep learning alrededor de ella. Un equipo del MIT CSAIL acaba de tirar el andamio. Le dieron a un modelo de frontera los pesos crudos de redes neuronales entrenadas y le pidieron, en lenguaje natural, que las explicara, depurara y reescribiera, sin bucle de entrenamiento, sin gradientes y sin pasadas hacia adelante. Funcionó. La programación en el espacio de pesos, razonar directamente sobre los parámetros en lugar de empujarlos cuesta abajo, ha pasado de experimento mental a demo, y creo que degrada en silencio el fine-tuning de «la forma en que adaptamos modelos» a una opción entre tres.

El resultado principal merece el revuelo que está generando. Al pedirle que mejorara Qwen3.5-0.8B en matemáticas sin ninguna actualización de gradientes, el modelo —GPT-6 Astra— rastreó un bucle patológico de razonamiento hasta una única dirección escrita en dos capas MLP, la restó de 0,016% de los pesos y elevó la precisión en MATH-500 del 7,9% al 48,1%. Mismos ajustes de muestreo, todo igual. La corrección incluso se transfirió al seguimiento de instrucciones, triplicando IFEval. Eso no es un ajuste de hiperparámetros; es cirugía. Pero antes de enterrar el descenso de gradiente, conviene ser precisos sobre lo que realmente se demostró, dónde generaliza y dónde ya falla.

Qué es realmente la programación en el espacio de pesos

Durante años hemos tenido exactamente dos formas de cambiar lo que hace un modelo. El prompting cambia la entrada; los pesos quedan congelados. El fine-tuning cambia los pesos, pero a ciegas: le muestras al paisaje de pérdida un lote de ejemplos y dejas que los gradientes empujen los parámetros en la dirección que reduzca el error, con poco control sobre qué maquinaria interna se reconecta en el proceso. La programación en el espacio de pesos propone una tercera palanca: olvidar por completo la función de pérdida y hacer que un sistema de razonamiento lea los pesos, formule una hipótesis sobre lo que calculan y los edite para ajustarse a una especificación en lenguaje natural.

La parte más inquietante son los resultados de lectura. Los investigadores entrenaron cuatro políticas diminutas con PPO para jugar versiones en cuadrícula de Breakout, Pong, Pac-Man y Freeway: arquitecturas idénticas, mismos canales de entrada, mismos espacios de acción, así que solo los pesos podían distinguirlas. Astra nombró correctamente los cuatro juegos sin que le dieran la lista de candidatos. Hizo lo mismo con modelos de difusión entrenados para generar círculos, cuadrados y triángulos y, en la versión difícil, identificó cuál de tres transformers a nivel de carácter había sido entrenado en Python, inglés o japonés romanizado, usando solo las capas intermedias, con embeddings y capas de salida eliminadas y cada dimensión sin etiquetar. De paso localizó todas las induction heads, los circuitos de copia que permiten a un modelo repetir texto anterior, multiplicando matrices de pesos. Es una técnica conocida de la literatura de interpretabilidad que nadie le había explicado. Si has seguido el lento trabajo de la interpretabilidad mecanicista, ver a un modelo de propósito general hacerlo de forma nativa produce un cierto vértigo.

Luego escribió pesos. Dado un controlador de coche entrenado con PPO atascado en un mínimo local —la política conducía directamente hacia una rampa en lugar de retroceder primero para ganar velocidad—, Astra diagnosticó el fallo a partir de los pesos y de un único episodio registrado, y su edición hizo que el coche tuviera éxito en los 1.024 episodios de evaluación tras cambiar el 3,5% de los parámetros. Al pedirle que escribiera redes para jugar desde cero, sin ningún feedback del entorno, produjo políticas que superaban a redes entrenadas con PPO durante 100 millones de pasos. Léelo otra vez: sin interacción, sin señal de recompensa, solo una descripción en lenguaje natural de un juego compilada en pesos funcionales por el razonamiento de un modelo de lenguaje.

Cómo funcionan las ediciones directas de pesos en modelos reales

La corrección de Qwen es el resultado que importa a los profesionales, porque 0,8 mil millones de parámetros es un modelo real, del tipo que los equipos realmente ajustan y despliegan. El fallo estaba bien documentado: los modelos de razonamiento pequeños caen en bucles, repitiendo el mismo texto hasta alcanzar el límite de tokens sin llegar nunca a una respuesta. La propia model card de Qwen lo advierte, y en las pruebas de los investigadores, 85 de las primeras 96 respuestas consumieron así todo el contexto de 32.768 tokens. El diagnóstico de Astra: las MLP de las capas 15 y 19 escribían en el flujo residual una dirección que mantenía al modelo atrapado en la misma trayectoria generativa. Su corrección consistió en restar esa dirección de 64 columnas de salida en cada una de esas dos MLP: 131.072 pesos en total, el 0,016% del modelo.

La aritmética es casi ofensivamente simple, y ese es el punto. Una vez que sabes qué dirección en el espacio de activaciones corresponde a «repetir sin fin», eliminarla es una proyección: para cada vector de pesos afectado, restas la componente que apunta en la dirección problemática. Cualquiera puede escribirlo en una docena de líneas.

import numpy as np
def subtract_direction(W, v, columns):
"""Remove the component of each chosen column that lies along v."""
v = v / np.linalg.norm(v)
W[:, columns] -= np.outer(v, v @ W[:, columns])
return W
# The Qwen repair, schematically: for the MLP output projections of
# layers 15 and 19, subtract the "loop" direction from 64 columns each.
# 2 layers x 64 columns x 1024 rows = 131,072 edited weights.
W_down[15] = subtract_direction(W_down[15], loop_dir[15], cols[15])
W_down[19] = subtract_direction(W_down[19], loop_dir[19], cols[19])

La parte difícil nunca fue la resta: es saber qué dirección, en qué capa, dentro de un flujo residual de miles de dimensiones. Esa es la parte para la que antes necesitábamos el descenso de gradiente, porque los gradientes son un procedimiento de búsqueda sobre el espacio de pesos que no requiere comprensión alguna. Astra reemplazó la búsqueda por el diagnóstico. Es la diferencia entre un electricista que reconecta circuitos por prueba y error hasta que desaparece la avería, y otro que lee el esquema y corta el cable correcto. La misma lógica explica por qué el modelo encontró las induction heads componiendo matrices de pesos: estaba aplicando un método de interpretabilidad publicado que nunca le habían mostrado, lo que sugiere una transferencia genuina de razonamiento y no recetas memorizadas.

Cuándo la edición directa de pesos supera al fine-tuning

Aquí va mi postura, y la defiendo: para fallos estrechos y localizables en modelos de tamaño pequeño a medio, la edición directa de pesos ya es la herramienta mejor, y no hay color. Piensa en la alternativa de fine-tuning para el bug del bucle. Tendrías que reunir un dataset de trazas de razonamiento sin bucles, lanzar SFT o RL y esperar que la presión de la pérdida elimine el comportamiento sin degradar todo lo demás que sabe el modelo. Quemarías horas de GPU escalando colinas hacia un proxy —más datos de matemáticas— en lugar de la intención real, que es «deja de repetirte». La programación en el espacio de pesos te permite expresar la intención. La edición tocó una centésima parte del modelo; un fine-tune los toca todos, y los daños colaterales aparecen después como regresiones extrañas que nadie relaciona con la ejecución de entrenamiento.

El fine-tuning escala colinas hacia un proxy de tu intención. La programación en el espacio de pesos te permite declarar la intención.

El segundo caso es escapar de mínimos locales que los métodos basados en gradiente no pueden abandonar estructuralmente. PPO dejó el coche atascado contra la rampa porque el aprendizaje por refuerzo explora perturbando la política actual, y ninguna pequeña perturbación de «conducir recto» descubre «retrocede dos segundos primero». El razonamiento no perturba: puede saltar a una solución cualitativamente distinta porque opera sobre un modelo del problema, no sobre una perturbación de la respuesta actual. Mil millones de pasos de PPO no encontraron lo que encontró una pasada de razonamiento: no es una brecha de eficiencia, es una diferencia de categoría.

Tercero, el ciclo de iteración se colapsa. El fine-tuning arrastra una cola logística —curación de datos, entrenamientos, barridos de evaluación, comprobaciones de regresión— que convierte un «pequeño cambio de comportamiento» en un proyecto de varios días. Quien haya ejecutado un modelo grande en su propio hardware sabe cuánto esfuerzo es fontanería y cuánto modelado. Una edición de pesos se parece más a un hotfix de código: diagnosticar, parchear, correr las evaluaciones y revertir si está mal. Cuando el diagnóstico es correcto, te saltas todo el pipeline de entrenamiento. Las victorias claras se concentran en cuatro situaciones:

• Tienes diagnosticado el fallo, pero no hay datos de entrenamiento que expresen la corrección
• Necesitas un alcance quirúrgico: cambiar un comportamiento sin que el resto derive
• El modelo está atascado en un mínimo local que la exploración aleatoria no puede superar
• No puedes permitirte un pipeline de entrenamiento, ni en GPUs ni en tiempo de calendario

Por qué la programación en el espacio de pesos es frágil

Ahora el agua fría, porque hay mucha. El dato más útil que he visto no viene del paper: viene de un practicante que probó el mismo truco en un modelo pequeño de lenguaje natural a bash y no obtuvo ganancia neta. Editar 1.920 pesos arregló algunos errores de grep y rompió otros comandos. Es el resultado esperable, y apunta al problema profundo: los comportamientos en redes entrenadas están entrelazados. La edición de Qwen funcionó porque el comportamiento de bucle resultó vivir en una dirección compacta y removible. Muchos comportamientos no son así. Están distribuidos por superposición, con las mismas columnas transportando varias características no relacionadas, de modo que restar una «dirección» es como intentar quitar una nota de un acorde. Te cargarás las demás. Nadie tiene una teoría para predecir de antemano qué fallos son geométricamente compactos y cuáles están dispersos; hasta que la tengamos, cada edición de pesos es una apuesta.

Las demostraciones de lectura también merecen descuento. El razonamiento de Astra sobre las redes de juegos se apoyó en estadísticas superficiales —dónde se concentran los pesos de la primera capa, qué logits de salida separan— y la identificación de idioma fue, en la práctica, una pregunta de opción múltiple a tres bandas en la que una opción, el japonés romanizado, tiene una distribución de letras llamativamente inusual (sin q, l, v ni x). ¿Reconocimiento de patrones impresionante? Sin duda. ¿Evidencia de una comprensión nativa profunda del espacio de pesos? Menos claro. El resultado de difusión juega en ambos sentidos: Astra dibujó todas las formas como contornos cuando los modelos en realidad generan formas rellenas. Es un error que demuestra que leía geometría y no simulaba la red, pero también muestra que su «comprensión» puede estar estructuralmente equivocada de maneras que aun así pasan la prueba.

Luego están la escala y la procedencia. Todos los resultados limpios están entre 17.000 y 7 millones de pesos, con el 0,8B de Qwen como caso atípico, e incluso el experimento de lectura de capas intermedias necesitó hasta cien ejecuciones de análisis en Python para llegar ahí. Nadie ha mostrado esto funcionando en un modelo de 70B, y menos en uno de frontera, y el enfoque ingenuo —pegar los pesos en una ventana de contexto— muere mucho antes. Una pregunta incómoda también flota sobre todo esto: ¿de dónde salió esta capacidad? Los LLM sospechosamente buenos al ajedrez suelen resultar haber ingerido mucha notación de ajedrez durante el entrenamiento. Si Astra fue entrenado deliberadamente con datos de pesos, estos resultados dicen menos sobre comprensión emergente y más sobre un currículo muy bueno. Sinceramente, no lo sabemos.

Por último, el salto en MATH-500 necesita un asterisco. Ese benchmark lleva años saturado por datos de entrenamiento, y un modelo base que puntúa 7,9% casi seguro falla por bucles y formato más que por capacidad matemática; es decir, la edición desbloqueó capacidad latente en lugar de crear habilidad. Eso sigue siendo valioso; desbloquear es una victoria real. Pero es una afirmación distinta de «la edición hizo al modelo mejor en matemáticas», y encaja en un patrón conocido en el que los benchmarks no capturan la mayor parte de lo que es el trabajo real.

Ediciones de pesos en producción: trátalas como hotfixes

Si quieres probarlo —y en modelos pequeños, deberías—, trata las ediciones de pesos con la disciplina que aplicarías a un parche en caliente sobre una base de datos en producción. Registra todo: anota exactamente qué tensores cambiaron y en cuánto, porque 0,016% es lo bastante pequeño como para que un bug silencioso en tu script de edición se esconda para siempre. Evalúa de forma amplia, no solo el comportamiento objetivo; la corrección de Qwen casualmente mejoró el seguimiento de instrucciones, pero el signo de ese efecto secundario fue suerte, y la próxima vez puede salir al revés. Mantén el checkpoint base intacto y versiona cada edición como un parche reversible. Y acota tus ambiciones: el punto dulce demostrado son fallos pequeños y bien entendidos en modelos que puedes evaluar por completo. Si tu instinto es arreglar un problema vago de «sensación» en un modelo de 70B «quitando la dirección mala», estás a punto de aprender sobre la superposición por las malas.

• Fija el checkpoint base; guarda las ediciones como diffs y nunca sobrescribas in situ
• Ejecuta evaluaciones amplias antes y después, no solo el benchmark objetivo
• Prefiere fallos con una firma nítida y reproducible antes que sensaciones
• Presupuesta reversiones: asume que una fracción de las ediciones romperá algo

Mi postura honesta: hoy esto es un instrumento de interpretabilidad y un bisturí de depuración, no un pipeline de despliegue. Los equipos que extraigan valor primero no serán los que envíen ediciones de pesos a producción. Serán los que usen un modelo de frontera para explicar lo que aprendieron sus modelos pequeños —leyendo checkpoints como ya leemos trazas de razonamiento— y luego actúen sobre ese conocimiento con herramientas normales, aburridas y fiables.

Los gradientes no han muerto: han sido degradados

Aquí es donde mi afirmación inicial se desmorona, y quiero ser honesto al respecto. El descenso de gradiente hace algo que la programación en el espacio de pesos no puede: aprende de datos a escala. Cada capacidad que Astra usó para hacer estas ediciones fue instalada, a su vez, por gradientes sobre un corpus de entrenamiento enorme. El razonamiento puede operar quirúrgicamente sobre lo que sabe una red; no puede enseñarle a una red la suma del texto humano. El futuro realista no es el reemplazo de los gradientes, sino una división del trabajo: los gradientes vierten el hormigón; la programación en el espacio de pesos hace la carpintería fina. Durante cuarenta años hemos tratado los pesos entrenados como un artefacto opaco, una caja negra que solo podíamos dirigir desde fuera. La idea realmente nueva aquí es que la caja se está volviendo legible, y que quien la lee no somos nosotros. Que eso resulte tranquilizador o alarmante probablemente depende de cuánto confiabas en los gradientes.