Poser des questions à un DataFrame : comment l’agent Pandas de LangChain crée des graphiques

Dans le passé, l’analyse d’un ensemble de données exigeait une maîtrise avancée d’un langage de requête ou d’une bibliothèque de visualisation pour pouvoir identifier ne serait-ce qu’une seule tendance. Avec un agent piloté par un LLM devant un DataFrame pandas, vous pouvez au contraire taper une demande telle que « afficher le comptage des genres sous forme de barres » et obtenir à la fois un graphique et une brève explication. Cette commodité s’accompagne cependant de risques réels, car l’agent fonctionne en écrivant et en exécutant du Python sur votre machine. Ce guide explique les trois composants impliqués, suit pas à pas une question jusqu’à ce qu’elle se transforme en graphique, montre comment examiner le code écrit par l’agent, et énumère les mesures de précaution nécessaires avant de faire confiance à ses résultats.

Débutons par un point important : create_pandas_dataframe_agent fait partie du paquet expérimental de LangChain. Il convient parfaitement à la conception de prototypes et à l’exploration, mais il n’est pas conçu pour un usage en production sauf si vous y ajoutez une revue approfondie par des humains ainsi qu’un mécanisme d’isolation.

De la syntaxe à l’intention

Le flux de travail traditionnel exige que vous sachiez comment faire quelque chose avant de pouvoir apprendre quoi que ce soit : quelles méthodes de pandas regroupent les lignes, quelle fonction de matplotlib dessine un graphique en barres, comment étiqueter les axes. L’approche basée sur des agents inverse cette logique : vous décrivez ce que vous souhaitez savoir, et le modèle trouve comment le calculer et le présenter.

L’effet pratique est que davantage de personnes peuvent travailler directement avec les données. Un analyste commercial ou un expert du domaine qui comprend les questions mais pas la syntaxe peut trouver une réponse sans attendre quelqu’un connaissant les bibliothèques. L’attention se déplace de la manière d’écrire le code vers les questions qui ont réellement une importance pour une décision. Le compromis, abordé ci-dessous, est qu’il faut désormais vérifier du code que l’on n’a pas écrit soi-même.

Les trois composants à l’origine de l’agent

Une façon utile d’envisager le système est comme un moteur de raisonnement, un stockage structuré de données et un connecteur entre eux.

Le LLM en tant que moteur de raisonnement

Le modèle de langage interprète votre demande, écrit le code Python nécessaire pour y répondre et choisit un type de graphique adapté, par exemple un graphique en barres pour les comptages par catégorie. Son rôle est de relier le langage naturel à une logique exécutable, y compris déterminer ce que représentent réellement les données.

Le DataFrame en tant que stockage organisé de données

pandas conserve les données sous forme de tableau composé de lignes et de colonnes étiquetées. Prenons l’ensemble de données UCI sur la consommation d’alcool chez les étudiants comme exemple : des attributs tels que sex et age sont stockés en tant que colonnes, prêtes à être filtrées et agrégées. C’est cette structure cohérente qui permet à l’agent d’exécuter des opérations précises rapidement.

LangChain en tant que connecteur

create_pandas_dataframe_agent fournit le prompt prédéfini ainsi que les outils nécessaires pour permettre au modèle d’accéder au DataFrame. En réalité, l’agent reçoit un outil d’exécution en Python où votre DataFrame est disponible sous le nom de df, ainsi qu’un prompt indiquant au modèle comment l’utiliser. Vous n’avez pas besoin de mettre en place cette connexion vous-même.

Comment une question devient un graphique

Suivre une seule demande à travers le système permet de clarifier le rôle de chaque composant. Supposons que la question soit "Afficher le comptage des genres sous forme de barres."

1. La question arrive. Le modèle reçoit le texte et commence à interpréter ce qui est demandé.
2. Le modèle associe la demande aux données. Il reconnaît que "genre" correspond à la colonne sex et décide qu’un graphique en barres convient pour représenter un comptage par catégorie.

Les données sont consultées. Il n’y a pas de base de données séparée ; le DataFrame en mémoire constitue la source des données.

L’analyse est exécutée. Le modèle génère du code qui compte les valeurs M et F, en appliquant tout filtre nécessaire, puis le connecteur ce code.

Le résultat est interprété. Le modèle lit ces comptes et les insère dans le contexte de la population étudiante.

La réponse est présentée. Vous obtenez un graphique en barres montrant la distribution ainsi qu’un résumé en langage simple.

