So messen Sie die Zuverlässigkeit der Reaktion eines Großsprachenmodells

Das Grundprinzip von großsprachigen Modellen (LLMs) ist sehr einfach: das nächste Wort (oder Token) in einer Abfolge von Wörtern vorherzusagen, die auf statistischen Mustern in ihren Trainingsdaten basieren. Diese scheinbar einfache Fähigkeit erweist sich jedoch als unglaublich anspruchsvoll, wenn sie eine Reihe erstaunlicher Aufgaben wie die Zusammenfassung der Text, die Ideengenerierung, das Brainstorming, die Codegenerierung, die Informationsverarbeitung und die Erstellung von Inhalten erledigen kann. Trotzdem haben LLMs keine Erinnerung. Der Prozess der Vorhersage des nächsten Wortes ist wahrscheinlich. Das LLM muss jedes Wort aus einer Wahrscheinlichkeitsverteilung auswählen. Dabei erzeugen sie häufig falsche, hergestellte oder inkonsistente Inhalte, um kohärente Antworten zu erzeugen und Lücken mit plausiblen, aber falschen Informationen zu füllen. Dieses Phänomen wird als Halluzination bezeichnet, ein unvermeidliches, bekanntes Merkmal von LLMs, das die Validierung und Bestätigung ihrer Ausgaben rechtfertigt.

Methoden (Abrufer Augment Generation), bei denen ein LLM mit externen Wissensquellen funktioniert, minimieren Halluzinationen in gewissem Maße, aber sie können sie jedoch nicht vollständig ausrotten. Obwohl fortgeschrittene Lappen In-Text-Zitate und URLs bereitstellen können, kann es hektisch und zeitaufwändig sein, diese Referenzen zu überprüfen. Daher benötigen wir ein objektives Kriterium für die Bewertung der Zuverlässigkeit oder Vertrauenswürdigkeit der Antwort eines LLM, unabhängig davon

In diesem Artikel werden wir diskutieren, wie die Ausgabe eines LLM durch ein vertrauenswürdiges Sprachmodell auf Vertrauenswürdigkeit bewertet werden kann, das der Ausgabe des LLM eine Punktzahl zuweist. Wir werden zunächst diskutieren, wie wir ein vertrauenswürdiges Sprachmodell verwenden können, um der Antwort eines LLM zuweisen und Vertrauenswürdigkeit zu erklären. Anschließend werden wir ein Beispiel mit Lamaparse und Llamaindex entwickeln, der die Antworten des Rags auf Vertrauenswürdigkeit bewertet.

Der gesamte Code dieses Artikels ist im Jupyter -Notizbuch auf GitHub verfügbar.

Zuweisen einer Vertrauenswürdigkeit der Antwort eines LLM

Um zu demonstrieren, wie wir der Antwort eines LLM eine Vertrauenswürdigkeitszahl zuweisen können, werde ich das vertrauenswürdige Sprachmodell (TLM) von CleanLab verwenden. Solche TLMs verwenden eine Kombination aus Unsicherheit Quantifizierung und

Konsistenzanalyse

, um Vertrauenswürdigkeit und Erklärungen für LLM -Antworten zu berechnen. CleanLab bietet kostenlose Test -APIs an, die durch Erstellen eines Kontos auf ihrer Website erhalten werden können. Wir müssen zuerst den Python -Client von CleanLab installieren:

pip install --upgrade cleanlab-studio

CleanLab unterstützt mehrere proprietäre Modelle wie ' gpt-4o ', ' gpt-4o-mini ', o1-preview ', ', o1-preview ', ', o1-preview ',

',

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']}")

o1-preview

', ' o1 🎜> claude-3-sonnet

','

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.

claude-3.5-sonnet

', " claude-3,5-sonnet-v2 " und andere. Hier ist, wie TLM der Antwort von GPT-4o eine Trustworhess-Punktzahl zuweist. Der Score der Vertrauenswürdigkeit reicht von 0 bis 1, wo höhere Werte auf größere Vertrauenswürdigkeit hinweisen.

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.

Der obige Code testete die Antwort von GPT-4O auf die Frage " Wie viele Vokale befinden sich in dem Wort" Abracadabra ". ". Die Ausgabe des TLM enthält die Antwort des Modells (Antwort), Vertrauenswürdigkeit und Erklärung. Hier ist die Ausgabe dieses Codes.

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))

Es ist zu sehen, wie das fortschrittlichste Sprachmodell für so einfache Aufgaben halluziniert und die falsche Ausgabe erzeugt. Hier ist die Antwort und Vertrauenswürdigkeit für dieselbe Frage für

Claude-3,5-SONNET-V2 .

Claude-3,5-sonnet-V2 erzeugt die richtige Ausgabe. Vergleichen wir die Antworten der beiden Modelle mit einer anderen Frage.

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))

Hier ist die Antwort der beiden Modelle:

Wir können auch eine Vertrauenswürdigkeit für Open-Source-LLMs generieren. Schauen wir uns die jüngsten, vielbezogenen Open-Source-LLM an: Deepseek-R1. Ich werde Deepseek-r1-Distill-Llama-70b

