H-Neurons: The Sparse Circuitry Behind LLM Hallucinations

A team of researchers from the Institute for Artificial Intelligence at Tsinghua published in December 2025 a finding that reframes how we understand hallucinations in large language models. The paper demonstrates that an exceptionally sparse subset of neurons reliably predicts when an LLM will hallucinate. Less than 0.1% of total neurons. In Mistral-7B, the range is 0.01‰ to 0.35‰. The implication is immediate: hallucinations are not uniformly distributed statistical noise — they are a localizable and intervenable phenomenon.

What Are H-Neurons and How Are They Identified

The paper defines H-Neurons as neurons in transformer feedforward networks (FFN) whose activation systematically predicts the occurrence of hallucinations. Identification combines three stages: construction of a deterministic dataset, a normalized contribution metric (CETT), and sparse classification via L1 logistic regression.

Results: Universal Generalization Across Families and Scales

The consistency across Mistral, Gemma, and Llama — and across scales from 4B to 70B — is the paper's most robust result. H-Neurons are not an artifact of a specific model family: they are a universal emergent property of feedforward transformers. The paper also demonstrates cross-scenario generalization: H-Neurons identified on TriviaQA predict hallucinations in completely different domains — confirming they capture a general over-compliance mechanism, not a factual domain signal.

Cross-Scenario Generalization: Detailed AUROC

The paper's most provocative finding is that H-Neurons identified in one scenario (TriviaQA — factual hallucination) predict problematic behaviors in semantically disjoint scenarios. The following table shows cross-scenario transfer AUROC scores for Mistral-7B-v0.3:

Four Dimensions of Over-Compliance Induced by α-Scaling

The central experiment of the paper is direct intervention: scaling H-Neuron activations by a factor α ∈ [0, 3]. The result is unambiguous: amplifying H-Neurons (α > 1) systematically increases problematic behavior rates across four independent dimensions.

Pre-Training Origin: RLHF Does Not Eliminate the Mechanism

The AUROC transferability analysis is the most important piece of evidence: the authors take H-Neurons identified in instruction-tuned models and verify their predictive power in the corresponding base models (before RLHF). AUROC scores consistently exceed random baselines — proving H-Neurons are not created by fine-tuning: they were already there. Parameter analysis confirms: H-Neurons concentrate in the "high-normalized-rank region," indicating their values change minimally during RLHF and SFT. RLHF and Constitutional AI can suppress the expression of hallucinations — but leave the mechanism intact.

Three Production Intervention Vectors

Production Implementation: Pseudo-Code and Architecture

For engineers looking to implement H-Neuron detection and suppression in production, the pipeline has three phases: offline identification, inference monitoring, and active suppression. The following pseudo-code shows the PyTorch implementation with forward pass hooks:

import torch
from sklearn.linear_model import LogisticRegression
import numpy as np

# ── Phase 1: Offline H-Neuron Identification ──
def compute_cett(model, dataloader, layer_indices):
    """Compute CETT scores for all FFN neurons."""
    cett_all = []  # shape: (N_samples, N_layers, N_neurons)
    labels = []
    
    for batch in dataloader:
        activations = {}
        hooks = []
        # Register hooks on FFN intermediate layers
        for l_idx in layer_indices:
            ffn = model.layers[l_idx].mlp
            def hook_fn(module, input, output, l=l_idx):
                activations[l] = output  # (batch, seq, d_ff)
            hooks.append(ffn.register_forward_hook(hook_fn))
        
        with torch.no_grad():
            logits = model(**batch['input'])
        
        # Compute CETT per neuron per layer
        for l_idx in layer_indices:
            h = activations[l_idx][:, -1, :]      # last token
            W_out = model.layers[l_idx].mlp.down_proj.weight
            projected = h.unsqueeze(-1) * W_out.T  # (batch, d_ff, d)
            norms = projected.norm(dim=-1)          # (batch, d_ff)
            cett = norms / norms.sum(dim=-1, keepdim=True)
            cett_all.append(cett.cpu().numpy())
        
        for h in hooks: h.remove()
    
    return np.concatenate(cett_all), np.array(labels)

# L1 logistic regression → H-Neuron indices
def identify_h_neurons(cett_matrix, labels, C=0.01):
    clf = LogisticRegression(
        penalty='l1', C=C, solver='saga', max_iter=5000
    )
    clf.fit(cett_matrix, labels)
    h_indices = np.where(clf.coef_[0] > 0)[0]
    return h_indices  # typically <0.1% of total neurons

# ── Phase 2: Runtime Monitoring ──
class HNeuronMonitor:
    def __init__(self, model, h_indices, layer_idx, alpha=1.0):
        self.h_indices = h_indices
        self.alpha = alpha
        self.scores = []
        
        ffn = model.layers[layer_idx].mlp
        ffn.register_forward_hook(self._hook)
    
    def _hook(self, module, input, output):
        h_act = output[:, -1, self.h_indices]
        score = h_act.abs().mean().item()
        self.scores.append(score)
        
        # Phase 3: α-scaling suppression
        if self.alpha != 1.0:
            output[:, :, self.h_indices] *= self.alpha
        return output
    
    def confidence(self, threshold=0.5):
        """Anti-hallucination confidence: 1.0 = safe."""
        return 1.0 - min(self.scores[-1] / threshold, 1.0)

Comparison with Prior Hallucination Detection Approaches

H-Neurons is not the first attempt to detect or mitigate LLM hallucinations. But it radically differs from existing approaches in resolution, computational cost, and intervention capability:

The fundamental advantage of H-Neurons: direct intervention. It not only detects — it suppresses. And unlike SelfCheckGPT, it does not require multiple forward passes. Detection occurs within a single pass with negligible additional latency (<5ms).

Open Questions and Limitations