C’est aux étapes 2 et 4 que se produisent la plupart des erreurs. Une mauvaise correspondance entre les colonnes ou un filtre légèrement incorrect peuvent encore produire un graphique d’apparence propre, c’est précisément pourquoi la section suivante est importante.

Un regard à l’intérieur : étapes intermédiaires et code généré

Cela permet de séparer le code que vous exécutez du code que l’agent exécute. Vous pouvez appeler vous-même df.head() pour consulter les cinq premières lignes et comprendre les colonnes. En revanche, l’agent écrit son propre code pour répondre à chaque demande, et vous pouvez rendre ce code visible.

Lors de la création de l’agent avec create_pandas_dataframe_agent, passez return_intermediate_steps=True. Le résultat inclura alors chaque action entreprise par l’agent, ainsi que le code qu’il a exécuté et la sortie qu’il a observée. Cela permet de faire trois choses :

• Validation : vous pouvez confirmer que l’agent a calculé sa réponse plutôt que de deviner. Vous verrez des expressions réelles telles que len(df) pour compter les lignes ou df[df['age'] == 18] pour sélectionner les étudiants de 18 ans.

Débogage : en définissant verbose=True, les raisonnements de l’agent ainsi que le code généré sont affichés en console au fur et à mesure de son exécution, ce qui permet de repérer où la logique a échoué lorsque le résultat semble anormal.

Apprentissage : l’agent cesse d’être une boîte noire pour devenir une démonstration en temps réel de la manière dont pandas est utilisé pour manipuler les données.

Ces deux options se complètent. verbose=True est pratique lorsque l’on observe une exécution de manière interactive, tandis que return_intermediate_steps=True restitue les étapes sous forme de données, que l’on peut enregistrer, afficher dans un notebook ou vérifier automatiquement.

Sécurité : l’agent exécute le code qu’il écrit

Puisque l’agent exécute du Python généré par un modèle, une instruction malveillante ou simplement erronée peut lire des fichiers, effectuer des appels réseau ou supprimer des données en utilisant les mêmes privilèges que votre processus. Les versions récentes de langchain_experimental rendent cela explicite en refusant de créer l’agent à moins que vous n’indisiez allow_dangerous_code=True ; consultez la documentation actuelle correspondant à votre version. Ce paramètre constitue une reconnaissance du risque, et non une mesure d’atténuation.

Tenez également pour non fiables tous les données que vous n’avez pas créées. Une cellule contenant un texte, tel qu’une instruction destinée au modèle, peut influencer le code qu’il génère, ce qui représente une forme d’injection de prompt facile à négliger lorsque l’entrée est un tableau.

Une liste de contrôle pour une utilisation responsable

Faites participer quelqu’un à chaque projet et examinez ces points :

• Faites exécuter l’agent dans un environnement isolé, tel qu’un conteneur ou un environnement jetable sans identifiants et avec un accès limité aux fichiers et au réseau, afin que du code non intentionnel ou malveillant ne puisse causer de dommages.
• Rédigez des instructions claires et précises. En indiquant exactement les colonnes ainsi que le type d’agrégation souhaité, vous réduisez les risques que l’agent choisisse le mauvais champ ou en invente un.
• Vérifiez les résultats à l’aide de vos propres connaissances. Ne vous fiez jamais aveuglément à un graphique ; utilisez les étapes intermédiaires pour vous assurer que les bonnes colonnes, filtres et calculs ont été utilisés.
• Itérez. L’analyse est un dialogue. Si le premier graphique n’est pas tout à fait correct, utilisez les informations fournies par les étapes intermédiaires pour affiner votre prochaine demande.
• Travaillez sur une copie des données. Les opérations qui modifient directement le DataFrame peuvent changer silencieusement ce que verront les questions ultérieures.

Points clés

• Un agent pandas est composé de trois éléments : un LLM capable de raisonner et d’écrire du code, un DataFrame qui contient des données structurées, ainsi que la fonction create_pandas_dataframe_agent de LangChain qui les relie.
• La plupart des erreurs surviennent lorsque le modèle associe des mots à des colonnes ou écrit le code d’analyse, et il peut néanmoins générer des graphiques convaincants.
• Les paramètres return_intermediate_steps=True et verbose=True affichent le code généré, ce qui permet sa vérification et son débogage.
• Cet agent exécute du Python arbitraire, se trouve dans un paquet expérimental et nécessite un environnement isolé ainsi qu’une révision humaine avant d’être utilisé en production.
• L’agent assure la vitesse de traitement ; vous fournissez le contexte sectoriel et le jugement critique qui transforment ses résultats en conclusions précises.

Lectures complémentaires