ทำความรู้จัก GraphEval: กรอบการทำงานตรวจจับภาวะหลอนใน LLM ด้วยกราฟความรู้

!pip install -q transformers networkx matplotlib torch

# The ground-truth context provided to the LLM
source_context = (
    "GraphEval is a hallucination evaluation framework based on representing information "
    "in Knowledge Graph (KG) structures. It acts as a pre-processing step and utilizes "
    "out-of-the-box NLI models to detect factual inconsistencies."
)

# The generated response we want to evaluate (contains a hallucination)
llm_output = (
    "GraphEval is an evaluation framework that uses Knowledge Graphs. "
    "It requires a highly expensive, enterprise-level server farm to operate."
)
 
# Prompt template that would theoretically be passed to a local/free LLM (e.g. Mistral-7B)
KG_EXTRACTION_PROMPT = f"""
You are an expert information extractor. Extract the core information from the following text as a Knowledge Graph.
Return the output strictly as a Python list of tuples in the format: (Subject, Relationship, Object).
 
Text: {llm_output}
"""
``` เพื่อลดภาระการประมวลผล เราจะจำลองผลลัพธ์ของไตรภาคที่สกัดได้ ซึ่งมีการจงใจใส่ข้อมูลเท็จเรื่องความต้องการฟาร์มเซิร์ฟเวอร์ระดับองค์กรลงไป เพื่อทดสอบระบบตรวจจับ
 
```python
# Simulated extraction to bypass the heavy computational load of running a massive LLM locally
extracted_triples = [
    ("GraphEval", "is", "evaluation framework"),
    ("GraphEval", "uses", "Knowledge Graphs"),
    ("GraphEval", "requires", "expensive enterprise server farm")
]
 
print("Extracted Triples:")
for t in extracted_triples:
    print(t)

from transformers import pipeline
 
# Loading the open-source NLI model
print("Loading DeBERTa NLI model...")
nli_evaluator = pipeline("text-classification", model="cross-encoder/nli-deberta-v3-small")
 
def evaluate_triple(context, triple):
    subject, relation, obj = triple
    hypothesis = f"{subject} {relation} {obj}"
 
# Checking if the context entails the hypothesis
    result = nli_evaluator({"text": context, "text_pair": hypothesis})
 
# NLI models normally output: 'entailment', 'neutral', or 'contradiction'
    label = result['label'].lower()
 
# In GraphEval, anything other than 'entailment' is flagged as a hallucination
    is_hallucinated = label != 'entailment'
 
return is_hallucinated, label, hypothesis
 
# Running the evaluation pipeline
evaluation_results = []
 
print("\n--- GraphEval Results ---")
for t in extracted_triples:
    is_hallucinated, nli_label, hypothesis = evaluate_triple(source_context, t)
    evaluation_results.append((is_hallucinated, nli_label))
 
status = "🚨 HALLUCINATION" if is_hallucinated else "✅ GROUNDED"
    print(f"{status} | Triple: {t} | NLI Output: {nli_label}")

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)
 
# Color-code the edges based on the NLI evaluation
        edge_colors.append('red' if is_hallucinated else 'green')
 
# Set up the plot
    plt.figure(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='bold')
 
# 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(color='green', label='Grounded (Entailment)')
    red_patch = mpatches.Patch(color='red', label='Hallucination (Neutral/Contradiction)')
    plt.legend(handles=[green_patch, red_patch], loc='lower right')
 
plt.title("GraphEval Hallucination Map", fontsize=14, fontweight='bold')
    plt.axis('off')
    plt.tight_layout()
    plt.show()
 
# Render the knowledge graph
visualize_grapheval(extracted_triples, evaluation_results)