Resource-Efficient Iterative LLM-Based NAS with Feedback Memory

Este trabajo propone un pipeline de búsqueda de arquitecturas neuronales (NAS) eficiente en recursos que utiliza modelos de lenguaje grandes (LLM) en un bucle cerrado con memoria de retroalimentación histórica para iterativamente generar y refinar arquitecturas de redes convolucionales en una sola GPU de consumo, logrando mejoras significativas en precisión sin necesidad de fine-tuning ni infraestructura en la nube.

Lo esencial

Imagina que quieres construir el mejor coche de carreras posible, pero no eres un ingeniero experto. En su lugar, tienes un genio muy inteligente pero con una memoria muy corta (un modelo de lenguaje grande o LLM) y una pista de pruebas pequeña (tu tarjeta gráfica de ordenador).

El problema es que este genio, por muy listo que sea, a veces se equivoca mucho al dibujar los planos del coche. Si le pides que diseñe un coche una sola vez y listo, probablemente te dará algo que no funciona bien.

Este paper presenta una solución genial: un sistema de "prueba, error y aprendizaje" que funciona en un solo ordenador doméstico.

Aquí te explico cómo funciona, paso a paso, con analogías sencillas:

1. El Equipo de Trabajo (Dos Genios en Uno)

En lugar de tener un solo genio que hace todo, el sistema divide el trabajo en dos roles para no saturar la memoria del ordenador:

• El Arquitecto (Code Generator): Es el que dibuja los planos del coche (el código del modelo de IA).
• El Mecánico Crítico (Prompt Improver): Es el que revisa los planos, ve dónde falló el coche en la pista, y le dice al Arquitecto: "Oye, la rueda se cayó porque pusiste un tornillo muy pequeño. En la próxima, usa uno más grande".

2. La "Caja de Herramientas de la Memoria" (Feedback Memory)

Aquí está la magia. Normalmente, si un genio falla, se olvida del error y vuelve a intentar lo mismo. Pero este sistema tiene una "Caja de Herramientas de la Memoria".

• La analogía: Imagina que tienes una caja donde guardas solo los últimos 5 intentos (éxitos y fracasos).
• Cómo funciona: Cada vez que el Arquitecto dibuja un coche nuevo, el Mecánico mira esa caja. No le cuenta toda la historia de la vida del genio (eso sería demasiado largo y confuso), solo le dice: "En los últimos 5 intentos, cuando intentaste hacer el motor muy grande, se rompió. Cuando hiciste las ruedas más ligeras, fue más rápido".
• El truco: Esto se llama "memoria de Markov". Es como jugar al ajedrez: para decidir tu siguiente movimiento, no necesitas recordar cada jugada desde el principio del partido, solo necesitas recordar las últimas pocas jugadas y la posición actual del tablero.

3. La Pista de Pruebas Rápida (Proxy Evaluation)

No tienen tiempo ni dinero para probar cada coche durante 10 horas. Así que usan una prueba de 1 vuelta.

• En lugar de entrenar el modelo de IA durante días, lo entrenan solo una vez (una vuelta rápida).
• Si el coche va rápido en esa primera vuelta, el sistema dice: "¡Bueno! Intentemos mejorar eso". Si se rompe, el Mecánico anota el error en la caja de herramientas.

4. El Resultado: De Novato a Experto

Lo increíble es que empezaron con modelos de IA pequeños (como un estudiante de ingeniería) y, tras 2000 intentos (que en total tardaron solo unas 18 horas en un ordenador normal, sin pagar nubes de servidores caros), lograron:

• DeepSeek-Coder: Mejoró su rendimiento de un 28% a un 69%.
• Qwen2.5: Saltó del 50% al 71%.
• GLM-5: Subió del 43% al 62%.

¿Por qué es importante esto?

Imagina que antes, para diseñar un coche de carreras, necesitabas una fábrica gigante con miles de ingenieros trabajando meses (los métodos antiguos de NAS).
Este paper dice: "No, puedes hacerlo tú solo en tu garaje, con un ordenador normal, usando un genio que aprende de sus propios errores".

