Bewertung der Halluzination des Sprachmodells mit GraphEval

# Einführung

Halluzinationen sind eines der bekanntesten Probleme große Sprachmodelle (LLMs) kann beim Generieren von Antworten auftreten. Sie treten auf, wenn ein Modell eine Antwort liefert, die sachlich falsch, unsinnig oder einfach erfunden ist, typischerweise aufgrund mangelnder interner Kenntnisse des Modells zu diesem Thema.

Während in den letzten Jahren viele Lösungen zur Bewältigung des Issues von Modellhalluzinationen entstanden sind, wurden methodische Bewertungsrahmen für die interne Diagnose dieser Halluzinationen vergleichsweise wenig untersucht. Eins aktuelle Studie von Amazon-Forschern schlägt die Verwendung von Wissensgraphen als Mittel zur Analyse und Erkennung von Halluzinationen vor, die bei LLMs auftreten. Der in der Studie vorgestellte Rahmen wird benannt GraphEval.

In diesem Artikel verfolgen wir einen sanften, praktischen Ansatz, um die konzeptionellen Bausteine ​​von GraphEval anhand eines simulationsbasierten, leichten Codebeispiels zu veranschaulichen, das Sie problemlos auf Ihrem Laptop ausprobieren können.

# GraphEval auf den Punkt gebracht

GraphEval nutzt Wissensgraphen, um Halluzinationen in LLM-generierten Ausgaben zu identifizieren und zu signalisieren. Im Gegensatz zu klassischen Leistungsmetriken, die Einzelwerte zur Bewertung von Aspekten wie Genauigkeit, Sicherheit usw. bereitstellen, wendet GraphEval einen zweistufigen Bewertungsprozess an, bei dem die Erklärbarkeit im Vordergrund steht, nämlich Erkenntnisse darüber, wo genau die Halluzination stattgefunden hat.

Zu diesem Zweck berücksichtigt GraphEval zwei Phasen:

• Erstellen eines Wissensgraphen aus der generierten Modellantwort. Der Graph besteht aus semantischen Tripeln der Type (Subjekt, Beziehung, Objekt)wobei Subjekte und Objekte Knoten entsprechen und Beziehungen den Kanten entsprechen, die diese Knoten verbinden.
• Bewertung jedes Tripels im erstellten Wissensgraphen anhand eines Quellkontexts (eines Grundwahrheitswissens) mithilfe eines NLI-Modells (Pure Language Inference). Jedes Tripel, das gemäß der NLI-Engine nicht durch den Kontext impliziert werden kann – weil es widersprüchlich oder impartial ist – wird als Halluzination gekennzeichnet.

# Veranschaulichung von GraphEval anhand eines Codebeispiels

Bevor wir mit dem Code beginnen, der die Anwendung des GraphEval-Frameworks simuliert, stellen wir sicher, dass die erforderlichen Bibliotheken installiert sind:

!pip set up -q transformers networkx matplotlib torch

Der Zweck des Codebeispiels, das wir gleich durchgehen, besteht darin, die Funktionsweise der GraphEval-Methodik zu entmystifizieren. Daher werden wir die Phasen, die in einer realen Umgebung einen hohen Rechenaufwand erfordern würden, durch simulierte, einfache Alternativen ersetzen.

Dementsprechend simulieren wir eine fundierte Wissensbasis (Kontext), von der angenommen wird, dass sie sachliche Informationen enthält. In einer Produktionsumgebung würde dieses fundierte Wissen beispielsweise aus dem Abrufen relevanter Dokumente aus dem stammen Vektordatenbank eines Retrieval-Augmented Technology (RAG)-Methods. Der Einfachheit halber erstellen wir hier direkt einen Floor-Fact-Kontext und speichern ihn darin source_context.

# The bottom-truth context offered to the LLM
source_context = (
    "GraphEval is a hallucination analysis framework primarily based on representing data "
    "in Information Graph (KG) buildings. It acts as a pre-processing step and makes use of "
    "out-of-the-box NLI fashions to detect factual inconsistencies."
)

Nehmen wir nun an, das Folgende sei die ursprüngliche LLM-Antwort auf eine Benutzeraufforderung wie „Erklären Sie kurz und bündig, was GraphEval ist“. Um die erste Part des Bewertungsprozesses einzuleiten, würden wir einen Hilfs-LLM bitten, den Wissensgraphen aus dieser Antwort zu erstellen. Sowohl die Antwort als auch die Folgeaufforderung, die zum Erhalten des Wissensdiagramms verwendet wurde, sind unten dargestellt:

