Resumen Técnico: Auto-juego Anclado para la Reparación de Código

Formulación del Problema

La reparación de código es una capacidad crítica para los modelos de lenguaje (LM) en los flujos de trabajo de programación, lo que requiere que el modelo genere un programa fijo que supere las pruebas unitarias dado un programa con errores y la suite de pruebas. Aunque los datos de reparación de alta calidad en el mundo real son limitados, trabajos recientes han explorado el escalado de la supervisión utilizando LMs para generar tareas de corrección de errores. Los autores investigan el auto-juego generador-reparador (generator–fixer self-play), un escenario donde un único modelo se entrena mediante aprendizaje por refuerzo para alternar entre la generación de errores (editando código correcto) y su reparación.

El desafío central identificado es la deriva de distribución (distribution drift). Si bien las pruebas unitarias verifican eficazmente la corrección funcional (pasa/falla), no verifican el realismo del error. En el auto-juego estándar, el generador puede derivar hacia la producción de errores "difíciles pero poco realistas": ediciones que fallan las pruebas pero que no se parecen a los errores encontrados en la práctica (por ejemplo, código escrito por humanos o código editado por LMs). En consecuencia, mientras que el reparador mejora sobre la distribución sintética del generador, su rendimiento suele degradarse ante fuentes de errores realistas.

Metodología

1. Auto-juego Generador–Reparador

Los autores instancian un bucle de auto-juego donde una única política $\pi_\theta$ desempeña dos roles:

• Generador ($G$): Edita una implementación de referencia correcta $c^\star$ para producir un programa con errores $b$.
• Reparador ($F$): Repara $b$ dado el descriptivo de la tarea y la retroalimentación de la prueba unitaria $o(x, b)$.

Recompensas:

• Recompensa del Reparador: Recompensa binaria basada en si el programa reparado $y$ supera todas las pruebas unitarias ($v(x, y) = 1$).
• Recompensa del Generador: Diseñada para fomentar errores que sean válidos (ejecutables y con fallos en las pruebas) y de dificultad intermedia. La dificultad se estima mediante la tasa de reparación de $K$ intentos de reparación independientes. Los errores que son demasiado fáciles (siempre reparados) o demasiado difíciles (nunca reparados) son penalizados para mantener un currículo adaptativo.

El sistema se optimiza utilizando GRPO (Optimización de Política Relativa de Grupo).

2. El Modo de Fallo: Deriva de Distribución

Los experimentos muestran que el auto-juego estándar exhibe dinámicas co-evolutivas donde el generador produce errores cada vez más difíciles para un reparador fijo, y el reparador mejora sobre esos errores específicos. Sin embargo, cuando se evalúa en fuentes realistas (errores escritos por humanos, editados por humanos y generados por LMs), el rendimiento retrocede. El reparador se sobreajusta a las ediciones idiosincrásicas y poco realistas generadas por el bucle de auto-juego.

3. Solución Propuesta: Auto-juego Anclado (ASP)

Para mitigar la deriva, los autores proponen el Auto-juego Anclado (ASP), que ancla el proceso de auto-juego a un pequeño conjunto de referencia de errores ($D_{ref}$) muestreados de fuentes realistas. El ASP emplea dos mecanismos complementarios:

• Mezcla de Referencia para el Entrenamiento del Reparador: Durante el entrenamiento, una fracción de los errores de entrada del reparador se reemplaza con errores del conjunto de referencia ($D_{ref}$). Esto asegura que el reparador esté continuamente expuesto a patrones de error realistas, evitando el sobreajuste a la evolución de la distribución sintética del generador. El generador no se actualiza en estos episodios mezclados para evitar problemas de fuera de la política (off-policy).
• Modelado del Generador Guiado por Similitud: Se añade una recompensa auxiliar al objetivo del generador para empujarlo a producir errores similares a los del conjunto de referencia.
  • El generador calcula el diff unificado entre la solución de referencia y el error generado.
  • Este diff se incrusta utilizando un modelo de incrustación de código (voyage-code-3).
  • La recompensa se basa en la similitud de coseno entre la incrustación del error generado y los $k$-vecinos más cercanos en el grupo de referencia.
  • Se utiliza una similitud centrada $\delta_t(b) = \text{sim}_{01}(b) - B_t$, donde $B_t$ es una línea base continua. Esto moldea al generador hacia ediciones similares a la referencia sin abrumar la recompensa principal de la prueba unitaria.

