Bewertung – chatgpz.de – KI-Tools & Praxiswissen

Bewertung der Halluzination des Sprachmodells mit GraphEval

admin — Fri, 24 Jul 2026 14:04:27 +0000

[ad_1]

# 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


 
Ausgabe:

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

Wir haben absichtlich ein Tripel hinzugefügt, das im Grunde eine Halluzination ist (es ist überhaupt keine Serverfarm eines Unternehmens erforderlich!), damit wir zeigen können, wie der anschließende NLI-Prozess, der auf den Wissensgraphen angewendet wird, es offenbart.
Genug simulierte Schritte für heute. Kommen wir zur eigentlichen Aktion der nächsten Stufe: dem NLI-Prozess. Der nächste Codeabschnitt ist von grundlegender Bedeutung für die Nutzung der Ideen hinter GraphEval. Es verwendet ein vorab trainiertes NLI-Modell von Umarmendes Gesicht  – Das Modell ist öffentlich verfügbar, sodass zum Herunterladen kein Zugriffstoken erforderlich ist – um jedes Triple mit dem Floor-Fact-Kontext zu vergleichen. Wenn das NLI-Modell für ein bestimmtes Tripel keine Konsequenz „vorhersagt“, wird es als Halluzination bezeichnet.

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

Ausgabe:

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

Wie erwartet wird das letzte Tripel im Wissensgraphen als Halluzination erkannt.
Zum Abschluss können wir neben den Erkennungsergebnissen auch den Wissensgraphen der ursprünglichen LLM-Antwort anzeigen:

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)

Resultierende Visualisierung:
 
# Schlussbemerkungen
GraphEval ist eine Bewertungsmethode, die dazu beitragen soll, die Grundursache von Halluzinationen in LLM-Ausgaben zu erkennen und zu lokalisieren. In diesem Artikel wurden die wichtigsten Prinzipien und methodischen Phasen in ein simuliertes praktisches Szenario umgewandelt, um seinen Nutzen und seine wichtigsten Auswirkungen auf eine mögliche Implementierung in Produktionssystemen besser zu verstehen.
Iván Palomares Carrascosa  ist ein führender Autor, Redner und Berater in den Bereichen KI, maschinelles Lernen, Deep Studying und LLMs. Er schult und leitet andere darin, KI in der realen Welt zu nutzen.


[ad_2]



Perplexity AI veröffentlicht WANDR: einen offenen Benchmark zur Bewertung von Forschungsagenten, die weit und tief suchen müssen
admin — Sun, 19 Jul 2026 21:02:24 +0000
 [ad_1]



Rechercheagenten übernehmen bereits heute echte Wissensarbeit. Die Groups delegieren ihnen Wettbewerbskartierung, Due Diligence und Literaturrecherche. Allerdings testen die meisten Benchmarks eine einzelne Antwort und keine großen, evidenzgestützten Sammlungen. Perplexity schließt diese Lücke mit einem neuen offenen Benchmark.
Ratlosigkeit befreit WANDR (Breite und tiefe Forschung). Es handelt sich um ein offenes Benchmark- und Bewertungssystem. Es besteht aus rund 500 realistischen, herausfordernden Datenerfassungsaufgaben für die Wissensarbeit. WANDR ist der große Bruder von Perplexitys DRACO-Benchmark für tiefgreifende Forschung. DRACO fragt, ob ein Agent einen genauen, vollständigen und objektiven Langformbericht erstellt. WANDR fragt stattdessen, ob es eine große Beweissammlung aufbauen kann.
Was ist WANDR
Im Kern testet WANDR zwei Anforderungen gemeinsam. Breit bedeutet, eine große, oft offene Gruppe qualifizierter Einheiten zu entdecken. Tief bedeutet, jedes Unternehmen ausreichend zu untersuchen, um jede Behauptung mit Beweisen zu untermauern. Durch die Kombination beider Faktoren ändert sich das Drawback für die Agenten. Ein paar überzeugende Beispiele reichen hier nicht aus. Eine ausgefeilte Erzählung, die auf unvollständigen Recherchen aufbaut, greift ebenfalls zu kurz.
Um dies zu erfassen, verwendet WANDR ein Composable Qualifikationsschlüsselhierarchie. Eine Aufgabe könnte eine Anforderung sein firm(n) -> worker(m) -> url(okay). Das bedeutet n qualifizierte Unternehmen, jeweils m Mitarbeiter und jeweils okay unterstützende Seiten. Jeder vollständige Pfad durch den Baum wird unabhängig validiert. Dieselbe Struktur kann eine flache Liste, eine verschachtelte Suche oder eine Matrix darstellen.
Ein konkretes Aufgabenbeispiel
Um diese Hierarchie zu begründen, betrachten Sie die Veröffentlichung ceo_cfo_appointments Aufgabe. Gefragt sind mindestens 70 in den USA ansässige Unternehmen. Für jeden muss eine Ernennung zum CEO oder CFO erstmals zwischen dem 1. März und dem 30. April 2026 bekannt gegeben werden. Für jeden stellt der Agent eine maßgebliche Terminseite bereit. Eine Unteraufgabe fügt professional Unternehmen eine Itemizing-Authority-Seite hinzu. Insgesamt erfordert die Aufgabe 140 quellengestützte Datensätze.
Konkret sehen die beiden Hierarchien und ein übermittelter Datensatz so aus:


# Job hierarchies
firm(70) -> company_appointee(1) -> url(1)   # 70 appointment information
firm(70) -> url(1)                           # 70 itemizing information

# One file the grader re-fetches and re-checks (values are illustrative)
{
  "merchandise":     "Instance Corp - new CFO",
  "url":      "https://issuer.instance.com/press/cfo-appointment",
  "excerpts": ("Instance Corp as we speak named Jane Doe as Chief Monetary Officer, efficient April 2026."),
  "reply":   "Jane Doe appointed CFO; introduced April 2026"
}


Realistische Aufgaben, maßstabsgetreu generiert
Über einzelne Beispiele hinaus baut WANDR seine Aufgaben auf der realen Nutzung auf. Es geht von nicht identifizierten Mustern aus, die in der Produktion zu sehen sind, und nicht von synthetischen Eingabeaufforderungen. Eine halbautomatische Pipeline wandelt diese Muster dann in Aufgaben um. Die Pipeline durchläuft vier Phasen: Seeding, Authoring, Zulassung und Kuration. Es verwendet eine verschachtelte Autor-Kritiker-Schleife mit mechanischer Flusenbildung.
Daher erfordert die mittlere Aufgabe insgesamt 50 Mitglieder und 245 Datensätze. Für alle 500 Aufgaben fordert WANDR 170.495 quellengestützte Datensätze. Die Aufgaben sind in 167 Aufgaben mit niedrigerem, 166 mittlerem und 167 höherem Schwierigkeitsgrad unterteilt. Der Schwierigkeitsgrad hängt von der Arbeit professional Datensatz ab, nicht nur vom Maßstab.
Wie WANDR Agenten bewertet
Im Gegensatz zu festen Antwortschlüsseln bewertet WANDR jeden Anspruch anhand der zitierten Beweise. Jeder Datensatz enthält ein Component, eine URL, ausgewählte Auszüge und eine Antwort. Der Bewerter ruft die Seite während der Bewertung erneut ab. Es prüft, ob die Seite nutzbar und im Umfang ist. Anschließend wird überprüft, ob die Auszüge tatsächlich vorliegen und alle Anforderungen erfüllen.
Diese binären Datensatzurteile werden dann in der Hierarchie zusammengefasst. Präzision misst die Qualität dessen, was ein System übermittelt hat. Abrufen misst die qualitätsbereinigte Fertigstellung und füllt etwaige Lücken mit Nullen. Weich Bei Partituren werden unvollständige Mitglieder teilweise angerechnet. Hart Scores zählen nur Mitglieder, deren vollständiger Teilbaum korrekt ist.
Die Benchmark-Ergebnisse
Mit dieser Methode führte Perplexity sechs Produktionssysteme für alle 500 Aufgaben aus. Sein eigenes Search as Code (SaC)-System führt. Dennoch kommt kein System auch nur annähernd an die Lösung des Benchmarks heran.