• Es barato: No necesita superordenadores.
• Es eficiente: El sistema, al compartir la memoria del ordenador, aprende a crear coches (modelos) que son pequeños y ligeros, perfectos para funcionar en móviles o dispositivos pequeños.
• Es inteligente: No ignora los fracasos. Al contrario, aprende de los errores guardándolos en su "caja de herramientas" para no volver a cometerlos.

En resumen: Es como enseñar a un niño a cocinar. En lugar de darle una receta perfecta de una sola vez, le dejas que cocine, le dices "esta salada", él lo anota en su libreta de 5 recetas recientes, y en la siguiente vez ajusta la sal. Al final, ¡tiene un plato delicioso sin haber necesitado un chef estrella!

Resumen técnico

Aquí tienes un resumen técnico detallado del artículo "Resource-Efficient Iterative LLM-Based NAS with Feedback Memory" en español:

1. Planteamiento del Problema

La Búsqueda de Arquitectura Neuronal (NAS) automatiza el diseño de redes neuronales, pero los métodos convencionales (basados en aprendizaje por refuerzo o algoritmos evolutivos) requieren recursos computacionales masivos (miles de días-GPU). Aunque existen métodos más eficientes que utilizan métricas proxy, suelen estar restringidos a espacios de búsqueda predefinidos (como estructuras basadas en celdas), lo que limita la creatividad arquitectónica.

Recientemente, los Modelos de Lenguaje Grandes (LLMs) han demostrado capacidad para generar código de redes neuronales directamente. Sin embargo, la mayoría de los enfoques actuales son de "disparo único" (single-shot), donde el LLM genera una arquitectura sin iterar ni aprender de sus propios errores. Además, los métodos de optimización iterativa existentes a menudo descartan las trayectorias de fallo o requieren modelos propietarios masivos y costosos, lo que los hace inaccesibles en entornos con recursos limitados.

El problema central: ¿Cómo se puede utilizar un LLM pequeño (≤7B parámetros) y congelado en una sola GPU de consumo para iterativamente mejorar arquitecturas de redes neuronales, aprendiendo de sus propios fallos y éxitos, sin necesidad de fine-tuning ni infraestructura en la nube?

2. Metodología

Los autores proponen una tubería (pipeline) de NAS en bucle cerrado que opera en un espacio de código abierto (código PyTorch ejecutable) y consta de tres módulos principales que interactúan iterativamente:

1. Generador de Código (Code Generator):

   • Utiliza un LLM instruido y congelado (no fine-tuned) para generar una clase nn.Module de PyTorch completa.
   • Recibe como entrada: una descripción de rol, la especificación de la tarea, la mejor arquitectura actual ($A^*$) y las sugerencias de mejora de la iteración anterior.
   • Genera código con temperatura $\tau=0.7$ para equilibrar diversidad y coherencia.

2. Evaluador (Evaluator):

   • Realiza una validación rápida (forward pass con datos dummy) para descartar código no ejecutable.
   • Entrena el modelo válido durante una sola época (one-epoch) en el conjunto de datos (CIFAR-10, CIFAR-100 o ImageNette) utilizando SGD.
   • Utiliza la precisión de una época como señal proxy rápida para clasificar la calidad de la arquitectura, evitando el costo de un entrenamiento completo.

3. Mejorador de Prompts con Memoria de Retroalimentación Histórica (Prompt Improver with Historical Feedback Memory):

   • Este es el núcleo de la innovación. Analiza el resultado de la evaluación junto con una memoria deslizante de las últimas $K=5$ intentos de mejora.
   • Estructura de la Memoria: Cada entrada en la memoria es una tripleta diagnóstica estructurada: (problema identificado, sugerencia de modificación, resultado obtenido). Esto trata los fallos de ejecución de código como señales de aprendizaje de primera clase, no como ruido descartable.
   • Propiedad de Markov: El diseño se basa en la propiedad de Markov de orden $K$. La decisión de mejora en el paso $t$ depende solo de la mejor arquitectura actual y de la ventana acotada de historial reciente, manteniendo el tamaño del contexto constante y evitando el desbordamiento.
   • Especialización Dual: Se utilizan dos roles de LLM (o un mismo modelo con roles diferenciados): uno para generar código y otro para el razonamiento diagnóstico, reduciendo la carga cognitiva por llamada.

