Skip to main content
La génération augmentée par récupération (RAG) est une méthode courante pour créer des applications d’IA générative ayant accès à des bases de connaissances personnalisées. Illustration Evals

Ce que vous apprendrez :

Ce guide vous montre comment :
  • Créer une base de connaissances
  • Créer une application RAG avec une étape de récupération qui identifie les documents pertinents
  • Suivre les étapes de récupération avec Weave
  • Évaluer des applications RAG à l’aide d’un juge LLM pour mesurer la précision du contexte
  • Définir des fonctions de score personnalisées

Prérequis

  • Un compte W&B
  • Python 3.8+ ou Node.js 18+
  • Packages requis :
    • Python: pip install weave openai
    • TypeScript: npm install weave openai
  • Une clé API OpenAI configurée comme variable d’environnement

Créer une base de connaissances

Commencez par calculer les embeddings des articles. En général, vous ne le faites qu’une seule fois pour vos articles, puis vous stockez les embeddings et les métadonnées dans une base de données. Mais ici, par souci de simplicité, cette opération est effectuée à chaque exécution du script.

Créer une application RAG

Ensuite, encapsulez la fonction de récupération get_most_relevant_document avec le décorateur weave.op(), puis créez une classe Model. Appelez weave.init('<team-name>/rag-quickstart') pour commencer à suivre toutes les entrées et sorties de vos fonctions afin de pouvoir les inspecter plus tard. Si vous ne spécifiez pas de nom de Team, la sortie est enregistrée dans votre Team ou entité W&B par défaut.

Évaluer avec un juge LLM

Lorsqu’il n’existe pas de moyen simple d’évaluer votre application, une approche consiste à utiliser un LLM pour en évaluer certains aspects. Voici un exemple d’utilisation d’un juge LLM pour essayer de mesurer la précision du contexte, en lui demandant de vérifier si le contexte a été utile pour parvenir à la réponse fournie. Ce prompt a été adapté à partir du framework RAGAS.

Définir une fonction de score

Comme dans le tutoriel Créer un pipeline d’Évaluation, définissez un ensemble de lignes d’exemple pour tester votre application, ainsi qu’une fonction de score. La fonction de score prend une ligne et l’évalue. Les arguments d’entrée doivent correspondre aux clés de votre ligne ; ici, question provient donc du dictionnaire de la ligne. output est la sortie du modèle. L’entrée du modèle est récupérée depuis l’exemple en fonction de son argument d’entrée ; ici aussi, il s’agit de question. Cet exemple utilise des fonctions async pour s’exécuter rapidement en parallèle. Si vous avez besoin d’une brève introduction à l’async, vous pouvez en trouver une ici.

Facultatif : définir une classe Scorer

Dans certaines applications, vous pouvez vouloir créer des classes d’évaluation personnalisées — par exemple lorsqu’il faut créer une classe LLMJudge standardisée avec des paramètres spécifiques (p. ex. modèle de chat, prompt), une logique de score propre à chaque ligne et un calcul spécifique du score agrégé. Weave propose une liste de classes Scorer prêtes à l’emploi et permet aussi de créer facilement un Scorer personnalisé. L’exemple suivant montre comment créer une class CorrectnessLLMJudge(Scorer) personnalisée. Dans les grandes lignes, les étapes pour créer un Scorer personnalisé sont assez simples :
  1. Définissez une classe personnalisée qui hérite de weave.flow.scorer.Scorer
  2. Redéfinissez la fonction score et ajoutez @weave.op() si vous voulez suivre chaque appel de la fonction
    • cette fonction doit définir un argument output dans lequel la prédiction du modèle sera transmise. Définissez-le avec le type Optional[dict] au cas où le modèle renverrait "None".
    • les autres arguments peuvent être de type Any ou dict, ou correspondre à des colonnes spécifiques du jeu de données utilisé pour évaluer le modèle avec la classe weave.Evaluate — ils doivent avoir exactement les mêmes noms que les noms de colonnes ou les clés d’une ligne après son passage à preprocess_model_input, si celle-ci est utilisée.
  3. Facultatif : Redéfinissez la fonction summarize pour personnaliser le calcul du score agrégé. Par défaut, Weave utilise la fonction weave.flow.scorer.auto_summarize si vous ne définissez pas de fonction personnalisée.
    • cette fonction doit avoir un décorateur @weave.op().
Pour l’utiliser comme scorer, vous devez l’initialiser et le passer à l’argument scorers dans votre `Evaluation comme ceci :

Récapitulons

Pour obtenir le même résultat avec vos applications RAG :
  • Encapsulez les appels LLM et les fonctions d’étape de récupération avec weave.op()
  • (facultatif) Créez une sous-classe Model avec une fonction predict et les détails de votre application
  • Rassemblez des exemples pour l’évaluation
  • Créez des fonctions de score qui évaluent un exemple
  • Utilisez la classe Evaluation pour exécuter des évaluations sur vos exemples
REMARQUE : Il arrive que l’exécution asynchrone des évaluations atteigne la limite de débit des modèles d’OpenAI, Anthropic, etc. Pour l’éviter, vous pouvez définir une variable d’environnement afin de limiter le nombre de workers parallèles, par exemple WEAVE_PARALLELISM=3. Voici le code dans son intégralité.

Conclusion

Ce tutoriel vous a montré comment intégrer l’observabilité à différentes étapes de vos applications, comme l’étape de récupération dans cet exemple. Vous avez également appris à créer des fonctions de score plus complexes, comme un juge LLM, pour évaluer automatiquement les réponses de l’application.

Prochaines étapes

Consultez le cours RAG++ pour approfondir les techniques pratiques de RAG destinées aux ingénieurs. Vous y découvrirez des solutions prêtes pour la Production proposées par Weights & Biases, Cohere et Weaviate afin d’optimiser les performances, de réduire les coûts et d’améliorer la précision et la pertinence de vos applications.