Comment évaluer efficacement vos candidatures RAG + LLM

Salut! Vous êtes-vous déjà demandé à quel point certaines applications actuelles semblent presque magiquement intelligentes ? Une grande partie de cette magie vient de quelque chose appelé RAG et LLM. Considérez RAG (Retrieval-Augmented Generation) comme le rat de bibliothèque intelligent du monde de l'IA. Il fouille dans des tonnes d'informations pour trouver exactement ce qui est nécessaire à votre question. Ensuite, il y a le LLM (Large Language Model), comme la célèbre série GPT qui générera une réponse fluide basée sur ses impressionnantes capacités de génération de texte. Avec ces deux éléments réunis, vous obtenez une IA qui est non seulement intelligente, mais également extrêmement pertinente et contextuelle. C'est comme combiner un assistant de recherche ultra-rapide avec un interlocuteur plein d'esprit. Ce combo est fantastique pour tout, depuis vous aider à trouver rapidement des informations spécifiques jusqu'à avoir une conversation étonnamment réelle.

Mais voici le problème : comment savoir si notre IA est réellement utile et ne se contente pas de débiter un jargon fantaisiste ? C'est là que l'évaluation entre en jeu. C'est crucial, pas seulement un plaisir. Nous devons nous assurer que notre IA est non seulement précise, mais également pertinente, utile et qu’elle ne prend pas de directions étranges. Après tout, à quoi sert un assistant intelligent s’il ne peut pas comprendre ce dont vous avez besoin ou s’il vous donne des réponses qui sont loin de la réalité ?

L'évaluation de notre candidature RAG + LLM est comme une confrontation avec la réalité. Cela nous indique si nous sommes vraiment sur la bonne voie pour créer une IA réellement utile et pas seulement techniquement impressionnante. Donc, dans cet article, nous expliquons comment y parvenir – en veillant à ce que notre IA soit aussi géniale en pratique qu'en théorie !

Phase de développement

Lors de la phase de développement, il est essentiel de réfléchir à la manière d'un pipeline d'évaluation de modèle d'apprentissage automatique typique. Dans une configuration IA/ML standard, nous travaillons généralement avec plusieurs ensembles de données, tels que des ensembles de développement, de formation et de test, et utilisons des métriques quantitatives pour évaluer l'efficacité du modèle. Cependant, l’évaluation des grands modèles linguistiques (LLM) présente des défis uniques. Les mesures quantitatives traditionnelles ont du mal à capturer la qualité des résultats des LLM, car ces modèles excellent dans la génération d'un langage à la fois varié et créatif. Par conséquent, il est difficile de disposer d’un ensemble complet d’étiquettes pour une évaluation efficace.

Dans les cercles universitaires, les chercheurs peuvent utiliser des critères et des scores tels que MMLU pour classer les LLM, et des experts humains peuvent être sollicités pour évaluer la qualité des résultats du LLM. Toutefois, ces méthodes ne s'adaptent pas de manière transparente à l'environnement de production, où le rythme de développement est rapide et où les applications pratiques nécessitent des résultats immédiats. Il ne s'agit pas uniquement de performances LLM ; les exigences du monde réel prennent en compte l'ensemble du processus, qui comprend la récupération des données, la composition rapide et la contribution du LLM. Il n'est pas pratique de créer un benchmark organisé par l'homme pour chaque nouvelle itération du système ou lorsqu'il y a des changements dans les documents ou les domaines. De plus, le rythme rapide du développement dans l'industrie ne permet pas le luxe d'attendre longtemps que des testeurs humains évaluent chaque mise à jour avant son déploiement. Par conséquent, ajuster les stratégies d’évaluation qui fonctionnent dans le monde universitaire pour les aligner sur l’environnement de production rapide et axé sur les résultats présente un défi considérable.

Donc, si vous tombez dans ce cas, vous pouvez penser à quelque chose comme un pseudo-score fourni par un maître LLM. Ce score pourrait refléter une combinaison de mesures d’évaluation automatisées et une essence distillée de jugement humain. Une telle approche hybride vise à combler le fossé entre la compréhension nuancée des évaluateurs humains et l’analyse évolutive et systématique de l’évaluation automatique.

