Hallucination Types in Language Models: A Complete Guide › Code: Detecting Intrinsic Hallucinations with NLI

# !uv pip install transformers torch -q

import warnings

warnings.filterwarnings("ignore")

# Source document
source = """
Anthropic was founded in 2021 by Dario Amodei and Daniela Amodei,
along with several other former OpenAI researchers.
The company raised $1.5 billion in its Series C funding round in 2023.
Anthropic focuses on AI safety research and the development of reliable AI systems.
Its primary product line, Claude, is designed to be helpful, harmless, and honest.
"""

# Summaries representing different hallucination types
summaries = {
    "faithful": (
        "Anthropic was founded in 2021 by Dario and Daniela Amodei. "
        "The company focuses on AI safety research. "
        "Claude is designed to be helpful, harmless, and honest."
    ),
    "intrinsic": (
        "Anthropic was founded in 2020 by Dario Amodei and Daniela Amodei. "
        "The company raised $1.5 billion in its Series C round in 2023. "
        "Its primary product is Claude."
    ),  # 2021 changed to 2020: direct contradiction of source
    "extrinsic": (
        "Anthropic was founded in 2021 by Dario and Daniela Amodei. "
        "The company has offices in San Francisco and London. "  # London not in source
        "Anthropic focuses on AI safety research."
    ),
    "fabrication": (
        "Anthropic was founded in 2021 by Dario Amodei, who previously "
        "won the Turing Award for his work on neural scaling laws. "  # Award invented
        "The company focuses on AI safety research."
    ),
}

def split_sentences(text):
    """Split text into sentences using punctuation boundaries."""
    text = text.strip()
    sentences = re.split(r"(?<=[.!?])\s+", text)
    return [s.strip() for s in sentences if len(s.strip()) > 10]


def lexical_overlap(left, right):
    """Jaccard overlap between lowercase alphanumeric token sets."""
    left_tokens = set(re.findall(r"[a-z0-9]+", left.lower()))
    right_tokens = set(re.findall(r"[a-z0-9]+", right.lower()))
    return len(left_tokens & right_tokens) / max(
        len(left_tokens | right_tokens), 1
    )


def score_hallucination(nli_model, source_text, summary_text):
    """
    Score each summary sentence for hallucination using cross-encoder NLI.

    For each summary sentence, retrieve the source sentence with the highest
    lexical overlap, then record the NLI entailment and contradiction scores.
    """
    source_sentences = split_sentences(source_text)
    summary_sentences = split_sentences(summary_text)

    results = []
    for hyp in summary_sentences:
        premise = max(
            source_sentences,
            key=lambda source_sentence: lexical_overlap(source_sentence, hyp),
        )
        output = nli_model(
            {"text": premise, "text_pair": hyp},
            truncation=True,
            max_length=512,
            top_k=None,
        )
        scores = {item["label"]: item["score"] for item in output}

        results.append(
            {
                "sentence": hyp,
                "entailment": scores["entailment"],
                "contradiction": scores["contradiction"],
            }
        )

    avg_entailment = float(np.mean([r["entailment"] for r in results]))
    avg_contradiction = float(np.mean([r["contradiction"] for r in results]))
    return results, avg_entailment, avg_contradiction

nli_model = pipeline(
    "text-classification",
    model="cross-encoder/nli-deberta-v3-small",
    device=-1,  # CPU; set to 0 for GPU
)

scored_summaries = {}
for summary_type, summary_text in summaries.items():
    results, avg_entail, avg_contra = score_hallucination(
        nli_model, source, summary_text
    )
    scored_summaries[summary_type] = {
        "results": results,
        "avg_entailment": avg_entail,
        "avg_contradiction": avg_contra,
    }