Arrêtez de classer les configurations d'agents par score moyen

Arrêtez de classer les configurations d'agents par score moyen

Dans la course à la création d'agents IA les plus efficaces, de nombreuses équipes se tournent par défaut vers une métrique unique et simpliste : le score moyen sur un ensemble de tâches d'évaluation. Que vous affiniez un modèle de langage, configuriez des pipelines de génération augmentée par récupération (RAG) ou optimisiez la logique d'utilisation d'outils, la tentation de classer les configurations d'agents par leur performance moyenne est presque irrésistible. Mais cette approche est fondamentalement erronée. Les scores moyens masquent la variance, cachent les modes d'échec et récompensent les configurations qui sont « assez bonnes » partout mais excellentes nulle part. Dans cet article, nous explorerons pourquoi le classement par score moyen est trompeur, comment aller au-delà, et fournirons des étapes concrètes pour mettre en œuvre un cadre d'évaluation plus robuste.

Le problème des moyennes

Considérons un scénario simple : vous avez deux configurations d'agents, A et B, testées sur 10 tâches diverses. La configuration A obtient 95 sur 9 tâches mais échoue de manière catastrophique sur une tâche, avec un score de 0. La configuration B obtient 70 sur les 10 tâches. Le score moyen pour A est de 85,5, tandis que la moyenne de B est de 70. Sur la seule base de la moyenne, vous classeriez A plus haut. Mais dans un système de production, l'échec catastrophique de A pourrait signifier la perte d'un client, la corruption d'une base de données ou la génération de contenu nuisible. B, bien que moins spectaculaire, est fiable sur tous les tableaux. Le score moyen obscurcit complètement ce compromis critique.

Ce n'est pas qu'une préoccupation théorique. En pratique, l'évaluation des agents implique souvent des tâches de difficulté variable, des cas limites et des scénarios de longue traîne. Les moyennes compressent ces informations riches en un seul nombre, ignorant la forme de la distribution, la variance et le comportement dans le pire des cas. Comme le soulignent les discussions sur des plateformes comme Towards Data Science, les limites des métriques basées sur la moyenne sont bien connues en apprentissage automatique, mais elles persistent dans l'évaluation des agents par commodité.

Pourquoi les agents amplifient le problème

Les agents diffèrent des modèles ML traditionnels de manière clé qui rend le classement par score moyen encore plus dangereux :

• **Dépendances séquentielles** : Les actions d'un agent dans les premières étapes affectent les résultats ultérieurs. Une seule mauvaise décision peut entraîner une cascade d'échecs totaux.
• **Utilisation d'outils** : Les agents appellent souvent des API externes, des bases de données ou des services web. Une configuration qui fonctionne 95 % du temps peut échouer dans des cas limites critiques.
• **Non-déterminisme** : En raison des réglages de température, de l'échantillonnage ou de facteurs externes, la même configuration peut produire des résultats différents sur la même entrée.

Les scores moyens cachent ces dynamiques. Une configuration qui échoue parfois de manière spectaculaire peut encore avoir une moyenne élevée si elle réussit assez souvent. Mais en production, « assez souvent » n'est pas suffisant.

Prérequis

Avant de plonger dans l'implémentation, décrivons ce dont vous aurez besoin pour suivre les exemples de cet article.

• **Python 3.9+** installé sur votre système.
• **pip** gestionnaire de paquets.
• Connaissance de base de Python, des outils en ligne de commande et du JSON.
• Optionnellement, **Docker** si vous souhaitez exécuter des évaluations dans des environnements isolés.

Nous utiliserons plusieurs bibliothèques open-source :

• `pandas` pour la manipulation des données
• `numpy` pour les calculs statistiques
• `matplotlib` et `seaborn` pour la visualisation
• `scipy` pour les tests statistiques

Vous aurez également besoin d'un ensemble de données de résultats d'évaluation d'agents. Pour la démonstration, nous créerons des données synthétiques, mais vous pouvez les remplacer par les vôtres.

Installation étape par étape

1. Configurer un environnement virtuel

Créez d'abord un environnement dédié pour éviter les conflits de dépendances.

python3 -m venv agent-eval-env
source agent-eval-env/bin/activate  # Sur Windows : agent-eval-env\Scripts\activate

2. Installer les paquets requis

Installez les bibliothèques principales que nous utiliserons pour l'analyse et la visualisation.

pip install pandas numpy matplotlib seaborn scipy

Cela installe tout ce qui est nécessaire pour les exemples ci-dessous.

3. Vérifier l'installation

Effectuez une vérification rapide pour vous assurer que tout fonctionne.

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from scipy import stats
print("Toutes les importations ont réussi !")