# The generated response we wish to consider (accommodates a hallucination)
llm_output = (
    "GraphEval is an analysis framework that makes use of Information Graphs. "
    "It requires a extremely costly, enterprise-level server farm to function."
)

# Immediate template that may theoretically be handed to an area/free LLM (e.g. Mistral-7B)
KG_EXTRACTION_PROMPT = f"""
You might be an knowledgeable data extractor. Extract the core data from the next textual content as a Information Graph.
Return the output strictly as a Python checklist of tuples within the format: (Topic, Relationship, Object).

Textual content: {llm_output}
"""

Der Einfachheit halber und um die ansonsten hohe Rechenlast beim lokalen Ausführen eines umfangreichen LLM zu umgehen, nehmen wir noch einmal an, dass die folgenden Diagrammtripel erhalten werden:

# Simulated extraction to bypass the heavy computational load of working a large LLM domestically
extracted_triples = (
    ("GraphEval", "is", "analysis framework"),
    ("GraphEval", "makes use of", "Information Graphs"),
    ("GraphEval", "requires", "costly enterprise server farm")
)

print("Extracted Triples:")
for t in extracted_triples:
    print

Extracted Triples:
('GraphEval', 'is', 'analysis framework')
('GraphEval', 'makes use of', 'Information Graphs')
('GraphEval', 'requires', 'costly enterprise server farm')

from transformers import pipeline

# Loading the open-source NLI mannequin
print("Loading DeBERTa NLI mannequin...")
nli_evaluator = pipeline("text-classification", mannequin="cross-encoder/nli-deberta-v3-small")

def evaluate_triple(context, triple):
    topic, relation, obj = triple
    speculation = f"{topic} {relation} {obj}"

    # Checking if the context entails the speculation
    end result = nli_evaluator({"textual content": context, "text_pair": speculation})

    # NLI fashions usually output: 'entailment', 'impartial', or 'contradiction'
    label = end result('label').decrease()

    # In GraphEval, something aside from 'entailment' is flagged as a hallucination
    is_hallucinated = label != 'entailment'

    return is_hallucinated, label, speculation

# Working the analysis pipeline
evaluation_results = ()

print("n--- GraphEval Outcomes ---")
for t in extracted_triples:
    is_hallucinated, nli_label, speculation = evaluate_triple(source_context, t)
    evaluation_results.append((is_hallucinated, nli_label))

    standing = "🚨 HALLUCINATION" if is_hallucinated else "✅ GROUNDED"
    print(f"{standing} | Triple: {t} | NLI Output: {nli_label}")

--- GraphEval Outcomes ---
✅ GROUNDED | Triple: ('GraphEval', 'is', 'analysis framework') | NLI Output: entailment
✅ GROUNDED | Triple: ('GraphEval', 'makes use of', 'Information Graphs') | NLI Output: entailment
🚨 HALLUCINATION | Triple: ('GraphEval', 'requires', 'costly enterprise server farm') | NLI Output: impartial

import networkx as nx
import matplotlib.pyplot as plt
import matplotlib.patches as mpatches

def visualize_grapheval(triples, eval_results):
    G = nx.DiGraph()
    edge_colors = ()

    for (triple, res) in zip(triples, eval_results):
        sub, rel, obj = triple
        is_hallucinated = res(0)

        G.add_node(sub)
        G.add_node(obj)
        G.add_edge(sub, obj, label=rel)

        # Coloration-code the perimeters primarily based on the NLI analysis
        edge_colors.append('pink' if is_hallucinated else 'inexperienced')

    # Arrange the plot
    plt.determine(figsize=(10, 6))
    pos = nx.spring_layout(G, seed=42)

    # Draw nodes
    nx.draw_networkx_nodes(G, pos, node_color="lightblue", node_size=2500)
    nx.draw_networkx_labels(G, pos, font_size=10, font_weight="daring")

    # Draw edges and labels
    nx.draw_networkx_edges(G, pos, edge_color=edge_colors, width=2.5, arrowsize=20)
    edge_labels = nx.get_edge_attributes(G, 'label')
    nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_color="black")

    # Add legend
    green_patch = mpatches.Patch(shade="inexperienced", label="Grounded (Entailment)")
    red_patch = mpatches.Patch(shade="pink", label="Hallucination (Impartial/Contradiction)")
    plt.legend(handles=(green_patch, red_patch), loc="decrease proper")

    plt.title("GraphEval Hallucination Map", fontsize=14, fontweight="daring")
    plt.axis('off')
    plt.tight_layout()
    plt.present()

# Render the data graph
visualize_grapheval(extracted_triples, evaluation_results)