Une introduction au débogage et aux tests de LLMS à Langsmith

J'ai récemment trouvé une plate-forme AI qui génère automatiquement des flashcards à partir de tout type de support. Comme j'aime mémoriser des concepts avec une répétition espacée, j'ai immédiatement téléchargé mon tutoriel xgboost et demandé à l'AI de créer 50 cartes flash dessus.

mais j'ai été déçu. La plupart des questions étaient trop faciles et très peu d'entre elles concernaient la syntaxe du code. Encore plus étrangement, 10% des questions étaient identiques et totalement hors contexte - «Quelle est la capitale de la France?».

Ces types d'erreurs suggèrent un manque d'évaluation et de validation appropriées des résultats produits par les services d'IA. Peut-être qu'ils ne connaissaient pas Langsmith.

Langsmith est une plate-forme à part entière pour tester, déboguer et évaluer les applications LLM. Peut-être que sa caractéristique la plus importante est l'évaluation de la sortie LLM et la surveillance des performances. Dans ce tutoriel, nous verrons le cadre en action et apprendrons des techniques pour l'appliquer dans vos propres projets.

Commençons!

Pourquoi langsmith?

Comme je l'ai mentionné ci-dessus, Langsmith est une plate-forme complète pour évaluer les grandes applications linguistiques. Voici quelques-unes de ses fonctionnalités et des avantages réels tangibles qu'ils apportent:

Configuration rapide

Les programmeurs peuvent commencer à expérimenter avec Langsmith en minutes, pas des heures. Cela signifie qu'une petite équipe ou un développeur en solo peut prototyper une application d'IA pendant un week-end et potentiellement expédier un service payant d'ici lundi.

Assurance qualité

Avec des outils d'évaluation rigoureux, les entreprises peuvent éviter l'embarras et le coût des versions défectueuses d'IA (comme l'exemple que j'ai donné dans l'introduction). Langsmith vous permet de vérifier la sortie des LLM par rapport aux critères intégrés tels que l'utilité, la cohérence, la misogynie ou même les évaluations personnalisées en langage naturel comme «le contenu du cliché de sortie?» Ou, dans le cas de la génération de cartes flash, «La carte contient-elle une question de codage?».

Surveillance et visualisation en temps réel

Langsmith utilise des traces pour enregistrer presque tous les aspects des exécutions LLM. Il s'agit notamment de mesures telles que la latence, le nombre de jetons, le prix des courses et tous les types de métadonnées. L'interface utilisateur Web vous permet de filtrer rapidement les exécutions en fonction du pourcentage d'erreur, de la latence, de la date ou même par contenu texte en utilisant le langage naturel. Cela signifie que si, par exemple, un tuteur AI commence à pénétrer ses réponses aux étudiants réels, vous pouvez pousser une correction en quelques heures.

Intégration avec Langchain

Langchain est le cadre parent de Langsmith axé spécifiquement sur la phase de développement des LLM. Il offre une conception de logiciels modulaire pour chaîner plusieurs LLM (agents) et les intégrer à d'autres API telles que YouTube, Google Search, etc. Langsmith est la cerise sur le dessus, garantissant que les prototypes construits avec Langchain fonctionnent comme prévu en utilisant ses puissants outils d'évaluation et de surveillance.

Consultez nos applications LLM avec le tutoriel Langchain pour en savoir plus sur Langchain.

ensembles de données

Une autre grande fonctionnalité de Langsmith est les ensembles de données. Ils peuvent être utilisés pour améliorer les chaînes, les agents ou les modèles de Langchain contre un ensemble d'exemples standardisés avant le déploiement. Par exemple, nous pouvons avoir un fichier CSV contenant deux colonnes - questions et réponses pour les cartes flashs dans un format spécifique.

En convertissant ce fichier en un ensemble de données de référence, nous pouvons demander aux LLMS d'évaluer leur propre sortie en utilisant les mesures d'assurance qualité mentionnées précédemment.

Nous verrons maintenant toutes ces fonctionnalités à travers des exemples un par un.

LLM Flow de développement d'applications de l'application