Si aucune erreur n'apparaît, vous êtes prêt à continuer.

Aller au-delà des scores moyens

Au lieu de classer par moyenne, nous adopterons une approche d'évaluation multidimensionnelle. Les idées clés sont :

1. **Rapporter les statistiques de distribution** : Inclure la médiane, l'intervalle interquartile (IQR), le minimum et le maximum des scores. 2. **Analyser les modes d'échec** : Identifier les tâches spécifiques où les configurations échouent et pourquoi. 3. **Utiliser des tests statistiques** : Comparer les configurations avec des intervalles de confiance, pas seulement des estimations ponctuelles. 4. **Visualiser les performances** : Utiliser des boîtes à moustaches, des diagrammes en violon et des cartes de chaleur pour révéler les tendances.

Implémentons ces étapes avec du code concret.

Création d'un ensemble de données d'évaluation synthétique

D'abord, nous allons générer un ensemble de données qui imite les résultats réels d'évaluation d'agents. En pratique, vous chargeriez votre propre fichier CSV ou JSON.

import pandas as pd
import numpy as np

np.random.seed(42)
n_tasks = 20
n_configs = 5

# Générer les noms des tâches
tasks = [f"tache_{i}" for i in range(n_tasks)]

# Créer des scores synthétiques pour chaque configuration
# Config A : élevé sur la plupart, catastrophique sur une
config_a = np.random.normal(90, 5, n_tasks)
config_a[0] = 0  # échec catastrophique

# Config B : cohérent, modéré
config_b = np.random.normal(70, 3, n_tasks)

# Config C : variance élevée
config_c = np.random.normal(80, 20, n_tasks)

# Config D : bimodale (certaines tâches excellentes, d'autres médiocres)
config_d = np.concatenate([np.random.normal(95, 2, 10), np.random.normal(40, 10, 10)])

# Config E : médiocre mais stable
config_e = np.random.normal(60, 2, n_tasks)

# Assembler dans un DataFrame
data = pd.DataFrame({
    'tache': tasks * n_configs,
    'config': ['A']*n_tasks + ['B']*n_tasks + ['C']*n_tasks + ['D']*n_tasks + ['E']*n_tasks,
    'score': np.concatenate([config_a, config_b, config_c, config_d, config_e])
})

print(data.head())

Calcul des statistiques récapitulatives

Calculons maintenant des statistiques significatives au-delà de la moyenne.

summary = data.groupby('config')['score'].agg([
    'mean', 'median', 'std', 'min', 'max',
    lambda x: x.quantile(0.25),
    lambda x: x.quantile(0.75)
])
summary.columns = ['moyenne', 'mediane', 'ecart_type', 'min', 'max', 'q25', 'q75']
summary = summary.sort_values('moyenne', ascending=False)
print(summary.round(2))

Remarquez comment la configuration A a la moyenne la plus élevée (environ 85,5) mais un minimum de 0. La configuration B a une moyenne plus faible (70) mais un minimum de 64. Si vous ne regardiez que les moyennes, vous choisiriez A. Mais le minimum révèle le défaut fatal de A.

Visualisation des distributions

Une image vaut mille moyennes. Créons un diagramme en boîte.

import matplotlib.pyplot as plt
import seaborn as sns

plt.figure(figsize=(10, 6))
sns.boxplot(data=data, x='config', y='score', order=['A','B','C','D','E'])
plt.title('Distribution des scores par configuration d\'agent')
plt.ylabel('Score')
plt.xlabel('Configuration')
plt.show()

Le diagramme en boîte montre immédiatement la valeur aberrante de la configuration A à 0. La configuration C a une grande dispersion. La configuration D est bimodale (deux clusters distincts). Les configurations B et E sont serrées mais faibles. Cette visualisation vous en dit bien plus qu'un tableau de moyennes.

Comparaison statistique avec intervalles de confiance

Au lieu de classer par moyenne, utilisez des intervalles de confiance pour comparer les configurations.

from scipy import stats

def intervalle_confiance_moyenne(data, confiance=0.95):
    a = 1.0 * np.array(data)
    n = len(a)
    se = stats.sem(a)
    h = se * stats.t.ppf((1 + confiance) / 2., n-1)
    return np.mean(a), np.mean(a)-h, np.mean(a)+h

ci_df = data.groupby('config')['score'].apply(
    lambda x: intervalle_confiance_moyenne(x)
).apply(pd.Series)
ci_df.columns = ['moyenne', 'ci_inf', 'ci_sup']
print(ci_df.round(2))

L'intervalle de confiance de la configuration A est large (d'environ 73 à 98) à cause de la valeur aberrante. Celui de la configuration B est étroit (68 à 72). Des intervalles qui se chevauchent suggèrent que les configurations pourraient ne pas être statistiquement différentes, malgré des différences de moyennes.

