Informática e IAPrepublicaciónExperimento4 min de lectura

UN MODELO DE LENGUAJE REESCRIBE SUS PROPIOS PESOS

Un modelo de lenguaje se entrena una vez, se congela y se despliega. Para mejorarlo, normalmente hace falta otro entrenamiento: grandes clústeres de cálculo, una cadena de entrenamiento y las personas que saben usarlos. Lo que un usuario puede cambiar, el prompt, se desvanece en cuanto cambia la tarea. Jiajun Fan, Ge Liu y sus colegas de UIUC, CMU, Rutgers, Princeton y Stanford se hicieron otra pregunta: ¿puede un modelo reescribir sus propios pesos —los miles de millones de números que lo definen— solo razonando, sin ningún entrenamiento?

Su respuesta, escriben, es sí, «hasta donde sabemos, por primera vez». Lo llaman autorreescritura (self-rewriting).

Una sesión sobre sus propios pesos

Los experimentos usan una familia de modelos abiertos, Qwen3.5, en cuatro tamaños: 2.000, 4.000, 9.000 y 27.000 millones de parámetros. Cada modelo dispone de una sesión sobre sus propios pesos. Recibe sus respuestas calificadas a problemas de matemáticas de práctica y un entorno de Python en el que puede leer y sobrescribir sus matrices de pesos. También puede ejecutarse a sí mismo un número limitado de veces —20 pasadas hacia delante (forward passes)— para responder problemas con y sin su edición, usando las mismas semillas aleatorias, o para leer sus propios estados ocultos.

Lo que no puede hacer es entrenarse. El entorno rechaza cualquier cálculo de gradientes y cualquier optimizador, no tiene GPU ni acceso a la red, y bloquea las ediciones que se limitarían a reescalar una matriz entera. Cada valor que el modelo cambia lo escribe su propio razonamiento. Después, los resultados se comprueban en problemas que las sesiones nunca vieron.

Encontrar la matriz rota

En una primera prueba, el equipo dio al modelo de 27.000 millones de parámetros una copia dañada de sí mismo: ocho filas de una matriz, en la capa 30 de 64, sobrescritas con ruido. Al modelo solo se le dijo que algunos valores se habían corrompido. La copia no resolvía nada.

Su sesión parece una depuración. Primero sospechó de las primeras capas: se equivocaba, y sus propias pruebas lo indicaron. Después comparó el peso más grande de cada matriz de salida con el típico, y encontró al culpable: «El down_proj de la capa 30 tiene un valor atípico extremo de 1397x». Su arreglo fue suave: en esa matriz y en otras 19, limitó todo peso que superara 15 veces la mediana de su matriz. No restauró los valores originales, que nunca vio; limitó los aleatorios. En 200 problemas de matemáticas reservados, la copia pasó del 0 % al 33 %. Más llamativo aún, la reparación, hallada solo con texto, funcionó también con imágenes: en seis pruebas de referencia (benchmarks) de imágenes que nunca había visto, la copia subió del 7,3 % al 70,2 %, es decir, el 83 % de la precisión del modelo sin daños.

Enseñarse a parar

Con sus propios pesos, sin daños, el modelo 27B partió de un diagnóstico: la mayoría de sus respuestas agotaban los tokens, pero casi todas las que terminaban eran correctas. En sus propias palabras: «mi razonamiento es sólido, pero soy demasiado prolijo o no llego a conclusiones de forma eficiente».

Así que comparó sus estados ocultos en respuestas que terminan y en respuestas que se alargan sin fin, encontró la dirección que las separa y eliminó una pequeña parte de ella en una capa. Sus pruebas favorecían la edición. En un segundo protocolo, el sistema también comprobaba cada edición una vez en problemas reservados antes de que el modelo decidiera presentarla. En las ocho primeras sesiones de este tipo, todas ellas documentadas, el modelo se retiró en cinco y presentó tres. Dos de esas ediciones lo mejoraron significativamente en 490 problemas nuevos: +6,6 puntos (del 57,2 % al 63,8 %) y +4,0 puntos. La mayor ganancia vino de un cambio sorprendentemente simple —retocar ligeramente un ajuste en cada capa de atención lineal—, tras el cual menos respuestas agotaron los tokens. En un problema, el modelo original repitió una sola frase 549 veces sin responder; tras la edición, respondió correctamente. Cada sesión detrás de las mayores ganancias se ejecutó en unas pocas horas con una sola GPU.

Solo lo consigue el modelo más grande

Con la misma tarea y las mismas herramientas, el tamaño marcó toda la diferencia. El modelo de 2.000 millones de parámetros no hizo ninguna edición: la mayor parte de su código fallaba. Los modelos de 4.000 y 9.000 millones añadieron ruido aleatorio a sus pesos y se estropearon a sí mismos; el de 9.000 millones llegó incluso a presentar una edición que lo dejó incapaz de responder problemas nuevos. Solo el modelo de 27.000 millones midió antes de actuar y conservó lo que sus pruebas respaldaban. Para los autores, es la primera evidencia, dentro de una familia de modelos, de que la capacidad de diagnosticar y reescribir los propios pesos crece con el tamaño.

En qué se basan las afirmaciones

Los resultados proceden de una sola familia de modelos y, sobre todo, de problemas de matemáticas. Las ganancias corrigen principalmente respuestas que nunca terminan, y una de las tres ediciones presentadas no aportó ninguna ganancia significativa. La reparación recupera la mayor parte, no todo, de lo que el daño eliminó. Los autores imaginan un futuro en el que mejorar un modelo requiera «una conversación en lugar de un entrenamiento», y quizá un camino hacia modelos que se mejoren a sí mismos una y otra vez. Ese camino, insisten, debería recorrerse con personas en el circuito (in the loop): cada modelo que un modelo haga de sí mismo, evaluado tanto en seguridad como en la tarea, y confirmado por una persona.