Evaluando la comprensión de nombres de API en modelos de código

El progreso reciente en Modelos de código, como CodeBERT y Codex, ha mostrado resultados sólidos en varias tareas relacionadas con el código. Sin embargo, hay preguntas sobre qué tan bien estos modelos usan las APIs, que son herramientas importantes en la programación. Usar correctamente las APIs es esencial para crear software que funcione como se espera. Esto significa que los modelos de código necesitan aprender no solo los nombres de las APIs, sino también cómo usarlas correctamente en el código. Estudios han demostrado que incluso los mejores modelos de código preentrenados pueden tener dificultades para sugerir las APIs adecuadas al escribir código.

Este estudio investiga si los modelos de código preentrenados entienden correctamente los nombres de las APIs. Para averiguarlo, utilizamos un método llamado "knowledge probing". Este método prueba la comprensión de los modelos sobre los nombres de las APIs creando preguntas que requieren llenar los espacios en blanco. Nos enfocamos en dos áreas: cómo los modelos entienden las llamadas a las APIs y cómo entienden las importaciones de las APIs. Los resultados muestran que los modelos de código actuales tienen dificultades con los nombres de las APIs, y cómo aprenden estos nombres depende mucho de cómo fueron entrenados.

Además, descubrimos que usar lenguaje natural puede ayudar a los modelos a localizar mejor los nombres de las APIs y puede ayudarles a adaptar este conocimiento a nuevas situaciones. Nuestros hallazgos pueden ayudar a mejorar la forma en que los modelos de código entienden y usan las APIs, guiando futuras investigaciones en este campo.

#Antecedentes sobre Modelos de Código

Los modelos de código, como CodeBERT, GraphCodeBERT y PLBART, se entrenan usando grandes cantidades de código fuente para aprender cómo funciona el código. Se utilizan para varias tareas como completar código, traducir entre lenguajes de programación y resumir código. A pesar de las mejoras observadas en estos modelos, todavía hay una brecha significativa en cómo rinden en comparación con los desarrolladores humanos, especialmente cuando se trata de usar correctamente las APIs.

El uso de las APIs a menudo depende de saber no solo cómo llamar a una API, sino también de qué fuente llamarla. Esto incluye conocer la sintaxis correcta al importar bibliotecas y crear los nombres de API correctos según el código. Aunque asumimos que los modelos de código pueden aprender esto a través de ejemplos, la investigación ha demostrado que no es tan sencillo como parece.

#Importancia de las APIs en la Programación

Las APIs, o Interfaces de Programación de Aplicaciones, proporcionan un conjunto de herramientas y protocolos que ayudan a los desarrolladores a construir aplicaciones de software. Se pueden pensar como los bloques de construcción del software, permitiendo que diferentes programas se comuniquen entre sí. Al usar una API, un desarrollador debe conocer su nombre completamente calificado, que incluye el paquete, módulo y nombre de la función. Esta estructura puede volverse compleja, especialmente cuando las APIs están organizadas de manera jerárquica.

Entender cómo están estructuradas las APIs es esencial para los desarrolladores. Cada capa en la jerarquía de la API puede cambiar la forma en que se usa la API en el código. Por ejemplo, consideremos una biblioteca como NumPy, que tiene varios módulos para diferentes operaciones matemáticas. Cuando un desarrollador usa NumPy, debe saber la forma correcta de referirse a la función específica que necesita.

Así, es crucial que los modelos de código aprendan los nombres de las APIs de manera precisa. Este entendimiento no solo puede ayudar a usar las APIs correctamente, sino también a mejorar la automatización del diseño de APIs.

#Knowledge Probing y Su Aplicación

El "knowledge probing" se refiere a técnicas que prueban la comprensión de un modelo sobre ideas o información específicas. En este estudio, usamos "knowledge probing" para evaluar qué tan bien los modelos de código entienden los nombres de las APIs. Este enfoque implica crear pruebas que piden a los modelos predecir partes faltantes de los nombres de las APIs en base a su contexto en el código.

Por ejemplo, si a un modelo se le presenta una declaración sobre una llamada a una API y una parte de esa declaración está oculta, la tarea del modelo es llenar el espacio en blanco. Este tipo de pruebas pueden revelar el conocimiento subyacente que un modelo tiene sobre las APIs y cómo organiza esa información.

Nuestro objetivo principal con este estudio es determinar:

1. ¿Qué tan bien entienden los modelos de código las llamadas y las importaciones de APIs?
2. ¿Pueden los modelos de código entender alias de APIs?
3. ¿Mejora el contexto de lenguaje natural la comprensión de los nombres de las APIs?
4. ¿Qué tan bien recuerdan y generalizan los modelos lo que aprenden sobre los nombres de las APIs?

#Configurando el Experimento

Para evaluar el conocimiento de los nombres de las APIs de los modelos de código, creamos un estándar llamado PyINK. Este estándar está diseñado para probar la comprensión de los nombres de las APIs de Python a través de múltiples cuestionarios. Usamos una colección de código fuente de Python de varios repositorios para extraer nombres de APIs. Los cuestionarios estaban estructurados para evaluar tanto las Llamadas a APIs como las importaciones, con algunos cuestionarios centrados en alias de importación de APIs.

