Hallucination Detection

from transformers import pipeline

# Load NLI model (BART trained on MNLI)
nli = pipeline("zero-shot-classification",
               model="facebook/bart-large-mnli")

def check_grounded(claim: str, context: str) -> dict:
    """
    Check if a claim is supported by the context.
    Returns label and confidence score.
    """
    # NLI: Is the claim entailed by the context?
    result = nli(
        claim,
        candidate_labels=["entailment", "neutral", "contradiction"],
        hypothesis_template="{}",
        multi_label=False
    )

    # Also check with context as premise
    # Using the NLI properly: context |= claim?
    from transformers import AutoModelForSequenceClassification, AutoTokenizer
    import torch

    model_name = "facebook/bart-large-mnli"
    tokenizer = AutoTokenizer.from_pretrained(model_name)
    model = AutoModelForSequenceClassification.from_pretrained(model_name)

    # Tokenize with context as premise, claim as hypothesis
    inputs = tokenizer(context, claim, return_tensors="pt", truncation=True)

    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)[0]

    labels = ["contradiction", "neutral", "entailment"]
    label_probs = {l: p.item() for l, p in zip(labels, probs)}

    return {
        "is_grounded": label_probs["entailment"] > 0.5,
        "label": max(label_probs, key=label_probs.get),
        "scores": label_probs
    }

# Usage
context = "The company reported revenue of $10 million in Q3 2024."
claim = "The company made $10 million in the third quarter."

result = check_grounded(claim, context)
print(f"Grounded: {result['is_grounded']}")
print(f"Label: {result['label']}")
print(f"Entailment score: {result['scores']['entailment']:.3f}")

from openai import OpenAI
from collections import Counter
import re

client = OpenAI()

def self_consistency_check(question: str, context: str,
                           n_samples: int = 5,
                           temperature: float = 0.7) -> dict:
    """
    Generate multiple answers and check for consistency.
    Returns the majority answer and a confidence score.
    """
    answers = []

    for _ in range(n_samples):
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=[
                {"role": "system", "content": "Answer based ONLY on the context provided. Be concise."},
                {"role": "user", "content": f"Context: {context}\n\nQuestion: {question}"}
            ],
            temperature=temperature
        )
        answers.append(response.choices[0].message.content.strip())

    # Normalize answers for comparison (lowercase, strip punctuation)
    def normalize(text):
        return re.sub(r'[^a-z0-9\s]', '', text.lower()).strip()

    normalized = [normalize(a) for a in answers]

    # Count occurrences
    counter = Counter(normalized)
    most_common, count = counter.most_common(1)[0]

    # Find original answer that matches normalized version
    majority_answer = next(a for a, n in zip(answers, normalized) if n == most_common)

    consistency_score = count / n_samples

    return {
        "answer": majority_answer,
        "consistency_score": consistency_score,
        "is_consistent": consistency_score >= 0.6,
        "all_answers": answers,
        "sample_count": n_samples
    }

# Usage
context = "Apple Inc. was founded by Steve Jobs, Steve Wozniak, and Ronald Wayne in 1976."
question = "When was Apple founded?"

result = self_consistency_check(question, context, n_samples=5)
print(f"Answer: {result['answer']}")
print(f"Consistency: {result['consistency_score']:.0%}")
print(f"Reliable: {result['is_consistent']}")

from openai import OpenAI
import json

client = OpenAI()

def extract_claims(answer: str) -> list:
    """Extract atomic claims from an answer."""
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": """Extract all factual claims from the text.
Return a JSON array of strings, each being one atomic claim.
Only include verifiable factual statements, not opinions."""},
            {"role": "user", "content": answer}
        ],
        response_format={"type": "json_object"}
    )

    result = json.loads(response.choices[0].message.content)
    return result.get("claims", [])

def verify_claims(claims: list, context: str) -> dict:
    """Verify each claim against the context using NLI."""
    from transformers import AutoModelForSequenceClassification, AutoTokenizer
    import torch

    tokenizer = AutoTokenizer.from_pretrained("facebook/bart-large-mnli")
    model = AutoModelForSequenceClassification.from_pretrained("facebook/bart-large-mnli")

    verified = []
    for claim in claims:
        inputs = tokenizer(context, claim, return_tensors="pt", truncation=True)
        with torch.no_grad():
            outputs = model(**inputs)
            probs = torch.softmax(outputs.logits, dim=1)[0]

        entailment_score = probs[2].item()  # Index 2 is entailment
        verified.append({
            "claim": claim,
            "supported": entailment_score > 0.5,
            "score": entailment_score
        })

    supported_count = sum(1 for v in verified if v["supported"])
    faithfulness = supported_count / len(claims) if claims else 1.0

    return {
        "faithfulness_score": faithfulness,
        "verified_claims": verified,
        "supported_count": supported_count,
        "total_claims": len(claims)
    }

def full_hallucination_check(answer: str, context: str) -> dict:
    """Complete hallucination detection pipeline."""
    claims = extract_claims(answer)
    verification = verify_claims(claims, context)

    return {
        "is_faithful": verification["faithfulness_score"] >= 0.8,
        "faithfulness_score": verification["faithfulness_score"],
        "claims": verification["verified_claims"],
        "summary": f"{verification['supported_count']}/{verification['total_claims']} claims verified"
    }

# Usage
context = """
Apple Inc. was founded by Steve Jobs, Steve Wozniak, and Ronald Wayne in 1976.
The company is headquartered in Cupertino, California. As of 2023, Apple is
the world's largest technology company by revenue, with $383 billion in 2023.
"""

answer = """
Apple was founded in 1976 by Steve Jobs and Steve Wozniak.
The company is based in Cupertino and generated over $380 billion in revenue in 2023.
Apple is known for the iPhone, which was first released in 2008.
"""

result = full_hallucination_check(answer, context)
print(f"Faithful: {result['is_faithful']}")
print(f"Score: {result['faithfulness_score']:.0%}")
print(f"Verified: {result['summary']}")