Dans le développement des applications ML, vous collectez des données, des données, des amendements, des tests et des modèles de déploiement - les étapes sont bien définies. Avec les applications LLM, cependant, vous commencez souvent par un modèle prêt à l'emploi d'un fournisseur. Réglage fin? Cela peut être cher. Donc, vous vous concentrerez beaucoup sur la fabrication des bonnes invites - il s'agit de poser à votre application LLM les bonnes questions. Considérez-le comme ayant besoin de nombreuses invites pour tester les choses, tout comme vous avez besoin de beaucoup de données pour un bon modèle ML.

Cependant, avec des invites, vous avez affaire aux textes qui entrent et sortent, pas des nombres. Ainsi, les moyens habituels de mesurer les erreurs ou la précision, comme MSE ou Cross-Entropy, ne fonctionnent pas ici. De plus, imaginez lire chaque entrée et sortie pour l'évaluation - cela prendrait des jours si vous avez des milliers d'invites à évaluer.

Ainsi, vous avez besoin d'un flux de travail qui consiste à créer et à tester efficacement ces invites pour voir à quel point votre application LLM se produit, sans se noyer dans des vérifications manuelles. Voici à quoi cela pourrait ressembler:

1. Développer

À ce stade, vous prototyperez le fondement de votre application à l'aide de frameworks comme Langchain. Pour un projet de générateur FlashCard, votre prototype peut inclure plusieurs composants au-dessus de votre LLM que vous avez choisi d'un fournisseur. Par exemple, vous devrez peut-être le enchaîner à:

• Retrievers: API des moteurs de recherche, grabyers Web
• chargeurs de documents: entrées de fichier - PDF, texte, CSV, JSON, presse-papiers, youtube, recherche, etc.
• Charteurs de chat
• Magasins vectoriels
• Modèles d'intégration
• rappel

et ainsi de suite (voir quel type de composants vous pouvez ajouter à partir de cette page de documents Langchain). Mais vous pouvez réduire considérablement votre temps de développement en utilisant des chaînes standard offertes par Langchain pour les tâches courantes de haut niveau.

2. Productionize

À ce stade, vous testerez votre application contre autant de scénarios que possible. Cela signifie que vous devez vous assurer que chaque composant ajouté fonctionne bien, la chaîne bien ensemble et produire des sorties cohérentes et de haute qualité.

Étant donné que les LLM sont non déterministes (ils ne génèrent pas la même sortie pour la même entrée) et la complexité des composants ajoutés, vous passerez la plupart de votre temps à ce stade. Et Langsmith a été développé dans le seul but de rendre ce temps aussi court que possible. Nous en discuterons davantage tout au long du tutoriel.

3. Déploier

Une fois que vous avez une application viable, vous pouvez le déployer en tant qu'API REST. Une API REST convertit essentiellement vos chaînes ou agents Langchain existants en liens HTTPS, d'autres peuvent envoyer des demandes pour interagir avec votre modèle d'IA. Maintenant, vous allez créer l'interface utilisateur de votre service comme une application de bureau ou, plus souvent, un site Web.

En ce moment, il n'y a pas de moyen facile de le faire, mais les développeurs de Langchain sont sur le point de publier Langserve, qui seront intégrés dans Fastapi (à quel point cela serait-il génial?). Consultez le sneak pic à partir de cette page de la documentation.

Maintenant, commençons enfin à bricoler avec Langsmith.

Présentation de la plate-forme Langsmith

Nous commencerons par comprendre l'interface utilisateur Web. Il est disponible via le lien Smith.langchain.com. Pour l'accès, vous devez vous inscrire et être effacé de la liste d'attente, car il est actuellement en bêta fermé.

Mais une fois que vous êtes, la page de destination ressemblera à ceci:

Les deux sections principales sont les projets et les ensembles de données et les tests, et les deux sections peuvent être manipulées via Python SDK. La plate-forme a également des onglets pour le déploiement et les files d'attente d'annotation, mais ils dépassent le cadre de cet article.

Configuration de Langsmith Python Sdk

La gestion des projets dans Langsmith est beaucoup plus facile avec son SDK Python, qui est connecté à la plate-forme via une clé API.

