Coder à l’aide d’un grand modèle de langage (LLM)

1. Introduction
2. Hallucinations ?
3. Exemple

Introduction

L’une des applications les plus pertinentes des grands modèles de langage (LLM) tels que GPT-4 est la programmation, notamment en Python ou JavaScript. Le résultat est généralement propre, bien structuré, lisible, et correct. L’agent conversationnel ChatGPT fournit même un interpréteur pour exécuter du code, écrit par lui ou provenant de l’extérieur. Si le code a été généré par un LLM, cette phase de test ne doit pas être négligée, bien au contraire.

Hallucinations ?

Un test permet notamment de s’assurer de l’absence d’hallucinations. De quoi s’agit-il ? Le LLM peut par exemple recourir à des méthodes ou librairies totalement inexistantes ! Une simple exécution du code permettra de s’en rendre compte immédiatement, au contraire de bugs plus subtils présents dans le programme.

Afin de minimiser ces hallucinations, une solution peut consister à comparer différents modèles. Moins connus que GPT-4 d’OpenAI ou Gemini-2.0 de Google, les modèles Claude 3.7 Sonnet d’Anthropic ou Grok-3 de xAI (sur le réseau social X d’Elon Musk) pourraient par exemple s’avérer supérieurs pour programmer. Idem pour DeepSeek-R1 de DeepSeek, sous licence MIT. Pour une liste plus complète, il est possible de consulter un classement des meilleurs LLMs.

Exemple

Demander à DeepSeek (modèle DeepSeek-V3) de générer un code qui sauvegarde dans un fichier texte un dictionnaire de ndarrays fournit le code suivant :

import numpy as np

# Exemple de dictionnaire contenant des ndarray
data = {
    'array1': np.array([1, 2, 3]),
    'array2': np.array([[4, 5], [6, 7]]),
    'array3': np.array([8, 9, 10])
}

# Sauvegarder le dictionnaire dans un fichier texte
with open('sauvegarde.txt', 'w') as f:
    for key, value in data.items():
        f.write(f"{key}:\n")
        np.savetxt(f, value, fmt='%d')  # fmt='%d' pour sauvegarder en entiers
        f.write("\n")  # Ajouter une ligne vide entre les tableaux

Avec la même requête, ChatGPT (modèle GPT-4-turbo) donne la réponse suivante, plus complexe :

import numpy as np
import pickle

def save_ndarray_dict(file_path, data_dict):
    """
    Sauvegarde un dictionnaire de numpy ndarrays dans un fichier texte en utilisant pickle.
    :param file_path: Chemin du fichier où sauvegarder les données
    :param data_dict: Dictionnaire contenant des ndarrays
    """
    with open(file_path, 'wb') as f:
        pickle.dump(data_dict, f)

def load_ndarray_dict(file_path):
    """
    Charge un dictionnaire de numpy ndarrays depuis un fichier texte.
    :param file_path: Chemin du fichier contenant les données sauvegardées
    :return: Dictionnaire des ndarrays chargés
    """
    with open(file_path, 'rb') as f:
        return pickle.load(f)

# Exemple d'utilisation
data = {
    'array1': np.random.rand(3, 3),
    'array2': np.arange(10)
}

save_ndarray_dict('data.pkl', data)

# Chargement et affichage des données
loaded_data = load_ndarray_dict('data.pkl')
print(loaded_data)

GPT-4 justifie sa réponse en précisant qu’il utilise le module pickle pour assurer la préservation des structures de données (notamment leur type exact, ce qui conserve la précision). Pas d’hallucination cette fois, pickle existe bien. Une exécution dans l’interpréteur Canvas de ChatGPT permet de s’en assurer.