Contribuciones Clave

1. Formulación del Problema: Los autores formalizan el auto-juego generador-reparador para la reparación de código e identifican la deriva de distribución como un modo de fallo primario cuando se depende únicamente de recompensas de pruebas unitarias.
2. Benchmark (BUGSOURCEBENCH): Introducen y lanzan BUGSOURCEBENCH, un benchmark controlado para evaluar la generalización de la reparación entre distintas fuentes. Abarca cuatro fuentes de errores manteniendo constantes las tareas subyacentes, las especificaciones y las pruebas unitarias:
   • HUMAN: Errores introducidos por anotadores en soluciones de referencia escritas por humanos.
   • HUMAN-EDITED LM: Errores en código generado por LM que posteriormente fue editado por humanos.
   • LM ERRORS (QWEN-7B): Errores de un modelo de código más débil.
   • LM ERRORS (GPT-OSS-20B): Errores de un modelo de código más fuerte.
3. Método (ASP): Proponen el Auto-juego Anclado, que combina la guía de similitud de incrustación para la generación de errores con el entrenamiento del reparador con mezcla de referencias para estabilizar el auto-juego y mejorar la generalización.

Resultados Experimentales

Los autores evalúan ASP frente a un Modelo Base, una línea base de Solo-Reparador (generador congelado, reparador entrenado) y el Auto-juego estándar en BUGSOURCEBENCH.

• Rendimiento General: ASP logra la tasa de reparación promedio más alta en todas las fuentes de errores. Mejora la tasa de reparación promedio en +7.0 puntos porcentuales (absolutos) y un 24% (relativo) sobre el auto-juego estándar.
• Generalización entre Fuentes:
  • Errores Generados por LM: ASP muestra ganancias masivas, mejorando las tasas de reparación en un +11 pp (100% relativo) en promedio para errores generados por LM.
  • Errores de Origen Humano: ASP mejora las tasas de reparación en +3.4 pp (7.1% relativo) en errores de autoría humana, mientras que el auto-juego estándar a menudo degrada el rendimiento en estas fuentes.
• Estudios de Ablación:
  • Tanto la mezcla de referencia como el modelado por similitud contribuyen al rendimiento, pero su combinación produce las mayores ganancias, lo que sugiere que abordan modos de fallo complementarios.
  • El método es eficiente en muestras, mostrando mejoras con tan solo 50 ejemplos de referencia.
  • El uso de un grupo de referencia mixto (que cubre todas las fuentes de errores) produce el mejor rendimiento general en comparación con grupos restringidos a una sola fuente.
• Robustez: Las ganancias de ASP son robustas a través de diferentes modelos de incrustación (voyage-code-3 vs. CodeBERT), modelos base (Qwen-7B vs. DeepSeek-6.7B) y distribuciones de tareas (transferencia a DebugBench).

Significación y Afirmaciones

El artículo afirma que el auto-juego basado únicamente en pruebas unitarias es insuficiente para escalar la reparación de código porque carece de una señal explícita de realismo, lo que conduce a la deriva de distribución. Al introducir el Auto-juego Anclado, los autores demuestran que un pequeño conjunto de referencia puede anclar eficazmente el proceso de generación, permitiendo que el modelo se beneficie del currículo adaptativo del auto-juego mientras mantiene la robustez ante fuentes de errores realistas.

El trabajo destaca que las capacidades de reparación son distintas de las de generación de código; los modelos que resuelven tareas desde cero pueden fallar al reparar soluciones existentes, y viceversa. El método propuesto ofrece un camino para construir herramientas de programación automatizadas más fiables que se generalicen a través de las heterogéneas fuentes de errores encontradas en la programación asistida por LM en el mundo real.

Limitaciones: Los autores señalan que sus experimentos se centran en la reparación de funciones de Python con retroalimentación de pruebas unitarias. El entorno no captura desafíos a nivel de repositorio (fallos multi-archivo, gestión de dependencias) o el uso de herramientas de largo horizonte. Además, la señal de realismo depende de un modelo de incrustación congelado y un grupo de referencia finito, lo que sugiere que trabajos futuros podrían explorar críticos aprendidos o recompensas basadas en preferencias.