Pour obtenir une clé, cliquez sur l'icône de clé de la plate-forme et enregistrez-la dans un endroit sûr. Ensuite, dans un nouveau répertoire avec un nouvel environnement virtuel initialisé, créez un fichier .env. À l'intérieur, collez les deux lignes suivantes:

LANGCHAIN_API_KEY="LangSmith-API-key"
OPENAI_API_KEY="Your-OPENAI-key"

Ensuite, dans votre terminal, exécutez les commandes suivantes pour installer Langsmith et Python-Dotenv pour lire les variables d'environnement:

python-dotenv to read environment variables:
pip install -U langsmith
pip install python-dotenv

Maintenant, il est temps d'écrire du code:

import warnings

from dotenv import find_dotenv, load_dotenv

warnings.filterwarnings("ignore")

Nous importons les fonctions find_dotenv et load_dotenv pour lire les variables d'environnement et les configurons avec OS:

import os

load_dotenv(find_dotenv())
os.environ["LANGCHAIN_API_KEY"] = str(os.getenv("LANGCHAIN_API_KEY"))
os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_ENDPOINT"] = "https://api.smith.langchain.com"

Définition de Langchain_Tracing_V2 vers True permet le traçage (journalisation), ce qui est essentiel pour déboguer les LLM. Ensuite, nous initialisons un client pour parler à la plate-forme Langsmith:

from langsmith import Client

# Initialize a client
client = Client()

Le client contient des commandes de haut niveau pour manipuler des projets et des actifs dans Langsmith. La première commande du client que nous utiliserons consiste à créer un nouveau projet:

import uuid

# Create id
uid = uuid.uuid4()
# Create a unique name
PROJECT_NAME = "flashcards-generator-" + str(uid)
# Create the project
session = client.create_project(
   project_name=PROJECT_NAME,
   description="A project that generates flashcards from user input",
)

Une fois la création_project avec succès, vous pouvez voir le projet répertorié dans la section Projets de l'interface utilisateur Web:

Ensuite, nous devons définir le nouveau projet par défaut avec une autre variable d'environnement:

os.environ["LANGCHAIN_PROJECT"] = PROJECT_NAME

Maintenant, nous avons besoin d'un LLM pour notre projet. Nous irons avec GPT-3.5 Turbo car il est moins cher, mais vous pouvez utiliser de nombreux autres modèles disponibles via Langchain. Les modèles OpenAI sont initialisés via la classe Chatopenai.

from langchain.chat_models import ChatOpenAI

llm = ChatOpenAI()  # Uses gpt-3.5-turbo by default

faisons notre première course:

LANGCHAIN_API_KEY="LangSmith-API-key"
OPENAI_API_KEY="Your-OPENAI-key"

Si vous vérifiez rapidement le projet à partir de l'interface utilisateur, vous verrez l'exécution ci-dessus tracée (enregistrée):

Lorsque nous configurons les variables d'environnement et le client, nous avons automatiquement activé la journalisation. Comme vous pouvez le voir, nous avons déjà un tas de métadonnées sur la course.

exécutons quelques autres invites:

python-dotenv to read environment variables:
pip install -U langsmith
pip install python-dotenv

Nous pouvons déjà créer un résumé de texte de base. Résumons la sortie de la dernière exécution:

import warnings

from dotenv import find_dotenv, load_dotenv

warnings.filterwarnings("ignore")

génial, il est maintenant temps de créer notre premier ensemble de données.

Création d'un ensemble de données non marqué dans Langsmith

Comme je l'ai mentionné dans la section «LLM Application Development Workflow», vous devrez probablement créer ou collecter des milliers d'invites pour évaluer votre modèle, chaîne ou agent LLM. Donc, gérer ces un par un comme nous l'avons fait ci-dessus n'est pas la meilleure pratique.

Pour cette raison, Langsmith propose des ensembles de données en trois types:

