Valutare la comprensione dei nomi delle API nei modelli di codice

Nei recenti progressi nei Modelli di Codice, come CodeBERT e Codex, ci sono stati risultati forti in vari compiti legati al codice. Tuttavia, ci sono domande su quanto bene questi modelli usino le API, che sono strumenti importanti nel coding. Usare correttamente le API è essenziale per creare software che funzioni come previsto. Questo significa che i modelli di codice devono imparare non solo i nomi delle API, ma anche come usarle correttamente nel codice. Studi hanno dimostrato che anche i migliori modelli di codice pre-addestrati possono faticare a suggerire le API giuste quando scrivono codice.

Questo studio analizza se i modelli di codice pre-addestrati comprendano correttamente i nomi delle API. Per scoprirlo, usiamo un metodo chiamato knowledge probing. Questo metodo testa la comprensione dei modelli sui nomi delle API creando domande che richiedono di riempire gli spazi vuoti. Ci concentriamo su due aree: come i modelli comprendono le Chiamate API e come comprendono gli import delle API. I risultati mostrano che i modelli di codice attuali hanno difficoltà con i nomi delle API, e come li apprendono dipende molto da come sono stati addestrati.

Inoltre, abbiamo scoperto che usare il linguaggio naturale può aiutare i modelli a localizzare meglio i nomi delle API e può aiutarli ad adattare questa conoscenza a nuove situazioni. Le nostre scoperte possono aiutare a migliorare come i modelli di codice comprendono e usano le API, guidando la ricerca futura in quest'area.

#Contesto sui Modelli di Codice

I modelli di codice, come CodeBERT, GraphCodeBERT e PLBART, sono addestrati usando grandi quantità di codice sorgente per capire come funziona il codice. Vengono usati per vari compiti come completare il codice, tradurre tra linguaggi di programmazione e riassumere il codice. Nonostante i miglioramenti visti in questi modelli, c'è ancora un divario significativo su quanto bene si comportano rispetto agli sviluppatori umani, specialmente quando si tratta di usare correttamente le API.

L'uso delle API spesso dipende dal sapere non solo come chiamare un'API, ma anche da quale fonte chiamarla. Questo include conoscere la sintassi corretta quando si importano librerie e creare i nomi delle API giusti basati sul codice. Anche se presumiamo che i modelli di codice possano imparare questo tramite esempi, la ricerca ha dimostrato che non è così semplice come sembra.

#Importanza delle API nel Coding

Le API, o Interfacce di Programmazione delle Applicazioni, forniscono un insieme di strumenti e protocolli che aiutano gli sviluppatori a costruire applicazioni software. Possono essere considerate come i mattoni del software, permettendo a diversi programmi di comunicare tra loro. Quando si utilizza un'API, uno sviluppatore deve conoscere il suo nome completamente qualificato, che include il pacchetto, il modulo e il nome della funzione. Questa struttura può diventare complessa, specialmente quando le API sono organizzate in modo gerarchico.

Capire come sono strutturate le API è essenziale per gli sviluppatori. Ogni livello nella gerarchia delle API può cambiare come l'API viene usata nel codice. Ad esempio, consideriamo una libreria come NumPy, che ha vari moduli per diverse operazioni matematiche. Quando uno sviluppatore usa NumPy, deve conoscere il modo corretto per riferirsi alla funzione specifica di cui ha bisogno.

Quindi, è cruciale per i modelli di codice imparare accuratamente i nomi delle API. Questa comprensione può non solo aiutare a usare le API correttamente, ma anche migliorare l'automazione del design delle API.

#Knowledge Probing e la Sua Applicazione

Il knowledge probing si riferisce a tecniche che testano la comprensione di un modello su idee o informazioni specifiche. In questo studio, usiamo il knowledge probing per valutare quanto bene i modelli di codice comprendano i nomi delle API. Questo approccio implica creare test che chiedono ai modelli di prevedere le parti mancanti dei nomi delle API in base al loro contesto nel codice.

Ad esempio, se a un modello viene presentata una dichiarazione riguardante una chiamata API e una parte di quella dichiarazione è nascosta, il compito del modello è riempire lo spazio vuoto. Questi tipi di test possono rivelare la conoscenza sottostante che un modello ha sulle API e come organizza quella informazione.

Il nostro obiettivo principale con questo studio è determinare:

1. Quanto bene i modelli di codice comprendono le chiamate e gli import delle API?
2. Possono i modelli di codice comprendere gli alias delle API?
3. Aggiungere contesto in linguaggio naturale migliora la comprensione dei nomi delle API?
4. Quanto bene i modelli di codice ricordano e generalizzano ciò che imparano sui nomi delle API?

#Impostazione dell'Esperimento

Per valutare la conoscenza dei nomi delle API da parte dei modelli di codice, abbiamo creato un benchmark chiamato PyINK. Questo benchmark è progettato per testare la comprensione dei nomi delle API di Python attraverso vari quiz. Abbiamo utilizzato una raccolta di codice sorgente Python da vari repository per estrarre i nomi delle API. I quiz erano strutturati per valutare sia le chiamate API che gli import, con alcuni quiz incentrati sugli alias degli import delle API.

