Mejorando la autocompletación de código con contexto a nivel de repositorio

Los Modelos de Lenguaje Grande diseñados para la asistencia de código, conocidos como CodeLLMs, se han vuelto populares para ayudar con tareas como la Finalización de código. Sin embargo, estos modelos a menudo no entienden todos los detalles dentro del repositorio de código de un proyecto. Esto puede llevar a sugerencias que no coinciden perfectamente con lo que el usuario necesita. Por lo tanto, hay un esfuerzo en curso para mejorar cómo funcionan estos modelos en términos de entender el contexto más amplio del código, que incluye archivos, clases y cómo se relacionan entre sí.

#El Reto

Las herramientas tradicionales de finalización de código logran captar el entorno inmediato del código que se está escribiendo, pero se pierden el panorama general. No consideran la información valiosa que se encuentra en diferentes partes del proyecto, como archivos relacionados y la jerarquía de clases. Esta falta de comprensión significa que las sugerencias pueden ser menos útiles de lo que podrían ser.

Una forma de solucionar esto es aumentar la longitud del contexto del código que estos modelos pueden manejar. Sin embargo, simplemente hacer que los modelos sean capaces de mirar más líneas de código es caro e impráctico a largo plazo. Hay una clara necesidad de mejores métodos que puedan identificar eficientemente los contextos más relevantes sin tener que revisar cada archivo en un repositorio de código.

#Finalización de Código a Nivel de Repositorio

Para abordar estos problemas, ha surgido la idea de la finalización de código a nivel de repositorio. Este enfoque tiene como objetivo tener en cuenta todos los detalles relevantes de un proyecto en su conjunto, incluyendo enlaces entre diferentes archivos, módulos que se importan y la estructura general del código. Los métodos existentes generalmente recuperan contextos relevantes para la finalización de código utilizando un enfoque basado en similitudes, que a menudo se queda corto. Muchos métodos pasan por alto la importancia de contextos diversos dentro del mismo repositorio, que podrían contener información útil, sin importar si los fragmentos de código se ven similares. Componentes importantes como funciones compartidas, llamadas de métodos entre módulos y relaciones dentro de las clases contribuyen a la imagen completa de cómo funciona el código.

#Introduciendo un Nuevo Enfoque

Para mejorar la finalización de código a nivel de repositorio, proponemos un nuevo marco que conecta todos estos elementos intrincados de manera más efectiva. Este marco incluye tres piezas principales:

1. Grafo Semántico a Nivel de Repo (RSG): Esta es una representación estructurada que incluye las partes clave de un repositorio de código y cómo se relacionan entre sí, proporcionando conocimiento confiable para la recuperación de contexto.

2. Método de Recuperación Expandir y Refinar: Este método es bidireccional. Primero, encuentra fragmentos de código similares (estrategia Buscar-Expandir), y luego expande la búsqueda para incluir contextos relacionados utilizando un enfoque basado en grafos. La segunda parte de este método refina la información recuperada para presentar solo las opciones más útiles al usuario.

3. Predicción de Enlace: Este componente toma el amplio conjunto de contextos encontrados y lo reduce a las opciones más relevantes. Utiliza un método que determina cuán fuertemente está conectado cada contexto al fragmento de código del usuario.

#Evaluación del Marco

Para probar la efectividad de nuestro marco propuesto, realizamos evaluaciones en diferentes áreas, enfocándonos en cuán bien puede recuperar contextos relevantes y completar fragmentos de código de manera efectiva. Comparamos nuestro marco con métodos existentes y encontramos que superó significativamente a estos últimos en ambas áreas.

#Recuperación de Contexto

En la primera evaluación, nos centramos en cuán bien nuestro marco podía recuperar las piezas correctas de código del repositorio. Nuestro método mostró una mejora promedio de alrededor del 49% en precisión en comparación con los métodos tradicionales basados en similitud. Esto significa que nuestro enfoque fue mejor para encontrar el contexto adecuado necesario para una finalización de código apropiada.

#Finalización de Código

En la segunda evaluación, probamos cuán bien el marco podía predecir la siguiente línea de código después de recuperar el contexto relevante. Nuevamente, nuestro método superó a los modelos tradicionales al lograr puntuaciones más altas en diferentes métricas de evaluación. Esto sugiere que no solo nuestro método encuentra el contexto correcto, sino que también lo utiliza de manera efectiva para generar sugerencias de código precisas.

#Cómo Funciona el Marco

#Construcción del Grafo Semántico a Nivel de Repo (RSG)

El primer paso en nuestro sistema es construir el Grafo Semántico a Nivel de Repo. Esto implica identificar elementos clave del programa, como funciones y clases, y establecer las relaciones entre ellos. Esto crea una estructura clara que describe cómo interactúan entre sí los diferentes componentes dentro del código.

#Estrategia Buscar-Expandir

Una vez que el RSG está en su lugar, podemos aplicar una estrategia Buscar-Expandir. Inicialmente, el sistema realizará una búsqueda para encontrar las piezas de código más similares a la tarea actual. Después de encontrar estas, expandirá su búsqueda para incluir contextos relacionados que pueden no parecer similares, pero que aún tienen relevancia.

#Predicción de Enlace para Re-ranking

Después de reunir el contexto inicial, el Predictor de Enlace refina esta información. Toma los contextos recopilados y los puntúa según su relevancia para la tarea del usuario. El sistema luego presenta solo las mejores opciones, facilitando a los usuarios encontrar los fragmentos de código más útiles.

#Resultados y Hallazgos

Los resultados de nuestras evaluaciones muestran las fortalezas de nuestro marco. Consistentemente superó a los modelos existentes tanto en la Recuperación de contextos relevantes como en la finalización de código. Al utilizar de manera efectiva un enfoque estructurado para entender y analizar el código, nuestro método mejora no solo la precisión de las sugerencias, sino también la relevancia de los fragmentos recuperados.

#Limitaciones y Direcciones Futuras de Investigación

Aunque nuestros resultados son prometedores, hay algunas limitaciones en nuestro trabajo actual. Por ejemplo, los tipos de ruta utilizados para la expansión en el RSG se eligieron manualmente, lo que puede no ser óptimo para todas las situaciones. En el futuro, desarrollar un algoritmo aprendible podría ayudar a agilizar este proceso.

Además, nuestras evaluaciones se realizaron principalmente con un conjunto de datos principal. Ampliar nuestros experimentos para incluir más conjuntos de datos podría mejorar la validez de nuestros hallazgos.

Finalmente, usar modelos grandes para estas tareas requiere recursos computacionales significativos, lo que puede tener un impacto ambiental. Encontrar formas de reducir la necesidad de esos recursos mientras se mantiene la efectividad será un paso importante hacia adelante.

#Conclusión

En conclusión, el marco que propusimos para la finalización de código a nivel de repositorio es un avance prometedor en el campo. Aborda las fallas comunes de los modelos existentes al incorporar una visión integral del contexto del código del proyecto. Las mejoras significativas en la precisión de recuperación y efectividad de la finalización de código demostradas en nuestras evaluaciones sugieren que este enfoque tiene un gran potencial para el futuro de las tecnologías de asistencia de código. Al continuar refinando nuestros métodos y explorando nuevas avenidas de investigación, esperamos expandir los límites de lo que es posible en este dominio.