• Key-Value (KV) - Par défaut: définit les entrées comme des paires de valeurs de clé arbitraires. Ils sont utiles lors de l'évaluation des chaînes et des agents qui nécessitent plusieurs entrées ou renvoient plusieurs sorties.
• LLM DataSets (LLM): les entrées et les sorties sont définies dans "Style d'achèvement" par LLMS - String in, String Out.
• ensemble de données de chat (CHAT): Ce sont des ensembles de données convertis à partir de chats LLM et définis à l'aide d'entrées structurées et de messages sérialisés.

Tout d'abord, voyons comment créer un ensemble de données de valeur clé sans sorties. Nous utiliserons la fonction create_dataset du client:

import os

load_dotenv(find_dotenv())
os.environ["LANGCHAIN_API_KEY"] = str(os.getenv("LANGCHAIN_API_KEY"))
os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_ENDPOINT"] = "https://api.smith.langchain.com"

Maintenant, ajoutons trois entrées qui demandent à la LLM de créer une seule carte flash:

from langsmith import Client

# Initialize a client
client = Client()

Si vous passez en revue l'onglet d'ensemble de données de l'interface utilisateur, vous verrez chaque invite répertoriée avec une sortie nul:

Maintenant, exécutons toutes les invites dans une seule ligne de code à l'aide de RUN_ON_DATASET Fonction:

import uuid

# Create id
uid = uuid.uuid4()
# Create a unique name
PROJECT_NAME = "flashcards-generator-" + str(uid)
# Create the project
session = client.create_project(
   project_name=PROJECT_NAME,
   description="A project that generates flashcards from user input",
)

Une fois l'exécution terminée, elle sera répertoriée sur la page de jeu de données. Voici à quoi il ressemble:

Nous venons de faire un test exécuté sur un ensemble de données non marqué - un ensemble de données avec des invites d'exemple mais pas d'exemple de sorties. Notre test a simplement produit une réponse à chaque invite mais n'a rien évalué. Mais nous aimerions effectuer des chèques de base tels que "la sortie est-elle utile?" ou «La réponse est-elle courte ou longue»?

Langsmith nous permet d'effectuer de telles vérifications à l'aide d'évaluateurs intégrés.

Évaluation des LLM dans Langsmith

Pour exécuter une concision et des évaluations de cohérence en utilisant les trois invites que nous avons dans notre ensemble de données, nous pouvons utiliser la classe RuneValConfig:

LANGCHAIN_API_KEY="LangSmith-API-key"
OPENAI_API_KEY="Your-OPENAI-key"

ci-dessus, nous définissons deux critères dans une liste appelée évaluateurs. Nous transmettons ces évaluateurs au paramètre d'évaluation de la fonction RUN_ON_DATASET:

python-dotenv to read environment variables:
pip install -U langsmith
pip install python-dotenv

run_on_dataset est une fonction utile pour exécuter toutes les invites dans un ensemble de données à l'aide du LLM fourni et effectuer tout type d'évaluation à la volée. Ses résultats seront visibles sur la page dédiée de chaque ensemble de données:

Cette fois, la course a des mesures de cohérence et de concision pour chaque invite. En bas, vous verrez également un score moyen pour chaque métrique.

Pour voir la liste de tous les critères intégrés, exécutez l'extrait ci-dessous:

import warnings

from dotenv import find_dotenv, load_dotenv

warnings.filterwarnings("ignore")

Écriture d'évaluateurs personnalisés dans Langsmith pour les ensembles de données non marqués

Bien sûr, tous les cas d'utilisation de LLM ne peuvent pas être vérifiés avec des évaluateurs de base. Par exemple, il n'y a pas d'évaluateur pour vérifier si une carte flash contient une question de codage ou non. Donc, nous ferons mieux de le définir:

import os

load_dotenv(find_dotenv())
os.environ["LANGCHAIN_API_KEY"] = str(os.getenv("LANGCHAIN_API_KEY"))
os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_ENDPOINT"] = "https://api.smith.langchain.com"

pour passer un critère personnalisé avec un langage naturel, nous passons simplement {"critères_name": "Condition pour vérifier"} à la classe des critères. Ci-dessus, nous créons deux évaluateurs supplémentaires, donc Langsmith exécutera deux invites supplémentaires en plus de la sortie produite par les invites de notre ensemble de données:

from langsmith import Client

# Initialize a client
client = Client()

Si vous consultez l'exécution, vous verrez les critères personnalisés que nous avons définis sous chaque invite. Si vous planez, vous obtiendrez le raisonnement du LLM après:

En vérifiant les résultats de l'évaluation pour toutes les invites, vous verrez que nos critères n'évaluent pas comme prévu. Donc, voici quelque chose à considérer - vous devez également prompter à ingérer vos critères pour vous assurer qu'ils vérifient les bonnes choses.

Création d'ensembles de données étiquetés

Parfois, vous pouvez décider de créer un ensemble de données d'invites avec des sorties attendues, par exemple, des ensembles de données étiquetés. Vous pouvez créer des ensembles de données étiquetés dans divers formats, mais peut-être le plus courant est un fichier CSV. Par exemple, voici un fichier que j'ai généré avec Chatgpt qui contient cinq questions sur la syntaxe Pytorch:

Pour créer un ensemble de données à partir de cela, nous pouvons utiliser la fonction upload_csv:

import uuid

# Create id
uid = uuid.uuid4()
# Create a unique name
PROJECT_NAME = "flashcards-generator-" + str(uid)
# Create the project
session = client.create_project(
   project_name=PROJECT_NAME,
   description="A project that generates flashcards from user input",
)

La fonction a trois paramètres requis: chemin CSV et noms des colonnes d'entrée / sortie. Une fois le téléchargement terminé, l'ensemble de données apparaîtra dans l'interface utilisateur:

Exécutons également notre critère personnalisé à partir de la section précédente de cet ensemble de données:

os.environ["LANGCHAIN_PROJECT"] = PROJECT_NAME

Si vous accédez à la page de l'ensemble de données et consultez l'exécution, nous pouvons voir les scores moyens pour chaque critère personnalisé:

Évaluation des ensembles de données étiquetés

Les évaluateurs intégrés et personnalisés écrits en langage naturel sont principalement destinés aux ensembles de données non marqués. Pour les ensembles de données étiquetés comme l'ensemble de données CSV que nous avons téléchargé, Langsmith propose des évaluateurs plus complets pour mesurer l'exactitude de la réponse à une invite:

• context_qa (Q&A contextuel): utilise l'exemple de sortie comme contexte tout en évaluant l'exactitude
• QA (Q&A): Informe LLM de noter directement une réponse comme "correcte" ou "incorrect" en utilisant la sortie de référence
• COT_QA (Q&A de la chaîne de pensées): Similaire à Context_QA, mais cet évaluateur oblige le LLM à utiliser le raisonnement de la chaîne de réflexion avant d'obtenir un verdict.

essayons le dernier de nos exemples:

LANGCHAIN_API_KEY="LangSmith-API-key"
OPENAI_API_KEY="Your-OPENAI-key"

Le critère COTQA renvoie un score appelé précision contextuelle, comme illustré dans le GIF ci-dessous (également dans l'interface utilisateur):

Veuillez visiter la section des évaluateurs de Langchain de Langsmith Docs pour en savoir plus sur les évaluateurs.

Conclusion

Si vous avez l'impression après avoir lu ce tutoriel que Langsmith est vraiment un outil complexe pour l'ingénierie rapide, vous auriez raison! À l'heure actuelle, Langsmith est le meilleur cadre pour s'assurer que les instructions et les sorties de LLM sont en fait ce que vous voulez.

Vous devez également avoir réalisé l'effort nécessaire pour créer des applications LLM de qualité de production. Alors, utilisez Langsmith pour une expérience plus fluide tout en travaillant sur des projets LLM.

Si certains des concepts de Langsmith n'avaient pas de sens, vous manquez peut-être de certains fondamentaux à Langchain. Voici quelques ressources à ce sujet:

• Intro à Langchain pour l'ingénierie des données
• Construire des chatbots conscients du contexte à Langchain
• Ingénierie rapide dans Langchain
• Comment créer des applications LLM avec Langchain
• Langchain Docs
• Langsmith Docs

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!