Qu’est-ce que HumanEval ?

HumanEval est un benchmark permettant d’évaluer les capacités de génération de code des grands modèles de langage (LLM). Il a été développé par OpenAI pour évaluer les premières versions des modèles d’IA qui alimentent Codex, l’agent d’ingénierie logicielle de l’entreprise.

Le benchmark HumanEval est spécialement conçu pour le code généré en Python. Il va au-delà de la syntaxe pour vérifier si le code créé est précis et fonctionne comme prévu.

Le cadre du benchmark est accessible sur le dépôt GitHub d’OpenAI HumanEval. HumanEval dispose également d’un classement de performance des différents modèles de génération de code, notamment la suite Claude, Kimi K2, Google Gemma et Gemini, GPT-5 et les modèles plus anciens GPT-4o et GPT-4, et la famille IBM® Granite.

Le jeu de données HumanEval se compose de 164 problèmes de programmation écrits à la main, avec leurs tests unitaires correspondants.¹ Ces problèmes évaluent la capacité des modèles à comprendre le langage, à manipuler les chaînes, à rechercher et à trier. Ils évaluent également les capacités de résolution de problèmes en termes de mathématiques simples et d’algorithmes complexes. Ces tâches de programmation sont similaires aux questions algorithmiques, aux exercices de codage ou aux défis de conception systèmes auxquels les développeurs de logiciels sont confrontés lors des entretiens techniques.

Chaque tâche de génération de code contient les composantes suivantes :

• Signature de la fonction
  
  
• Docstring
  
  
• Corps de la fonction
  
  
• Tests unitaires

La signature définit le nom et les paramètres de la fonction. A titre d’exemple, voici la signature d’une fonction qui calcule le produit de deux entiers :            

def multiply(a, b):

Une docstring est une prompt en langage naturel ou une description du comportement attendu, des objectifs, des entrées et des sorties de la fonction. Ces commentaires décrivent le rôle de la fonction et guident le modèle lors de la génération du code Python.

Par exemple, la docstring de la fonction de multiplication sera :

“””Complete the function that takes two integers as inputs
and returns their product as the output.
Assume the inputs are always valid.
Examples:
multiply(8, 2) must return 16
multiply(0, 777) must return 0
multiply(-32,64) must return -2048
“””

Il s’agit d’un segment alloué au code produit par un modèle. Il contient la solution mise en œuvre pour résoudre le problème, étant donné la signature de la fonction et la docstring.

Ces cas de test vérifient l’exactitude fonctionnelle du code généré dans différents scénarios. Chaque test fournit des entrées spécifiques à la fonction, puis compare les sorties aux résultats escomptés.

Voici quelques exemples de tests unitaires pour la fonction de multiplication :

def test_multiply():
    assert multiply(89, 0) == 0
    assert multiply(37, -5) == -185
    assert multiply(66, 17) == 1122

De nombreux benchmarks pour LLM de codage appliquent des méthodes utilisées pour la génération de texte telles que les indicateurs basés sur la correspondance, qui comparent les échantillons de code générés à une solution de référence. Mais les indicateurs basés sur la correspondance ne tiennent généralement pas compte des différentes manières dont un problème peut être résolu, dont chacune peut être fonctionnellement équivalente à la solution de référence.

C’est pourquoi le benchmark HumanEval s’est tourné vers l’exactitude fonctionnelle, qui considère un échantillon de code généré comme étant correct s’il réussit une série de tests unitaires. Cette approche reflète la façon dont les développeurs évaluent la réussite de leur code en le soumettant à une série de tests unitaires et en s’assurant qu’il les réussit tous.

HumanEval mesure l’exactitude fonctionnelle à l’aide de l'indicateur pass@k. Pour chaque problème, un modèle génère k échantillons de code. Si l’un de ces échantillons réussit les tests unitaires, le problème est considéré comme correctement résolu. L’indicateur pass@k estime la probabilité qu’au moins un des k échantillons soit fonctionnellement correct.

HumanEval n’est que l’un des nombreux benchmarks qui permettent d’évaluer les LLM de codage. Les équipes de développement logiciel doivent toujours évaluer le code généré par LLM à l’aide de leurs propres tests internes et combiner plusieurs indicateurs pour avoir une vision plus complète de la performance du modèle. L’approche l’humain dans la boucle reste également cruciale pour garantir l’exactitude du code généré par l’IA et affiner et améliorer les modèles de machine learning au fil du temps.

Voici quelques limitations du benchmark HumanEval :

• Contamination
  
  
• Manque de complexité du monde réel
  
  
• Indicateur étroit des capacités de codage
  
  
• Prise en charge restreinte des langages de programmation

Les problèmes de programmation inclus dans le jeu de données ont pu être rencontrés lors de l’entraînement du modèle en raison de leur large disponibilité. Le nombre de problèmes est aussi suffisamment réduit pour que les modèles de génération de code puissent tous les mémoriser.

Les tâches de génération de code dans HumanEval se situent généralement dans la fourchette facile à moyenne. Pourtant, les tâches de programmation réelles ont tendance à être plus complexes, englobant des intégrations d’API avec plusieurs systèmes, d’immenses code bases et de vastes jeux de données.

Le benchmark ne reflète pas non plus l’état souvent enchevêtré des environnements de développement logiciel et des workflows dans le monde réel : cas d’utilisation évolutifs, cas de test incomplets, exigences incohérentes, code hérité ou spécifications vagues, pour n’en citer que quelques-uns.

La programmation ne se résume pas à une simple exactitude fonctionnelle. Par exemple, HumanEval ne prend pas en compte l’efficacité. Cela signifie qu’un code généré par LLM qui est exact et qui fonctionne comme prévu n’est peut-être pas la solution la plus efficace et la plus optimisée en termes de performance.

Le benchmark ne prend pas non plus en compte les bonnes pratiques de programmation telles que les conventions de codage, les normes de style, la gestion des erreurs, la validation des entrées et le codage sécurisé.

HumanEval est spécialement conçu pour le langage de programmation open source Python. Le code source généré dans d’autres langages doit être évalué à l’aide d’autres benchmarks.

Le benchmark propose différentes versions qui corrigent certaines de ses limites :

• HumanEval+
   

• HumanEval-V
   

• HumanEval-X
   

• HumanEvalNext

Chaque problème de programmation dans HumanEval comporte en moyenne 7 à 8 tests unitaires.¹ HumanEval+ augmente considérablement cette couverture de tests, pour atteindre une moyenne de 764 tests par problème, permettant ainsi une évaluation plus rigoureuse.²

HumanEval-V s’appuie sur son prédécesseur pour créer un benchmark pour les modèles d’IA multimodale, en particulier les modèles de langage-vision (VLM). Il mesure la capacité des VLM à comprendre et à raisonner à partir de tableaux, de diagrammes et de graphiques dans des contextes de programmation, en générant du code basé sur des organigrammes d’algorithmes ou des transformations de matrices, par exemple.

HumanEval-X étend le benchmark initial aux langages de programmation C++, Go, Java et JavaScript. Ses 820 tâches peuvent être utilisées pour évaluer les compétences en matière de génération et de traduction de code.

HumanEvalNext améliore HumanEval. Il ajoute plus de contexte grâce à des annotations de type (syntaxe de programmation pour indiquer les types de données des paramètres de fonction et des valeurs de retour), intègre plus de cas extrêmes, introduit davantage de tests unitaires et augmente la difficulté des problèmes.³