Assistenti al Codice: Benchmark, Prompt e Modelli Instruct

I modelli AI per la generazione di codice sono sempre più diffusi ma come si valuta la loro efficacia? Benchmark, prompt ottimizzati e differenze tra modelli standard e Instruct fanno la differenza.

Benchmark per la Valutazione degli Assistenti al Codice

I benchmark per la valutazione degli LLM si dividono in due categorie principali:

Benchmark per esercizi singoli

Questi test valutano la capacità di un modello di generare codice corretto per problemi isolati. Alcuni dei più utilizzati includono:

• HumanEval (di OpenAI): focalizzato su Python, misura l’accuratezza nella generazione di funzioni.
• **MultiPL-E**: estende HumanEval ad altri linguaggi tra cui Java.

Al momento MultiPL-E comprende 158 quesiti per Java accessibili da questo link e grazie alla console SQL ( powered by DuckDB WASM ) è possibile ispezionare i test direttamente dal browser.

Se proviamo a guardare le colonne del dataset quelle di nostro interesse sono:

• **prompt** - Contiene la descrizione del problema di programmazione e rappresenta l'input fornito al modello per generare codice.
• **tests** - Contiene test case formattati nel linguaggio di destinazione (ad esempio, in Java). Questi test sono usati per verificare se il codice generato dal modello soddisfa le specifiche del problema.
• **stop_tokens** - Definisce i caratteri o le sequenze che segnalano al modello quando interrompere la generazione del codice. Questo aiuta a prevenire output eccessivi o non desiderati.

Prompt:

import java.util.*; 
import java.lang.reflect.*; 
import org.javatuples.*; 
import java.security.*; 
import java.math.*; 
import java.io.*; 
import java.util.stream.*; 
class Problem { 
// Return length of given string 
// >>> stringLength(("")) // (0l) 
// >>> stringLength(("abc")) // (3l) 
public static long strlen(String string) {

Tests:

} 
public static void main(String[] args) { 
  assert(strlen(("")) == (0l)); 
  assert(strlen(("x")) == (1l)); 
  assert(strlen(("asdasnakj")) == (9l)); 
} 
}

Stop Token:

}

Benchmark per applicazioni complesse

Questi benchmark valutano la capacità dei modelli di generare applicazioni complete:

• BigApp Benchmark: misura la capacità di un LLM di sviluppare applicazioni full-stack (HTML/JS per il frontend, Java/Python per il backend e SQLite come database).

In questi scenari avanzati, strumenti di orchestrazione tra agenti AI come CrewAI e LangChain stanno guadagnando popolarità.

sempre più spesso vengono realizzati benchmark che mettono a confronto giochi creati da diversi LLM, valutando aspetti come la qualità del codice, l’ottimizzazione delle prestazioni e la capacità di generare logica di gioco.

Creare un Benchmark Aziendale Personalizzato

Sebbene questi benchmark siano utili per un confronto generale, sarebbe corretto definire un proprio benchmark aziendale. Questo dovrebbe includere:

• Stack tecnologico di riferimento: test specifici sulle tecnologie effettivamente utilizzate in azienda. In particolare nel caso di framework proprietari.
• Problematiche specifiche: valutazione su scenari concreti legati al business.
• Policy di sicurezza: verifica della conformità agli standard aziendali.
• Integrazione CI/CD: test per garantire compatibilità con i flussi di sviluppo e rilascio automatizzati.

Definire un benchmark su misura permette di valutare con maggiore precisione quale assistente al codice sia più efficace nel proprio contesto operativo.

Benchmark per capacità di ragionamento

Valutano quanto un modello LLM possa risolvere problemi complessi che richiedono logica, deduzione e comprensione avanzata. Come ad esempio valutare la capacità di risolvere problemi matematici, scientifici o di logica, sostenere un ragionamento in più passaggi. Alcuni fra i benchmark:

• MMLU (Measuring Massive Multitask Language Understanding): Questo benchmark comprende 16.000 domande a scelta multipla che coprono 57 materie accademiche, tra cui matematica, filosofia, diritto e medicina. È progettato per valutare la comprensione multitasking dei modelli linguistici.​
• GPQA (Graduate-Level Google-Proof Q&A): Consiste in 448 domande a scelta multipla scritte da esperti in biologia, fisica e chimica, progettate per essere a livello di dottorato e “a prova di Google”, richiedendo una comprensione approfondita e capacità di ragionamento che non possono essere facilmente trovate tramite una semplice ricerca online.​

Prompt Ottimizzati per la Generazione di Codice

Per ottenere i migliori risultati dai modelli LLM, è fondamentale scrivere prompt chiari e mirati. Ad esempio, quando si richiede codice Java, è utile specificare:

• Struttura dell’output: delimitare il codice tra tag come [inizio codice] e [fine codice].
• Limitazioni: specificare l’assenza di dipendenze esterne o spiegazioni aggiuntive.
• Linguaggio di richiesta: se il modello supporta l’italiano, usarlo per migliorare la comprensione.

Esempio di

prompt ottimizzato con Qwen2.5-coder:Qwen2.5-coder:

>ollama run qwen2.5-coder:7b
>>> genera il codice java per invocare un endpoint REST senza dipendenze 
esterne. il codice deve essere incluso tra "[inizio codice]" e "[fine codice]". 
Non includere commenti o spiegazioni

```java
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class RestCaller {
    public static void main(String[] args) {
        try {
            URL url = new URL("https://api.example.com/data");
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("GET");

            int responseCode = connection.getResponseCode();
            System.out.println("Response Code: " + responseCode);

            if (responseCode == HttpURLConnection.HTTP_OK) {
                BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
                String inputLine;
                StringBuffer response = new StringBuffer();

                while ((inputLine = in.readLine()) != null) {
                    response.append(inputLine);
                }
                in.close();

                System.out.println("Response: " + response.toString());
            } else {
                System.out.println("GET request not worked");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Send a message (/? for help)

Modelli Instruct

[embed]Big Code Models Leaderboard - a Hugging Face Space by bigcode Discover amazing ML apps made by the communityhuggingface.co

Se guardiamo la leaderbord si nota subito la presenza dei modelli Instruct:

I modelli standard tendono a generare output con dettagli aggiuntivi come:

• Spiegazioni sul funzionamento del codice.
• Commenti all’interno del codice generato.
• Possibile output ridondante o non ottimizzato.

I modelli Instruct, come CodeLlama-Instruct, sono addestrati per seguire istruzioni precise e produrre output concisi. Questo li rende ideali per:

• Generazione di codice eseguibile senza dettagli superflui.
• Completamento di task specifici.
• Integrazione diretta in workflow automatizzati.

Conclusioni

La scelta del miglior assistente al codice dipende da diversi fattori:

• Benchmark e test specifici per valutare le capacità del modello.
• Prompt ottimizzati per ottenere risultati migliori.
• Uso di modelli Instruct per generare codice mirato e senza distrazioni.
• Esecuzione locale o cloud in base alle esigenze di privacy e scalabilità.

i modelli LLM, in particolare quelli privati, vengono sempre più valutati sullo sviluppo di intere applicazioni e di conseguenza anche i benchmark riflettono questo cambiamento, analizzando la capacità dei modelli di affrontare workflow di sviluppo completi, dalla progettazione alla realizzazione di software funzionante.

Follow me on https://www.linkedin.com/in/farinamaurizio/ or https://x.com/MaurizioDouble0

Questo articolo è personale e non rappresenta le posizioni, strategie o opinioni del mio datore di lavoro.

ChatGPT è da considerare come co-autore.