Par exemple, si votre équipe développe un LLM interne formé à votre domaine et à vos données spécifiques, le processus impliquera généralement un effort de collaboration de la part des développeurs, des ingénieurs rapides et des scientifiques des données. Chaque membre joue un rôle essentiel :

• Les développeurs sont les architectes. Ils construisent le cadre de l'application, garantissant que la chaîne RAG + LLM est parfaitement intégrée et peut naviguer sans effort à travers différents scénarios.

• Les ingénieurs Prompt sont les créatifs. Ils conçoivent des scénarios et des invites qui imitent les interactions des utilisateurs du monde réel. Ils réfléchissent aux « et si » et poussent le système à traiter un large éventail de sujets et de questions.

• Les Data Scientists sont les stratèges. Ils analysent les réponses, approfondissent les données et utilisent leur expertise statistique pour évaluer si les performances de l'IA sont à la hauteur.

  
  

La boucle de rétroaction ici est essentielle. Pendant que notre IA répond aux invites, l’équipe examine chaque sortie. L’IA a-t-elle compris la question ? La réponse était-elle exacte et pertinente ? Le langage pourrait-il être plus fluide ? Ces commentaires sont ensuite réinjectés dans le système pour des améliorations.

Pour aller plus loin, imaginez utiliser un LLM maître comme le GPT-4 d'OpenAI comme référence pour évaluer votre LLM auto-développé. Votre objectif est d'égaler, voire de surpasser, les performances de la série GPT, connue pour sa robustesse et sa polyvalence. Voici comment procéder :

• Générer un ensemble de données pertinent : commencez par créer un ensemble de données qui reflète les nuances de votre domaine. Cet ensemble de données peut être organisé par des experts ou synthétisé à l'aide de GPT-4 pour gagner du temps, garantissant ainsi qu'il correspond à votre référence.

• Définir des indicateurs de réussite : exploitez les atouts du master LLM pour vous aider à définir vos indicateurs. Vous avez la liberté de choisir les mesures qui correspondent le mieux à vos objectifs, étant donné que le master LLM peut gérer les tâches les plus complexes. Dans le standard de la communauté, vous souhaiterez peut-être voir certains travaux de Langchain et d'autres bibliothèques comme ragas . Ils ont des mesures telles que la fidélité, le rappel du contexte, la précision du contexte, la similarité des réponses, etc.

• Automatisation de votre pipeline d'évaluation : pour suivre le rythme des cycles de développement rapides, établissez un pipeline automatisé. Cela évaluera systématiquement les performances de l'application par rapport à vos métriques prédéfinies après chaque mise à jour ou modification. En automatisant le processus, vous garantissez que votre évaluation est non seulement approfondie mais également itérative de manière efficace, permettant une optimisation et un affinement rapides.

  
  

Par exemple, dans la démonstration suivante, je vais vous montrer comment évaluer automatiquement divers LLM open source sur une simple tâche de conversation de récupération de documents à l'aide du GPT-4 d'OpenAI.