Nei nostri esperimenti, abbiamo utilizzato 10 modelli di codice diversi, inclusi varianti di CodeBERT e GraphCodeBERT. Abbiamo anche incluso un modello chiamato GPT-3.5-turbo, che non era stato specificamente addestrato per questo compito. Ogni modello è stato testato su quanto accuratamente potesse prevedere le parti mancanti dei nomi delle API in vari contesti.

Abbiamo categorizzato i nostri test in tre aree principali: chiamate API standard, import API e import API con alias. Ogni area era progettata per sondare aspetti specifici della comprensione dei nomi delle API da parte dei modelli.

#Chiamate e Import delle API

Il primo set di quiz si è concentrato sulle chiamate API. Qui, abbiamo presentato ai modelli delle dichiarazioni in cui parti del nome dell'API erano mascherate e abbiamo chiesto loro di prevedere i componenti mancanti. Abbiamo scoperto che i modelli generalmente si comportavano meglio nel prevedere le chiamate API rispetto agli import API.

Quando i modelli sono stati testati su dichiarazioni di import API, le loro prestazioni variavano significativamente. Alcuni modelli faticavano a prevedere correttamente i nomi degli import, suggerendo che potrebbero non codificare la conoscenza degli import API così efficacemente come fanno per le chiamate API.

Inoltre, abbiamo anche indagato quanto bene i modelli comprendano gli alias degli import delle API, che sono nomi alternativi per la stessa API. Questi alias possono essere comuni, specialmente in linguaggi di programmazione come Python. Abbiamo scoperto che mentre i modelli mostravano una certa comprensione degli alias, le loro prestazioni non erano ancora così forti come ci si aspettava.

#Ruolo del Contesto in Linguaggio Naturale

Per analizzare l'effetto del contesto in linguaggio naturale sulla capacità dei modelli di comprendere i nomi delle API, abbiamo creato quiz che includevano descrizioni pertinenti in linguaggio naturale accanto ai nomi delle API. I nostri risultati hanno indicato che incorporare il contesto in linguaggio naturale aiutava a migliorare leggermente le prestazioni dei modelli.

Tuttavia, mentre il supporto del linguaggio naturale può aiutare in alcune recupero dei nomi delle API, non ha cambiato le prestazioni relative dei diversi modelli. Questa scoperta suggerisce che mentre il contesto è importante, la comprensione fondamentale dei nomi delle API da parte dei modelli gioca ancora un ruolo critico su quanto bene possano prevedere i nomi correttamente.

#Memorizzazione e Generalizzazione

Un altro aspetto importante del nostro studio è stato valutare quanto bene i modelli possono memorizzare e generalizzare la conoscenza sui nomi delle API. Abbiamo testato sia le API viste che quelle non viste: le API viste erano quelle che i modelli avevano incontrato durante l'addestramento, mentre le API non viste erano nuove per i modelli durante il test.

I nostri esperimenti hanno dimostrato che i modelli generalmente si comportavano meglio sulle API viste, indicando che avevano ricordato efficacemente aspetti delle API su cui erano stati addestrati. Tuttavia, hanno anche dimostrato una ragionevole capacità di generalizzare a nuove API, il che è un segno incoraggiante per la loro applicabilità in scenari di coding reali.

#Risultati e Implicazioni

I risultati del nostro studio rivelano diversi risultati importanti sulla comprensione dei nomi delle API da parte dei modelli di codice pre-addestrati:

1. Conoscenza Limitata dei Nomi delle API: Anche se i modelli possono memorizzare alcune conoscenze sui nomi delle API, spesso non hanno una comprensione completa. Questa limitazione indica la necessità di miglioramenti nel modo in cui i modelli vengono addestrati a riconoscere e utilizzare i nomi delle API in modo efficace.

2. Comprensione Diversificata tra i Modelli: Ci sono state variazioni nelle prestazioni tra i diversi modelli di codice, con alcuni modelli che superavano costantemente gli altri. Queste differenze suggeriscono che approcci di addestramento specifici e architetture dei modelli possono influenzare notevolmente quanto bene un modello comprende i nomi delle API.

3. Impatto del Contesto in Linguaggio Naturale: Incorporare contesto in linguaggio naturale può offrire qualche miglioramento nelle capacità dei modelli, ma la comprensione generale rimane in gran parte dipendente dall'addestramento di base dei modelli.

4. Memorizzazione vs. Generalizzazione: La capacità di generalizzare a nuove API è promettente e suggerisce che i modelli possono adattare la loro conoscenza appresa a nuovi contesti, il che è essenziale in ambienti di programmazione dinamici.

#Conclusione

Questo studio contribuisce con preziose intuizioni sulla comprensione dei nomi delle API da parte dei modelli di codice pre-addestrati. Mostrando come i modelli si comportano in vari compiti relativi ai nomi delle API, evidenziamo aree in cui sono necessari miglioramenti. Le nostre scoperte enfatizzano l'importanza delle strategie di addestramento e il ruolo del contesto in linguaggio naturale nel migliorare la conoscenza del modello.

Affinando il modo in cui i modelli di codice apprendono sulle API, possiamo migliorare la loro efficacia nel supportare gli sviluppatori nella creazione di software. Le implicazioni di questa ricerca si estendono oltre la semplice comprensione delle API, poiché possono informare futuri sviluppi in strumenti e tecniche di coding automatizzati.

Man mano che la programmazione evolve, ulteriori esplorazioni su come i modelli gestiscono e applicano la conoscenza saranno vitali per far avanzare le pratiche di intelligenza del codice.