3. Contribuciones Clave

• Pipeline Iterativo de NAS con LLM: Un sistema que descubre arquitecturas progresivamente mejoradas mediante generación de código, evaluación y refinamiento de prompts, operando en un espacio de código abierto y no restringido.
• Mecanismo de Memoria de Retroalimentación Histórica: Una ventana deslizante de $K=5$ intentos que permite al LLM identificar patrones de fallo y evitar estrategias fallidas, utilizando tripletas diagnósticas para modelar causalidad entre decisiones de diseño y resultados.
• Eficiencia de Recursos y Accesibilidad: Demostración empírica de que LLMs congelados de hasta 7B parámetros pueden realizar NAS efectivo en una sola GPU de consumo (RTX 4090) sin fine-tuning, completando 2000 iteraciones en ~18 horas de GPU.
• Búsqueda Consciente del Hardware: Al compartir la VRAM limitada entre el LLM y el entrenamiento del modelo, el sistema favorece implícitamente arquitecturas compactas y eficientes, ideales para despliegue en el borde (edge).

4. Resultados Experimentales

Los experimentos se realizaron con tres LLMs diferentes (DeepSeek-Coder-6.7B, Qwen2.5-7B, GLM-5) en tres conjuntos de datos.

• Mejoras Significativas:
  • CIFAR-10:
    • DeepSeek-Coder-6.7B: Mejora de 28.2% a 69.2% (correlación de Spearman $\rho=0.75$).
    • Qwen2.5-7B: Mejora de 50.0% a 71.5% (el pico más alto, aunque con menor tasa de éxito).
    • GLM-5: Mejora de 43.2% a 62.0% en solo 100 iteraciones (tasa de éxito del 91%).
  • CIFAR-100 e ImageNette: Se observaron tendencias de mejora consistentes en todos los modelos, aunque la complejidad de los datos afectó las tasas de éxito de generación de código (ej. DeepSeek tuvo dificultades con la resolución más alta de ImageNette).
• Estadísticas: Todas las curvas de precisión mostraron tendencias ascendentes estadísticamente significativas, confirmando que la memoria histórica impulsa la mejora sistemática.
• Estudio de Ablación: La eliminación de la memoria de retroalimentación o de la arquitectura de referencia provocó que el proceso de búsqueda se estancara o degradara, demostrando que la modelización explícita de fallos es crítica.

5. Significado e Impacto

Este trabajo establece un nuevo paradigma para el NAS impulsado por LLMs:

1. Democratización: Hace que la búsqueda de arquitecturas sea accesible para investigadores con presupuestos limitados y hardware de consumo, eliminando la dependencia de clusters masivos o modelos propietarios costosos.
2. Innovación Arquitectónica: Al operar en un espacio de código abierto en lugar de celdas predefinidas, permite la invención de patrones arquitectónicos genuinamente nuevos que los métodos tradicionales no pueden expresar.
3. Aprendizaje de Fallos: Cambia la perspectiva de tratar los errores de compilación/ejecución como ruido, utilizándolos como señales estructuradas para guiar la búsqueda, lo cual es esencial dado que la generación de código de redes neuronales es inherentemente propensa a errores.
4. Eficiencia: Demuestra que la especialización de tareas (generador vs. mejorador) y el uso de memoria acotada permiten optimizar recursos de VRAM compartidos, resultando en modelos finales más ligeros y adecuados para dispositivos con recursos limitados.

En resumen, el artículo presenta una solución robusta, reproducible y de bajo costo para la automatización del diseño de redes neuronales, validando que la iteración inteligente sobre el historial de intentos es más efectiva que la generación estática, incluso con modelos de lenguaje pequeños.