Comment mesurer la fiabilité de la réponse d'un modèle grand

Le principe de base des grands modèles de langage (LLMS) est très simple: prédire le mot (ou jeton) suivant dans une séquence de mots basés sur des modèles statistiques dans leurs données de formation. Cependant, cette capacité apparemment simple s'avère incroyablement sophistiquée lorsqu'elle peut effectuer un certain nombre de tâches incroyables telles que le résumé de texte, la génération d'idées, le brainstorming, la génération de code, le traitement de l'information et la création de contenu. Cela dit, les LLM n'ont pas de mémoire non «ne comprennent» rien, à part s'en tenir à leur fonction de base: prédire le mot suivant .

Le processus de prédiction des mots suivants est probabiliste. Le LLM doit sélectionner chaque mot dans une distribution de probabilité. Dans le processus, ils génèrent souvent un contenu faux, fabriqué ou incohérent dans le but de produire des réponses cohérentes et de combler les lacunes avec des informations à l'aspect plausible mais incorrectes. Ce phénomène est appelé hallucination, une caractéristique inévitable et bien connue des LLM qui justifie la validation et la corroboration de leurs résultats.

Les méthodes de génération d'augmentation (RAG) de récupération, qui font travailler un LLM avec des sources de connaissances externes, minimisent les hallucinations dans une certaine mesure, mais elles ne peuvent pas les éradiquer complètement. Bien que les chiffons avancés puissent fournir des citations et des URL dans le texte, la vérification de ces références pourrait être mouvementée et longue. Par conséquent, nous avons besoin d'un critère objectif pour évaluer la fiabilité ou la fiabilité de la réponse d'un LLM, qu'elle soit générée à partir de ses propres connaissances ou d'une base de connaissances externe (RAG).

Dans cet article, nous discuterons de la façon dont la sortie d'un LLM peut être évaluée pour la fiabilité par un modèle de langage digne de confiance qui attribue un score à la sortie du LLM. Nous allons d'abord discuter de la façon dont nous pouvons utiliser un modèle de langue digne de confiance pour attribuer des scores à la réponse d'un LLM et expliquer la fiabilité. Par la suite, nous développerons un exemple de chiffon avec Llamaparse et Llamaindex qui évalue les réponses du chiffon pour la fiabilité.

L'ensemble du code de cet article est disponible dans le cahier Jupyter sur GitHub.

attribuer un score de fiabilité à la réponse d'un LLM

Pour démontrer comment nous pouvons attribuer un score de fiabilité à la réponse d'un LLM, j'utiliserai le modèle de langage fiable de CleanLab (TLM). Ces TLM utilisent une combinaison de Quantification de l'incertitude et Analyse de cohérence pour calculer les scores de fiabilité et les explications pour les réponses LLM.

CleanLab propose des API d'essai gratuites qui peuvent être obtenues en créant un compte sur leur site Web. Nous devons d'abord installer le client Python de CleanLab:

pip install --upgrade cleanlab-studio

CleanLab prend en charge plusieurs modèles propriétaires tels que ' gpt-4o ', ' gpt-4o-mini ', ' o1-preview ', ' Claude-3-Sonnet ',' Claude-3.5-Sonnet ', ‘ Claude-3.5-Sonnet-V2 ’ et autres. Voici comment TLM attribue un score de confiance à la réponse de GPT-4O. Le score de fiabilité varie de 0 à 1, où des valeurs plus élevées indiquent une plus grande fiabilité.

from cleanlab_studio import Studio
studio = Studio("<CLEANLAB_API_KEY>")  # Get your API key from above
tlm = studio.TLM(options={"log": ["explanation"], "model": "gpt-4o"}) # GPT, Claude, etc
#set the prompt
out = tlm.prompt("How many vowels are there in the word 'Abracadabra'.?")
#the TLM response contains the actual output 'response', trustworthiness score and explanation
print(f"Model's response = {out['response']}")
print(f"Trustworthiness score = {out['trustworthiness_score']}")
print(f"Explanation = {out['log']['explanation']}")