Tout d'abord, nous utilisons OpenAI GPT-4 pour créer un ensemble de données synthétisées dérivé d'un document, comme indiqué ci-dessous :

 import os import json import pandas as pd from dataclasses import dataclass from langchain.chat_models import ChatOpenAI from langchain.chains import LLMChain from langchain.prompts import PromptTemplate from langchain.document_loaders import PyPDFLoader from langchain.text_splitter import CharacterTextSplitter from langchain.output_parsers import JsonOutputToolsParser, PydanticOutputParser from langchain.prompts import ChatPromptTemplate, HumanMessagePromptTemplate QA_DATASET_GENERATION_PROMPT = PromptTemplate.from_template( "You are an expert on generate question-and-answer dataset based on a given context. You are given a context. " "Your task is to generate a question and answer based on the context. The generated question should be able to" " to answer by leverage the given context. And the generated question-and-answer pair must be grammatically " "and semantically correct. Your response must be in a json format with 2 keys: question, answer. For example," "\n\n" "Context: France, in Western Europe, encompasses medieval cities, alpine villages and Mediterranean beaches. Paris, its capital, is famed for its fashion houses, classical art museums including the Louvre and monuments like the Eiffel Tower." "\n\n" "Response: {{" "\n" " \"question\": \"Where is France and what is it's capital?\"," "\n" " \"answer\": \"France is in Western Europe and it's capital is Paris.\"" "\n" "}}" "\n\n" "Context: The University of California, Berkeley is a public land-grant research university in Berkeley, California. Established in 1868 as the state's first land-grant university, it was the first campus of the University of California system and a founding member of the Association of American Universities." "\n\n" "Response: {{" "\n" " \"question\": \"When was the University of California, Berkeley established?\"," "\n" " \"answer\": \"The University of California, Berkeley was established in 1868.\"" "\n" "}}" "\n\n" "Now your task is to generate a question-and-answer dataset based on the following context:" "\n\n" "Context: {context}" "\n\n" "Response: ", ) OPENAI_API_KEY = os.getenv("OPENAI_API_KEY") if OPENAI_API_KEY is None: raise ValueError("OPENAI_API_KEY is not set") llm = ChatOpenAI( model="gpt-4-1106-preview", api_key=OPENAI_API_KEY, temperature=0.7, response_format={ "type": "json_object" }, ) chain = LLMChain( prompt=QA_DATASET_GENERATION_PROMPT, llm=llm ) file_loader = PyPDFLoader("./data/cidr_lakehouse.pdf") text_splitter = CharacterTextSplitter(chunk_size=1000) chunks = text_splitter.split_documents(file_loader.load()) questions, answers = [], [] for chunk in chunks: for _ in range(2): response = chain.invoke({ "context": chunk }) obj = json.loads(response["text"]) questions.append(obj["question"]) answers.append(obj["answer"]) df = pd.DataFrame({ "question": questions, "answer": answers }) df.to_csv("./data/cidr_lakehouse_qa.csv", index=False)

Après avoir exécuté le code mentionné ci-dessus, nous obtenons comme résultat un fichier CSV. Ce fichier contient des paires de questions et réponses relatives au document que nous saisissons, comme suit :

Ensuite, nous construisons des chaînes DocumentRetrievalQA simples à l'aide de Langchain et les remplaçons par plusieurs LLM open source qui fonctionnent localement via Ollama. Vous pouvez retrouver mon précédent tutoriel à ce sujet ici.

 from tqdm import tqdm from langchain.chains import RetrievalQA from langchain.chat_models import ChatOllama from langchain.vectorstores import FAISS from langchain.embeddings import HuggingFaceEmbeddings vector_store = FAISS.from_documents(chunks, HuggingFaceEmbeddings()) retriever = vector_store.as_retriever() def test_local_retrieval_qa(model: str): chain = RetrievalQA.from_llm( llm=ChatOllama(model=model), retriever=retriever, ) predictions = [] for it, row in tqdm(df.iterrows(), total=len(df)): resp = chain.invoke({ "query": row["question"] }) predictions.append(resp["result"]) df[f"{model}_result"] = predictions test_local_retrieval_qa("mistral") test_local_retrieval_qa("llama2") test_local_retrieval_qa("zephyr") test_local_retrieval_qa("orca-mini") test_local_retrieval_qa("phi") df.to_csv("./data/cidr_lakehouse_qa_retrieval_prediction.csv", index=False)

En résumé, le code ci-dessus établit une chaîne simple de récupération de documents. Nous exécutons cette chaîne en utilisant plusieurs modèles, tels que Mistral, Llama2, Zephyr, Orca-mini et Phi. En conséquence, nous ajoutons cinq colonnes supplémentaires à notre DataFrame existant pour stocker les résultats de prédiction de chaque modèle LLM.

Définissons maintenant une chaîne principale à l'aide du GPT-4 d'OpenAI pour évaluer les résultats de la prédiction. Dans cette configuration, nous calculerons un score d'exactitude similaire à un score F1 approximatif, comme cela est courant dans les problèmes traditionnels d'IA/ML. Pour ce faire, nous appliquerons des concepts parallèles tels que les vrais positifs (TP), les faux positifs (FP) et les faux négatifs (FN), définis comme suit :

• TP : Déclarations présentes à la fois dans la réponse et dans la vérité terrain.
• FP : Déclarations présentes dans la réponse mais non trouvées dans la vérité terrain.
• FN : Déclarations pertinentes trouvées dans la vérité terrain mais omises dans la réponse.