verwenden, basierend auf der Metas llama-3,3–70b-in-strukturiert und aus Deepseeks größerer 671-Milliarden-Parametermischung von Experten (MOE (MOE ) Modell. Wissensdestillation ist eine Technik für maschinelles Lernen, die darauf abzielt, die Erkenntnisse eines großen vorgebildeten Modells, des „Lehrermodells“, auf ein kleineres „Schülermodell“ zu übertragen.

Hier ist die Ausgabe von

Deepseek-r1-Distill-Llama-70b

Modell.

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

entwickeln einen vertrauenswürdigen Lappen

Wir werden nun einen Lappen entwickeln, um zu demonstrieren, wie wir die Vertrauenswürdigkeit einer LLM -Antwort in Lappen messen können. Dieser Lappen wird entwickelt, indem Daten aus angegebenen Links abkratzen, sie im Markdown -Format analysiert werden und einen Vektorspeicher erstellen.

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

Die folgenden Bibliotheken müssen für den nächsten Code installiert werden. Um HTML in das PDF -Format umzusetzen, müssen wir auch wkhtmltopdf Befehlszeilen -Tool von ihrer Website installieren.

Die folgenden Bibliotheken werden importiert: In den nächsten Schritten werden Daten aus angegebenen URLs mithilfe von Pythons BeautifulSoup Bibliothek abgeschrieben, die abgekratzten Daten in PDF -Datei (en) mit pdfkit gespeichert und die Daten von PDF (PDF (analysieren s) zur Markierung der Datei mithilfe llamaparse , einer mit LLMs erstellten Dokument-Parsing-Plattform und für für LLM -Anwendungsfälle.

Wir werden zuerst die LLM konfigurieren, die von CleanLabtLM und dem Einbettungsmodell verwendet werden soll ( Suggingface Einbettungsmodell baai/bge-small-v1.5 ), der verwendet wird Berechnen Sie die Einbettungen der abgekratzten Daten, um den Vektorspeicher zu erstellen.

pip install --upgrade cleanlab-studio

Wir werden nun einen benutzerdefinierten Ereignishandler definieren, GetTrustworthinessScore , der von einer Basis -Event -Handlerklasse abgeleitet wird. Dieser Handler wird bis zum Ende einer LLM -Fertigstellung ausgelöst und extrahiert eine Vertrauenswürdigkeit aus den Reaktionsmetadaten. Eine Helferfunktion, display_response , zeigt die Reaktion des LLM zusammen mit seiner Vertrauenswürdigkeit an.

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']}")

Wir werden nun PDFs generieren, indem wir Daten aus angegebenen URLs abkratzen. Zur Demonstration werden wir Daten nur aus diesem Wikipedia-Artikel über große Sprachmodelle ( Creative Commons Attribution-Sharealike 4.0 Lizenz ) verschrotten.

Hinweis : Es wird den Lesern empfohlen, den Status des Inhalts/die Daten, die sie kurz vorstellen möchten, immer zu überprüfen und sicherzustellen, dass sie dies tun dürfen.

Das folgende Codelement erkrankt Daten aus den angegebenen URLs, indem sie eine HTTP -Anforderung erstellt und BeautifulSoup Python -Bibliothek verwendet, um den HTML -Inhalt zu analysieren. Der HTML-Gehalt wird durch Umwandlung von Protokoll-relativen URLs in absolute Einsen gereinigt. Anschließend wird der abgekratzte Inhalt mit pdfkit

in eine PDF -Datei konvertiert.

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.

Nachdem wir PDF (s) aus den abgekratzten Daten generiert haben, analysieren wir diese PDFs mit llamaparse . Wir setzen die Anweisungen für Parsen fest, um den Inhalt im Markdown-Format zu extrahieren und die Seiten (en) zusammen mit dem Dokumentnamen und der Seitennummer analysieren. Diese extrahierten Einheiten (Seiten) werden als Knoten

bezeichnet. Der Parser iteriert über die extrahierten Knoten und aktualisiert die Metadaten jedes Knotens, indem ein Zitierkopf angemeldet wird, der später verweist.

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.

Wir erstellen jetzt einen Vektor Store und eine Abfragemotor. Wir definieren eine Kundenumforderungsvorlage, um das Verhalten der LLM bei der Beantwortung der Fragen zu leiten. Schließlich erstellen wir eine Abfrage -Engine mit dem erstellten Index, um Abfragen zu beantworten. Für jede Abfrage holen wir die Top 3 Knoten aus dem Vektor Store basierend auf ihrer semantischen Ähnlichkeit mit der Abfrage. Das LLM verwendet diese abgerufenen Knoten, um die endgültige Antwort zu erzeugen.

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))

Lassen Sie uns nun den Lappen auf einige Fragen und ihre entsprechenden Vertrauenswürdigkeitswerte testen.

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

Zuweisen einer Vertrauenswürdigkeit der Reaktion von LLM, unabhängig davon, ob er durch direkte Inferenz oder RAG erzeugt wird, die Zuverlässigkeit der Ausgabe von AI und die Priorisierung der menschlichen Überprüfung bei Bedarf. Dies ist besonders wichtig für kritische Bereiche, in denen eine falsche oder unzuverlässige Reaktion schwerwiegende Konsequenzen haben kann.

Das sind alles Leute! Wenn Sie den Artikel mögen, folgen Sie mir bitte unter mittel und linkedIn .

Das obige ist der detaillierte Inhalt vonSo messen Sie die Zuverlässigkeit der Reaktion eines Großsprachenmodells. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!