Analyse des modes d'échec

Identifiez les tâches qui causent des échecs. Nous allons signaler tout score en dessous d'un seuil.

seuil = 50  # Définir le seuil d'échec
echecs = data[data['score'] < seuil]
print("Échecs (score < 50) :")
print(echecs.groupby(['config', 'tache']).size().unstack(fill_value=0))

La configuration A échoue uniquement sur tache_0. La configuration C échoue sur plusieurs tâches. La configuration D échoue sur les tâches 10-19. Cela identifie précisément où chaque configuration rencontre des difficultés.

Exemples d'utilisation

Exemple 1 : Comparer deux configurations

Supposons que vous deviez choisir entre la configuration A et la configuration B. Au lieu de comparer les moyennes, effectuez un test t pour deux échantillons ou un test U de Mann-Whitney.

scores_config_a = data[data['config'] == 'A']['score']
scores_config_b = data[data['config'] == 'B']['score']

t_stat, p_value = stats.ttest_ind(scores_config_a, scores_config_b)
print(f"Test t : t={t_stat:.3f}, p={p_value:.3f}")

# Alternative non paramétrique
u_stat, p_value_u = stats.mannwhitneyu(scores_config_a, scores_config_b)
print(f"Mann-Whitney U : U={u_stat:.0f}, p={p_value_u:.3f}")

Une valeur p élevée (>0,05) signifie que vous ne pouvez pas conclure que les configurations sont différentes, même si les moyennes diffèrent.

Exemple 2 : Créer un diagramme radar pour une évaluation multi-métrique

Définissez plusieurs métriques (par exemple, précision, latence, robustesse, sécurité) et tracez-les.

# Simuler plusieurs métriques
metriques = ['precision', 'latence', 'robustesse', 'securite']
config_metriques = {
    'A': [90, 50, 60, 20],
    'B': [70, 80, 85, 90],
    'C': [80, 60, 70, 60]
}

import numpy as np
import matplotlib.pyplot as plt

angles = np.linspace(0, 2*np.pi, len(metriques), endpoint=False).tolist()
angles += angles[:1]

fig, ax = plt.subplots(figsize=(8,8), subplot_kw=dict(polar=True))
for config, valeurs in config_metriques.items():
    valeurs += valeurs[:1]
    ax.plot(angles, valeurs, label=config)
    ax.fill(angles, valeurs, alpha=0.1)
ax.set_xticks(angles[:-1])
ax.set_xticklabels(metriques)
ax.legend(loc='upper right')
plt.show()

La configuration A excelle en précision mais échoue en sécurité. La configuration B est équilibrée. Le diagramme radar rend les compromis évidents.

Exemple 3 : Automatiser le pipeline d'évaluation

Créez un script Python qui charge les résultats, calcule les statistiques et génère un rapport.

# sauvegarder sous evaluate_agents.py
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from scipy import stats

def evaluer_agents(chemin_csv, dossier_sortie='./resultats_eval'):
    import os
    os.makedirs(dossier_sortie, exist_ok=True)
    
    df = pd.read_csv(chemin_csv)
    
    # Statistiques récapitulatives
    summary = df.groupby('config')['score'].agg(['mean','median','std','min','max'])
    summary.to_csv(f'{dossier_sortie}/resume.csv')
    
    # Diagramme en boîte
    plt.figure()
    sns.boxplot(data=df, x='config', y='score')
    plt.savefig(f'{dossier_sortie}/boite_moustaches.png')
    
    # Analyse des échecs
    echecs = df[df['score'] < 50]
    echecs.to_csv(f'{dossier_sortie}/echecs.csv')
    
    print(f"Résultats sauvegardés dans {dossier_sortie}")

if __name__ == '__main__':
    evaluer_agents('resultats.csv')

Exécutez-le avec :

python evaluate_agents.py

Conclusion

Classer les configurations d'agents par score moyen est une simplification dangereuse qui masque la variance, cache les échecs catastrophiques et récompense la médiocrité. Adoptez plutôt un cadre d'évaluation plus riche qui inclut les statistiques de distribution, les visualisations, les intervalles de confiance et l'analyse des modes d'échec. Le code et les exemples fournis ici vous donnent un point de départ pratique pour implémenter cela dans vos propres projets.

En allant au-delà des moyennes, vous prendrez des décisions plus éclairées, construirez des agents plus robustes et éviterez des surprises coûteuses en production. Rappelez-vous : l'objectif n'est pas de trouver la configuration avec la moyenne la plus élevée, mais de trouver celle qui fonctionne de manière fiable dans les scénarios qui comptent le plus.