Hallucination Detection

from transformers import AutoModelForSequenceClassification, AutoTokenizer
import torch

class NLIHallucinationDetector:
    """
    Detect hallucinations by checking if claims are entailed by context.
    Uses DeBERTa-v3 fine-tuned on MNLI — stronger than BART-MNLI for
    this task (see Honovich et al. 2022 TRUE benchmark).
    """
    def __init__(self, model_name="microsoft/deberta-v3-large-mnli"):
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.model = AutoModelForSequenceClassification.from_pretrained(model_name)
        self.model.eval()
        # DeBERTa-MNLI label order: contradiction=0, neutral=1, entailment=2
        self.labels = ["contradiction", "neutral", "entailment"]

    def check_claim(self, context: str, claim: str) -> dict:
        """Check if a single claim is entailed by context."""
        inputs = self.tokenizer(
            context, claim,
            return_tensors="pt",
            truncation=True,
            max_length=512
        )
        with torch.no_grad():
            logits = self.model(**inputs).logits
            probs = torch.softmax(logits, dim=1)[0]

        scores = {l: p.item() for l, p in zip(self.labels, probs)}
        verdict = max(scores, key=scores.get)

        return {
            "claim": claim,
            "verdict": verdict,
            "is_grounded": verdict == "entailment",
            "is_hallucination": verdict == "contradiction",
            "scores": scores,
        }

    def check_response(self, context: str, claims: list[str]) -> dict:
        """Check all claims in an LLM response against context."""
        results = [self.check_claim(context, c) for c in claims]
        grounded = sum(1 for r in results if r["is_grounded"])

        return {
            "faithfulness": grounded / len(results) if results else 1.0,
            "grounded_count": grounded,
            "total_claims": len(results),
            "results": results,
        }

# Usage
detector = NLIHallucinationDetector()
context = "Apple Inc. reported revenue of $94.8 billion in Q1 2024."

claims = [
    "Apple's Q1 2024 revenue was approximately $94.8 billion.",  # Entailed
    "This represented a 2% year-over-year increase.",            # Neutral (not in context)
    "Apple reported a loss in Q1 2024.",                         # Contradiction
]

result = detector.check_response(context, claims)
print(f"Faithfulness: {result['faithfulness']:.0%}")
# Faithfulness: 33% (only 1/3 claims entailed by the context)

from openai import OpenAI
from transformers import AutoModelForSequenceClassification, AutoTokenizer
import torch
import numpy as np

client = OpenAI()

def selfcheck_gpt(prompt: str, n_samples: int = 5,
                   temperature: float = 0.7) -> dict:
    """
    SelfCheckGPT: detect hallucinations via sampling consistency.
    No reference context needed — uses model's own consistency.

    Steps:
    1. Generate one 'main' response at temperature 0
    2. Generate n_samples stochastic responses at higher temperature
    3. For each sentence in main response, check if it's consistent
       with the stochastic samples using NLI
    4. Sentences that are contradicted across samples = likely hallucinated
    """
    # Step 1: Generate main response (greedy)
    main = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": prompt}],
        temperature=0,
    ).choices[0].message.content

    # Step 2: Generate stochastic samples
    samples = []
    for _ in range(n_samples):
        resp = client.chat.completions.create(
            model="gpt-4o",
            messages=[{"role": "user", "content": prompt}],
            temperature=temperature,
        )
        samples.append(resp.choices[0].message.content)

    # Step 3: Split main response into sentences
    sentences = [s.strip() for s in main.split('.') if s.strip()]

    # Step 4: Check each sentence against each sample via NLI
    tokenizer = AutoTokenizer.from_pretrained("microsoft/deberta-v3-base-mnli")
    model = AutoModelForSequenceClassification.from_pretrained(
        "microsoft/deberta-v3-base-mnli"
    )
    model.eval()

    sentence_scores = []
    for sentence in sentences:
        contradictions = 0
        for sample in samples:
            inputs = tokenizer(sample, sentence,
                             return_tensors="pt", truncation=True)
            with torch.no_grad():
                probs = torch.softmax(model(**inputs).logits, dim=1)[0]
            # contradiction = index 0 for DeBERTa-MNLI
            if probs[0].item() > 0.5:
                contradictions += 1

        score = contradictions / n_samples
        sentence_scores.append({
            "sentence": sentence,
            "hallucination_score": score,  # 0 = consistent, 1 = always contradicted
            "likely_hallucinated": score > 0.4,
        })

    avg_score = np.mean([s["hallucination_score"] for s in sentence_scores])
    return {
        "overall_score": avg_score,
        "sentences": sentence_scores,
        "main_response": main,
    }

# Usage
result = selfcheck_gpt("Tell me about the founding of SpaceX.")
for s in result["sentences"]:
    flag = " [!]" if s["likely_hallucinated"] else ""
    print(f"  {s['hallucination_score']:.2f} | {s['sentence'][:60]}...{flag}")