Le code ci-dessus a testé la réponse de GPT-4O pour la question « Combien de voyelles y a-t-il dans le mot« abracadabra ».? ». La sortie du TLM contient la réponse (réponse) du modèle, le score de fiabilité et l'explication. Voici la sortie de ce code.

Model's response = The word "Abracadabra" contains 6 vowels. The vowels are: A, a, a, a, a, and a.
Trustworthiness score = 0.6842228802750124
Explanation = This response is untrustworthy due to a lack of consistency in possible responses from the model. Here's one inconsistent alternate response that the model considered (which may not be accurate either):
5.

On peut voir comment le modèle de langue le plus avancé hallucine pour des tâches aussi simples et produit la mauvaise sortie. Il y a le score de réponse et de fiabilité pour la même question pour Claude-3.5-Sonnet-V2 .

Model's response = Let me count the vowels in 'Abracadabra':
A-b-r-a-c-a-d-a-b-r-a

The vowels are: A, a, a, a, a

There are 5 vowels in the word 'Abracadabra'.
Trustworthiness score = 0.9378276048845285
Explanation = Did not find a reason to doubt trustworthiness.

Claude-3.5-Sonnet-V2 produit la sortie correcte. Comparons les réponses des deux modèles à une autre question.

from cleanlab_studio import Studio
import markdown
from IPython.core.display import display, Markdown

# Initialize the Cleanlab Studio with API key
studio = Studio("<CLEANLAB_API_KEY>")  # Replace with your actual API key

# List of models to evaluate
models = ["gpt-4o", "claude-3.5-sonnet-v2"]

# Define the prompt
prompt_text = "Which one of 9.11 and 9.9 is bigger?"

# Loop through each model and evaluate
for model in models:
   tlm = studio.TLM(options={"log": ["explanation"], "model": model})
   out = tlm.prompt(prompt_text)
  
   md_content = f"""
## Model: {model}

**Response:** {out['response']}

**Trustworthiness Score:** {out['trustworthiness_score']}

**Explanation:** {out['log']['explanation']}

---
"""
   display(Markdown(md_content))

Voici la réponse des deux modèles:

Nous pouvons également générer un score de fiabilité pour les LLM open source. Vérifions la récente LLM open-source très médiatisée: Deepseek-R1. J'utiliserai Deepseek-R1-Distill-Llama-70b , basé sur le modèle de Meta LLAMA-3.3–70B-Instruct et distillé à partir du plus grand mélange de paramètres de 671 milliards d'experts de Deepseek (MOE (MOE (MOE (MOE (MOE de Deepseek ) modèle. La distillation des connaissances est une technique d'apprentissage automatique qui vise à transférer les apprentissages d'un grand modèle pré-formé, le «modèle d'enseignant», à un «modèle étudiant» plus petit.

import streamlit as st
from langchain_groq.chat_models import ChatGroq
import os
os.environ["GROQ_API_KEY"]=st.secrets["GROQ_API_KEY"]
# Initialize the Groq Llama Instant model
groq_llm = ChatGroq(model="deepseek-r1-distill-llama-70b", temperature=0.5)
prompt = "Which one of 9.11 and 9.9 is bigger?"
# Get the response from the model
response = groq_llm.invoke(prompt)
#Initialize Cleanlab's studio
studio = Studio("226eeab91e944b23bd817a46dbe3c8ae") 
cleanlab_tlm = studio.TLM(options={"log": ["explanation"]})  #for explanations
#Get the output containing trustworthiness score and explanation
output = cleanlab_tlm.get_trustworthiness_score(prompt, response=response.content.strip())
md_content = f"""
## Model: {model}
**Response:** {response.content.strip()}
**Trustworthiness Score:** {output['trustworthiness_score']}
**Explanation:** {output['log']['explanation']}
---
"""
display(Markdown(md_content))

Voici la sortie de Deepseek-R1-Distill-Llama-70b Modèle.

Développer un chiffon de confiance

Nous allons maintenant développer un chiffon pour démontrer comment nous pouvons mesurer la fiabilité d'une réponse LLM en chiffon. Ce chiffon sera développé en grattant les données à partir de liens donnés, en les analysant au format Markdown et en créant un magasin vectoriel.

Les bibliothèques suivantes doivent être installées pour le code suivant.

pip install llama-parse llama-index-core llama-index-embeddings-huggingface 
llama-index-llms-cleanlab requests beautifulsoup4 pdfkit nest-asyncio

pour rendre HTML au format PDF, nous devons également installer wkhtmltopdf outil de ligne de commande de leur site Web.

Les bibliothèques suivantes seront importées:

from llama_parse import LlamaParse
from llama_index.core import VectorStoreIndex
import requests
from bs4 import BeautifulSoup
import pdfkit
from llama_index.readers.docling import DoclingReader
from llama_index.core import Settings
from llama_index.embeddings.huggingface import HuggingFaceEmbedding
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.llms.cleanlab import CleanlabTLM
from typing import Dict, List, ClassVar
from llama_index.core.instrumentation.events import BaseEvent
from llama_index.core.instrumentation.event_handlers import BaseEventHandler
from llama_index.core.instrumentation import get_dispatcher
from llama_index.core.instrumentation.events.llm import LLMCompletionEndEvent
import nest_asyncio
import os

Les prochaines étapes impliqueront de gratter les données des URL données à l'aide de la bibliothèque BeautifulSoup de Python, d'enregistrer les données grattées dans les fichiers PDF en utilisant pdfkit , et analysant les données de PDF ( s) à un fichier de basse Cas d'utilisation LLM.

Nous allons d'abord configurer le LLM à utiliser par CleanLabTLM et le modèle d'intégration ( HuggingFace Modèle d'intégration BAAI / BGE-SMALL-EN-V1.5 ) qui sera utilisé Pour calculer les intérêts des données grattées pour créer le magasin vectoriel.

pip install --upgrade cleanlab-studio

Nous allons désormais définir un gestionnaire d'événements personnalisé, GetTrustWorthinessScore , qui est dérivé d'une classe de gestionnaire d'événements de base. Ce gestionnaire est déclenché à la fin d'une réalisation de LLM et extrait un score de fiabilité des métadonnées de réponse. Une fonction d'assistance, display_response , affiche la réponse du LLM avec son score de fiabilité.

from cleanlab_studio import Studio
studio = Studio("<CLEANLAB_API_KEY>")  # Get your API key from above
tlm = studio.TLM(options={"log": ["explanation"], "model": "gpt-4o"}) # GPT, Claude, etc
#set the prompt
out = tlm.prompt("How many vowels are there in the word 'Abracadabra'.?")
#the TLM response contains the actual output 'response', trustworthiness score and explanation
print(f"Model's response = {out['response']}")
print(f"Trustworthiness score = {out['trustworthiness_score']}")
print(f"Explanation = {out['log']['explanation']}")

Nous allons maintenant générer des PDF en grattant les données des URL données. Pour la démonstration, nous ferons en train de supprimer les données uniquement à partir de cet article Wikipedia sur les modèles de grands langues ( Creative Commons Attribution-ShareAlike 4.0 Licence ).

Remarque : Il est conseillé aux lecteurs de toujours revérifier l'état du contenu / données qu'ils sont sur le point de gratter et de s'assurer qu'ils sont autorisés à le faire.

Le morceau de code suivant éraforait les données des URL données en faisant une demande HTTP et en utilisant BeautifulSoup Python Library pour analyser le contenu HTML. La teneur en HTML est nettoyée en convertissant les URL relatives au protocole à celles absolues. Par la suite, le contenu gratté est converti en fichiers PDF en utilisant pdfkit .

Model's response = The word "Abracadabra" contains 6 vowels. The vowels are: A, a, a, a, a, and a.
Trustworthiness score = 0.6842228802750124
Explanation = This response is untrustworthy due to a lack of consistency in possible responses from the model. Here's one inconsistent alternate response that the model considered (which may not be accurate either):
5.

Après avoir généré des PDF (s) à partir des données grattées, nous analysons ces PDF en utilisant llamaparse . Nous définissons les instructions d'analyse pour extraire le contenu au format Markdown et analysons le ou les documents en termes de page avec le nom et le numéro de page du document. Ces entités extraites (pages) sont appelées nœuds . L'analyseur itère sur les nœuds extraits et met à jour les métadonnées de chaque nœud en ajoutant un en-tête de citation qui facilite la référence ultérieure.

Model's response = Let me count the vowels in 'Abracadabra':
A-b-r-a-c-a-d-a-b-r-a

The vowels are: A, a, a, a, a

There are 5 vowels in the word 'Abracadabra'.
Trustworthiness score = 0.9378276048845285
Explanation = Did not find a reason to doubt trustworthiness.

Nous créons maintenant un magasin vectoriel et un moteur de requête. Nous définissons un modèle d'invite client pour guider le comportement du LLM en répondant aux questions. Enfin, nous créons un moteur de requête avec l'index créé pour répondre aux requêtes. Pour chaque requête, nous récupérons les 3 meilleurs nœuds du magasin vectoriel en fonction de leur similitude sémantique avec la requête. Le LLM utilise ces nœuds récupérés pour générer la réponse finale.

from cleanlab_studio import Studio
import markdown
from IPython.core.display import display, Markdown

# Initialize the Cleanlab Studio with API key
studio = Studio("<CLEANLAB_API_KEY>")  # Replace with your actual API key

# List of models to evaluate
models = ["gpt-4o", "claude-3.5-sonnet-v2"]

# Define the prompt
prompt_text = "Which one of 9.11 and 9.9 is bigger?"

# Loop through each model and evaluate
for model in models:
   tlm = studio.TLM(options={"log": ["explanation"], "model": model})
   out = tlm.prompt(prompt_text)
  
   md_content = f"""
## Model: {model}

**Response:** {out['response']}

**Trustworthiness Score:** {out['trustworthiness_score']}

**Explanation:** {out['log']['explanation']}

---
"""
   display(Markdown(md_content))

Testons maintenant le chiffon pour certaines requêtes et leurs scores de fiabilité correspondants.

import streamlit as st
from langchain_groq.chat_models import ChatGroq
import os
os.environ["GROQ_API_KEY"]=st.secrets["GROQ_API_KEY"]
# Initialize the Groq Llama Instant model
groq_llm = ChatGroq(model="deepseek-r1-distill-llama-70b", temperature=0.5)
prompt = "Which one of 9.11 and 9.9 is bigger?"
# Get the response from the model
response = groq_llm.invoke(prompt)
#Initialize Cleanlab's studio
studio = Studio("226eeab91e944b23bd817a46dbe3c8ae") 
cleanlab_tlm = studio.TLM(options={"log": ["explanation"]})  #for explanations
#Get the output containing trustworthiness score and explanation
output = cleanlab_tlm.get_trustworthiness_score(prompt, response=response.content.strip())
md_content = f"""
## Model: {model}
**Response:** {response.content.strip()}
**Trustworthiness Score:** {output['trustworthiness_score']}
**Explanation:** {output['log']['explanation']}
---
"""
display(Markdown(md_content))

pip install llama-parse llama-index-core llama-index-embeddings-huggingface 
llama-index-llms-cleanlab requests beautifulsoup4 pdfkit nest-asyncio

attribuer un score de fiabilité à la réponse de LLM, qu'il soit généré par une inférence directe ou un chiffon, aide à définir la fiabilité de la sortie de l'IA et à hiérarchiser la vérification humaine si nécessaire. Ceci est particulièrement important pour les domaines critiques où une réponse erronée ou peu fiable pourrait avoir des conséquences graves.

C'est tout le monde! Si vous aimez l'article, suivez-moi sur médium et linkedin .

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!