En nuestros experimentos, usamos 10 modelos de código diferentes, incluidos variantes de CodeBERT y GraphCodeBERT. También incluimos un modelo llamado GPT-3.5-turbo, que no había sido entrenado específicamente para esta tarea. Cada modelo fue probado en qué tan precisamente podía predecir partes faltantes de los nombres de las APIs en varios contextos.

Categorizar nuestros tests en tres áreas principales: llamadas a APIs estándar, importaciones de APIs y importaciones de APIs con alias. Cada área fue diseñada para indagar en aspectos específicos de la comprensión de los modelos sobre los nombres de las APIs.

#Llamadas a APIs e Importaciones

El primer conjunto de cuestionarios se centró en las llamadas a APIs. Aquí, presentamos modelos con declaraciones donde partes del nombre de la API estaban enmascaradas y les pedimos que predijeran los componentes faltantes. Encontramos que los modelos generalmente se desempeñaron mejor al predecir llamadas a APIs en comparación con importaciones de APIs.

Cuando los modelos fueron probados en declaraciones de importación de APIs, su desempeño varió significativamente. Algunos modelos tuvieron dificultades para predecir correctamente los nombres de importación, lo que sugiere que pueden no codificar el conocimiento de importación de APIs tan efectivamente como lo hacen para las llamadas a APIs.

Además, también investigamos qué tan bien los modelos entienden los alias de importación de APIs, que son nombres alternativos para la misma API. Estos alias pueden ser comunes, especialmente en lenguajes de programación como Python. Descubrimos que, aunque los modelos mostraron algo de comprensión de los alias, su rendimiento aún no era tan fuerte como se esperaba.

#Rol del Contexto del Lenguaje Natural

Para analizar el efecto del contexto del lenguaje natural en la capacidad de los modelos para entender los nombres de las APIs, creamos cuestionarios que incluían descripciones relevantes en lenguaje natural junto con los nombres de las APIs. Nuestros resultados indicaron que incorporar contexto de lenguaje natural ayudó a mejorar ligeramente el rendimiento de los modelos.

Sin embargo, aunque el apoyo del lenguaje natural puede ayudar en algunas recuperaciones de nombres de APIs, no cambió el rendimiento relativo de los diferentes modelos. Este hallazgo sugiere que, aunque el contexto importa, la comprensión fundamental de los nombres de las APIs por parte de los modelos aún juega un papel crítico en qué tan bien pueden predecir los nombres correctamente.

#Memorización y Generalización

Otro aspecto importante de nuestro estudio fue evaluar qué tan bien los modelos pueden memorizar y generalizar conocimiento sobre los nombres de las APIs. Probamos tanto APIs vistas como no vistas: las APIs vistas eran aquellas que los modelos encontraron durante el entrenamiento, mientras que las no vistas eran nuevas para los modelos durante las pruebas.

Nuestros experimentos mostraron que los modelos generalmente se desempeñaron mejor en APIs vistas, indicando que habían recordado efectivamente aspectos de las APIs que habían sido entrenados. Sin embargo, también demostraron una capacidad razonable para generalizar a APIs no vistas, lo cual es una señal alentadora para su aplicabilidad en escenarios de programación del mundo real.

#Hallazgos e Implicaciones

Los resultados de nuestro estudio revelan varios hallazgos importantes sobre la comprensión de los nombres de las APIs por parte de modelos de código preentrenados:

1. Conocimiento Limitado de Nombres de APIs: Si bien los modelos pueden almacenar algo de conocimiento sobre los nombres de las APIs, a menudo no tienen una comprensión completa. Esta limitación indica la necesidad de mejoras en cómo se entrenan los modelos para reconocer y utilizar nombres de APIs de manera efectiva.

2. Comprensión Diversa entre Modelos: Hubo variaciones en el rendimiento entre diferentes modelos de código, con algunos modelos superando consistentemente a otros. Estas diferencias sugieren que enfoques de entrenamiento específicos y arquitecturas de modelos pueden afectar significativamente qué tan bien un modelo entiende los nombres de las APIs.

3. Impacto del Contexto de Lenguaje Natural: Incorporar contexto de lenguaje natural puede ofrecer alguna mejora en las habilidades de los modelos, pero la comprensión general sigue siendo en gran medida dependiente del entrenamiento básico de los modelos.

4. Memorización vs. Generalización: La capacidad de generalizar a nuevas APIs es prometedora y sugiere que los modelos pueden adaptar su conocimiento aprendido a nuevos contextos, lo cual es esencial en entornos de programación dinámicos.

#Conclusión

Este estudio contribuye con valiosas ideas sobre la comprensión de los nombres de las APIs por parte de modelos de código preentrenados. Al mostrar cómo los modelos se desempeñan en varias tareas relacionadas con los nombres de las APIs, destacamos áreas donde son necesarias mejoras. Nuestros hallazgos enfatizan la importancia de las estrategias de entrenamiento y el papel del contexto del lenguaje natural en la mejora del conocimiento del modelo.

Al refinar cómo los modelos de código aprenden sobre las APIs, podemos mejorar su efectividad en apoyar a los desarrolladores en la creación de software. Las implicaciones de esta investigación van más allá de solo la comprensión de las APIs, ya que pueden informar futuros desarrollos en herramientas y técnicas de codificación automatizada.

A medida que la programación evoluciona, la exploración adicional sobre cómo los modelos manejan y aplican el conocimiento será vital para avanzar en las prácticas de inteligencia de código.