System
Weiches F1
Harte F1
Notizen




Ratlosigkeit (Suche als Code)
0,363
0,133
5,20 $/Aufgabe, durchschnittlich 14,9 Minuten, 3,82 Mio. Token/Aufgabe


Anthropisch
0,249
0,072
Am nächsten an der Qualität, aber mehr Zeit, Geld, Token


Andere (am besten)
0,121
0,035
OpenAI, Exa schneller und günstiger, aber schlechtere Werte




Mit mehr Aufwand erreicht Perplexity einen Gentle-F1-Wert von 0,447 xhigh Einstellung. Die Kosten über alle Einstellungen hinweg erstrecken sich über mehr als vier Größenordnungen. Der Preis reicht von 0,03 $ professional Aufgabe bis zu 324,83 $ professional Aufgabe.
Über die Bestenliste hinaus stechen vier Erkenntnisse hervor. Erstens ist ein teilweiser Fortschritt üblich, eine vollständige Abdeckung jedoch nicht. Jedes System zeigt einen Gentle-Recall unterhalb der Gentle-Präzision. Zweitens verschärft die Größenordnung das Drawback erheblich. Tiefere Hierarchien schaden am meisten, da jede Verzweigung einen Fehlerpunkt hinzufügt. Drittens ist die Entdeckung der erste strukturelle Engpass. Der Erkennungsabschluss auf oberster Ebene liegt systemübergreifend zwischen 0,611 und 0,951. Der größte Teil des fehlenden Volumens ist auf eine Unterlieferung zurückzuführen, nicht auf die Zusammenführung von Duplikaten. Viertens ist es normalerweise einfach, eine brauchbare Seite zu finden. Es ist der schwierige Teil, daraus vollständige Beweise zu machen. Bei Perplexity fehlt auf 41,4 % der Seiten eine wesentliche Anforderung. Außerdem stützen 57,5 % der Auszüge nicht die vollständige Behauptung. Sein weicher F1 fällt von 0,531 bei einer reinen Abrufprüfung auf 0,363 bei der vollständigen Beurteilung.
Insbesondere passt Search as Code intestine zu dieser Aufgabenform. Ein Agent kann Abruf-, Filter-, Fanout-, Be a part of-, Deduplizierungs- und Stopplogik als Programm ausdrücken. Die deterministische Berechnung verarbeitet dann wiederholte Vorgänge außerhalb des Modellkontexts.


  








  How WANDR Evaluates a Wide-and-Deep Research Agent
  Watch an agent discover entities (wide), enrich each one (deep), then get graded against cited evidence. Scores roll up the hierarchy into Precision, Recall, and F1. Numbers here are illustrative of the method.

  
    
      
      
      
      
    
    
      Effort:
      
        
        
        
      
    
  

  
    
      
    
    
      Ready
      Task: find companies → a CEO/CFO appointee → one evidence URL each. Press Discover to begin.

      
        Precision0.00
        
      
      
        Recall0.00
        
      
      
        Soft F10.00
        
      
      
        Hard F10.00
        
      

      
        submitted
        evidence verified
        failed check
        missing (target)
      
    
  

  
    Interactive explainer · method after Perplexity WANDR (Wide ANd Deep Research)
    Built by Marktechpost

System	Weiches F1	Harte F1	Notizen
Ratlosigkeit (Suche als Code)	0,363	0,133	5,20 $/Aufgabe, durchschnittlich 14,9 Minuten, 3,82 Mio. Token/Aufgabe
Anthropisch	0,249	0,072	Am nächsten an der Qualität, aber mehr Zeit, Geld, Token
Andere (am besten)	0,121	0,035	OpenAI, Exa schneller und günstiger, aber schlechtere Werte