Avec ces définitions, nous pouvons calculer la précision, le rappel et le score F1 en utilisant les formules ci-dessous :

 import os import numpy as np import pandas as pd from tqdm import tqdm from langchain.chains import LLMChain from langchain.chat_models import ChatOpenAI from langchain.prompts import PromptTemplate OPENAI_API_KEY = os.getenv("OPENAI_API_KEY") if OPENAI_API_KEY is None: raise ValueError("OPENAI_API_KEY is not set") CORRECTNESS_PROMPT = PromptTemplate.from_template( """ Extract following from given question and ground truth. Your response must be in a json format with 3 keys and does not need to be in any specific order: - statements that are present in both the answer and the ground truth - statements present in the answer but not found in the ground truth - relevant statements found in the ground truth but omitted in the answer Please be concise and do not include any unnecessary information. You should classify the statements as claims, facts, or opinions with semantic matching, no need exact word-by-word matching. Question:What powers the sun and what is its primary function? Answer: The sun is powered by nuclear fission, similar to nuclear reactors on Earth, and its primary function is to provide light to the solar system. Ground truth: The sun is actually powered by nuclear fusion, not fission. In its core, hydrogen atoms fuse to form helium, releasing a tremendous amount of energy. This energy is what lights up the sun and provides heat and light, essential for life on Earth. The sun's light also plays a critical role in Earth's climate system and helps to drive the weather and ocean currents. Extracted statements: [ {{ "statements that are present in both the answer and the ground truth": ["The sun's primary function is to provide light"], "statements present in the answer but not found in the ground truth": ["The sun is powered by nuclear fission", "similar to nuclear reactors on Earth"], "relevant statements found in the ground truth but omitted in the answer": ["The sun is powered by nuclear fusion, not fission", "In its core, hydrogen atoms fuse to form helium, releasing a tremendous amount of energy", "This energy provides heat and light, essential for life on Earth", "The sun's light plays a critical role in Earth's climate system", "The sun helps to drive the weather and ocean currents"] }} ] Question: What is the boiling point of water? Answer: The boiling point of water is 100 degrees Celsius at sea level. Ground truth: The boiling point of water is 100 degrees Celsius (212 degrees Fahrenheit) at sea level, but it can change with altitude. Extracted statements: [ {{ "statements that are present in both the answer and the ground truth": ["The boiling point of water is 100 degrees Celsius at sea level"], "statements present in the answer but not found in the ground truth": [], "relevant statements found in the ground truth but omitted in the answer": ["The boiling point can change with altitude", "The boiling point of water is 212 degrees Fahrenheit at sea level"] }} ] Question: {question} Answer: {answer} Ground truth: {ground_truth} Extracted statements:""", ) judy_llm = ChatOpenAI( model="gpt-4-1106-preview", api_key=OPENAI_API_KEY, temperature=0.0, response_format={ "type": "json_object" }, ) judy_chain = LLMChain( prompt=CORRECTNESS_PROMPT, llm=judy_llm ) def evaluate_correctness(column_name: str): chain = LLMChain( prompt=CORRECTNESS_PROMPT, llm=ChatOpenAI( model="gpt-4-1106-preview", api_key=OPENAI_API_KEY, temperature=0.0, response_format={ "type": "json_object" }, ) ) key_map = { "TP": "statements that are present in both the answer and the ground truth", "FP": "statements present in the answer but not found in the ground truth", "FN": "relevant statements found in the ground truth but omitted in the answer", # noqa: E501 } TP, FP, FN = [], [], [] for it, row in tqdm(df.iterrows(), total=len(df)): resp = chain.invoke({ "question": row["question"], "answer": row[column_name], "ground_truth": row["answer"] }) obj = json.loads(resp["text"]) TP.append(len(obj[key_map["TP"]])) FP.append(len(obj[key_map["FP"]])) FN.append(len(obj[key_map["FN"]])) # convert to numpy array TP = np.array(TP) FP = np.array(FP) FN = np.array(FN) df[f"{column_name}_recall"] = TP / (TP + FN) df[f"{column_name}_precision"] = TP / (TP + FP) df[f"{column_name}_correctness"] = 2 * df[f"{column_name}_recall"] * df[f"{column_name}_precision"] / (df[f"{column_name}_recall"] + df[f"{column_name}_precision"]) evaluate_correctness("mistral_result") evaluate_correctness("llama2_result") evaluate_correctness("zephyr_result") evaluate_correctness("orca-mini_result") evaluate_correctness("phi_result") print("|====Model====|=== Recall ===|== Precision ==|== Correctness ==|") print(f"|mistral | {df['mistral_result_recall'].mean():.4f} | {df['mistral_result_precision'].mean():.4f} | {df['mistral_result_correctness'].mean():.4f} |") print(f"|llama2 | {df['llama2_result_recall'].mean():.4f} | {df['llama2_result_precision'].mean():.4f} | {df['llama2_result_correctness'].mean():.4f} |") print(f"|zephyr | {df['zephyr_result_recall'].mean():.4f} | {df['zephyr_result_precision'].mean():.4f} | {df['zephyr_result_correctness'].mean():.4f} |") print(f"|orca-mini | {df['orca-mini_result_recall'].mean():.4f} | {df['orca-mini_result_precision'].mean():.4f} | {df['orca-mini_result_correctness'].mean():.4f} |") print(f"|phi | {df['phi_result_recall'].mean():.4f} | {df['phi_result_precision'].mean():.4f} | {df['phi_result_correctness'].mean():.4f} |") print("|==============================================================|") df.to_csv("./data/cidr_lakehouse_qa_retrieval_prediction_correctness.csv", index=False) 

D'accord, nous avons maintenant un benchmark simple pour plusieurs modèles. Cela peut être considéré comme un indicateur préliminaire de la manière dont chaque modèle gère la tâche de récupération de documents. Même si ces chiffres offrent un aperçu, ils ne sont que le début de l'histoire. Ils servent de base pour comprendre quels modèles sont les plus efficaces pour récupérer des informations précises et pertinentes à partir d’un corpus donné. Vous pouvez trouver le code source ici .

Commentaires humains en boucle

Lorsqu'il s'agit de régler notre IA grâce au Human-In-Loop Feedback, la synergie entre les testeurs humains et le Master LLM est essentielle. Cette relation ne consiste pas simplement à recueillir des commentaires, mais à créer un système d’IA réactif qui s’adapte et apprend de l’apport humain.

Le processus interactif

• Contribution du testeur : les testeurs s'engagent dans la chaîne RAG + LLM et évaluent ses résultats d'un point de vue humain. Ils fournissent des commentaires sur des aspects tels que la pertinence, l'exactitude et le naturel des réponses de l'IA.
• Retour d'expérience au Master LLM : C'est ici que la magie opère. Les retours des testeurs humains sont communiqués directement au Master LLM. Contrairement aux modèles standards, le Master LLM est conçu pour comprendre et interpréter ces retours afin d'affiner ses résultats ultérieurs.
• Réglage de l'invite par le Master LLM : Armé de ces commentaires, le Master LLM ajuste l'invite pour notre LLM de développement. Ce processus est analogue à celui d'un mentor qui instruit un étudiant. Le Master LLM modifie soigneusement la façon dont le LLM de développement interprète et réagit aux invites, garantissant ainsi un mécanisme de réponse plus efficace et plus contextuel.

Le double rôle du Master LLM

Le Master LLM fonctionne à la fois comme une référence pour le LLM développé en interne et comme un participant actif dans la boucle de rétroaction. Il évalue les commentaires, ajuste les invites ou les paramètres du modèle et « apprend » essentiellement des interactions humaines.

L’avantage de l’adaptation en temps réel

Ce processus est transformateur. Il permet à l’IA de s’adapter en temps réel, la rendant plus agile et adaptée aux complexités du langage humain et des processus de pensée. Une telle adaptation en temps réel garantit que la courbe d'apprentissage de l'IA est abrupte et continue.

Le cycle d’amélioration

Grâce à ce cycle d’interaction, de feedback et d’adaptation, notre IA devient plus qu’un simple outil ; il devient une entité d'apprentissage, capable de s'améliorer à chaque interaction avec un testeur humain. Ce modèle humain dans la boucle garantit que notre IA ne stagne pas mais évolue pour devenir un assistant plus efficace et intuitif.

En résumé, Human-In-Loop Feedback ne consiste pas seulement à collecter des informations humaines : il s'agit également de créer une IA dynamique et adaptable capable d'affiner son comportement pour mieux servir les utilisateurs. Ce processus itératif garantit que nos applications RAG + LLM restent à la pointe, fournissant non seulement des réponses, mais aussi des réponses contextuelles et nuancées qui reflètent une véritable compréhension des besoins de l'utilisateur.

Pour une démonstration simple, vous pouvez regarder comment ClearML utilise ce concept pour améliorer Promptimizer dans cette vidéo .

Phase d'exploitation

Passer à la phase opérationnelle , c'est comme passer des répétitions générales à la soirée d'ouverture. Ici, nos applications RAG + LLM ne sont plus des entités hypothétiques ; ils deviennent des participants actifs dans les flux de travail quotidiens des vrais utilisateurs. Cette phase est le test décisif pour toute la préparation et la mise au point effectuées lors de la phase de développement.

Au cours de cette phase, nos équipes (opérations, produits et analystes) s'alignent pour déployer et gérer les applications, garantissant que tout ce que nous avons construit fonctionne non seulement mais prospère également dans un environnement réel. C'est ici que nous pouvons envisager de mettre en œuvre des stratégies de tests A/B pour mesurer l'efficacité de nos applications de manière contrôlée.

• Cadre de test A/B : nous divisons notre base d'utilisateurs en deux segments : le segment de contrôle, qui continue à utiliser la version établie de l'application (version 1), et le segment de test, qui teste les nouvelles fonctionnalités de la version 2 (en fait vous pouvez également exécuter plusieurs tests A/B en même temps). Cela nous permet de recueillir des données comparatives sur l'expérience utilisateur, la réceptivité des fonctionnalités et les performances globales.

• Déploiement opérationnel : l'équipe des opérations est chargée du déploiement en douceur des deux versions, en garantissant que l'infrastructure est robuste et que toutes les transitions de version sont transparentes pour l'utilisateur.

• Évolution du produit : l'équipe produit, à l'écoute des commentaires des utilisateurs, s'efforce d'itérer le produit. Cette équipe s'assure que les nouvelles fonctionnalités correspondent aux besoins des utilisateurs et à la vision globale du produit.

• Informations analytiques : l'équipe d'analystes examine rigoureusement les données collectées à partir du test A/B. Leurs idées sont essentielles pour déterminer si la nouvelle version surpasse l'ancienne et si elle est prête pour une version plus large.

• Mesures de performance : des indicateurs de performance clés (KPI) sont surveillés pour mesurer le succès de chaque version. Il s'agit notamment des mesures d'engagement des utilisateurs, des scores de satisfaction et de l'exactitude des résultats de l'application.

  
  

La phase d'exploitation est dynamique, informée par des boucles de rétroaction continues qui non seulement améliorent les applications, mais renforcent également l'engagement et la satisfaction des utilisateurs. C'est une phase caractérisée par la surveillance, l'analyse, l'itération et surtout l'apprentissage à partir de données en direct.

Alors que nous traversons cette phase, notre objectif est non seulement de maintenir les normes élevées fixées par la phase de développement, mais aussi de les dépasser, en garantissant que notre application RAG + LLM reste à la pointe de l'innovation et de la convivialité.

Conclusion

En résumé, l'intégration de la génération augmentée par récupération (RAG) et des modèles linguistiques étendus (LLM) marque une avancée significative dans l'IA, alliant récupération de données approfondie et génération de texte sophistiquée. Cependant, nous avons besoin d’une méthode d’évaluation appropriée et efficace et d’une stratégie de développement itérative. La phase de développement met l'accent sur la personnalisation de l'évaluation de l'IA et son amélioration grâce au retour d'informations de l'humain, garantissant que ces systèmes sont empathiques et adaptables aux scénarios du monde réel. Cette approche met en évidence l’évolution de l’IA d’un simple outil à un partenaire collaboratif. La phase opérationnelle teste ces applications dans des scénarios réels, en utilisant des stratégies telles que les tests A/B et des boucles de rétroaction continues pour garantir l'efficacité et l'évolution continue en fonction de l'interaction des utilisateurs.