from openai import OpenAI
import json

client = OpenAI()

def decompose_to_atomic_facts(text: str) -> list[str]:
    """
    Break text into atomic facts using an LLM.
    Each atomic fact is a single, verifiable claim.
    """
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{
            "role": "system",
            "content": """Decompose the text into atomic facts.
Each atomic fact should be:
- A single, self-contained claim
- Verifiable as true or false
- As specific as possible (include names, dates, numbers)
Return JSON: {"facts": ["fact1", "fact2", ...]}"""
        }, {
            "role": "user",
            "content": text
        }],
        response_format={"type": "json_object"}
    )
    return json.loads(response.choices[0].message.content)["facts"]


def factscore(text: str, knowledge_source: str) -> dict:
    """
    FActScore: atomic fact precision against a knowledge source.

    1. Decompose text into atomic facts
    2. Verify each fact against knowledge source (via NLI or LLM)
    3. Return proportion of supported facts
    """
    facts = decompose_to_atomic_facts(text)

    verified = []
    for fact in facts:
        # Use LLM-as-judge for verification (see Method 4)
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=[{
                "role": "system",
                "content": """Determine if the claim is supported by the source.
Respond with JSON: {"supported": true/false, "reason": "brief explanation"}"""
            }, {
                "role": "user",
                "content": f"Source: {knowledge_source}\n\nClaim: {fact}"
            }],
            response_format={"type": "json_object"}
        )
        result = json.loads(response.choices[0].message.content)
        verified.append({
            "fact": fact,
            "supported": result["supported"],
            "reason": result["reason"],
        })

    supported = sum(1 for v in verified if v["supported"])
    return {
        "factscore": supported / len(verified) if verified else 1.0,
        "supported": supported,
        "total": len(verified),
        "details": verified,
    }

# Usage
bio = """Marie Curie was born in Warsaw, Poland in 1867. She moved to Paris
in 1891 to study at the Sorbonne. She was the first woman to win a Nobel
Prize, receiving the Physics prize in 1903. She later won a second Nobel
Prize in Chemistry in 1911, making her the first person to win two Nobel
Prizes in different fields."""

source = """Marie Sklodowska Curie (1867-1934) was born in Warsaw. She moved
to Paris in 1891 and studied at the University of Paris. She won the Nobel
Prize in Physics in 1903 (shared with Pierre Curie and Henri Becquerel)
and the Nobel Prize in Chemistry in 1911."""

result = factscore(bio, source)
print(f"FActScore: {result['factscore']:.0%}")
# Note: "first person to win two Nobel Prizes in different fields"
# is actually Linus Pauling-debatable, but the claim about Curie
# being "first person" is commonly stated and technically true
# (Pauling won Peace, not a science field)

from openai import OpenAI
import json

client = OpenAI()

JUDGE_PROMPT = """You are a factual consistency judge. Given a source context
and an AI-generated response, evaluate each claim in the response.

For EACH claim, determine:
1. Is it SUPPORTED by the source context?
2. Is it CONTRADICTED by the source context?
3. Is it UNVERIFIABLE from the source context alone?

Be strict: if the source doesn't explicitly state something, mark it unverifiable.
Do not use your own knowledge — only judge against the provided source.

Respond in JSON:
{
  "claims": [
    {"text": "claim text", "verdict": "supported|contradicted|unverifiable",
     "evidence": "quote from source or explanation"},
  ],
  "overall_faithfulness": 0.0-1.0,
  "summary": "one sentence overall assessment"
}"""

def llm_judge(context: str, response: str,
              model: str = "gpt-4o") -> dict:
    """
    Use a strong LLM to judge factual consistency.
    Cost: ~$0.01-0.03 per evaluation with GPT-4o.
    """
    result = client.chat.completions.create(
        model=model,
        messages=[
            {"role": "system", "content": JUDGE_PROMPT},
            {"role": "user", "content": f"""Source context:
{context}

AI-generated response to evaluate:
{response}"""}
        ],
        response_format={"type": "json_object"},
        temperature=0,  # Deterministic for consistency
    )

    return json.loads(result.choices[0].message.content)

# Usage
context = """Tesla, Inc. was founded in 2003 by Martin Eberhard and
Marc Tarpenning. Elon Musk joined as chairman in 2004 after leading
the Series A funding round. The company went public in 2010."""

response = """Tesla was founded by Elon Musk in 2003. The company
went public in 2010 with an IPO price of $17 per share. It is
headquartered in Austin, Texas."""

judgment = llm_judge(context, response)
print(f"Faithfulness: {judgment['overall_faithfulness']}")
print(f"Summary: {judgment['summary']}")
for claim in judgment["claims"]:
    print(f"  [{claim['verdict'].upper()}] {claim['text']}")
    print(f"    Evidence: {claim['evidence']}")