Multimodal Hallucination

Multimodal hallucination is text generated about an image that states something the image does not show: an object that is absent, a wrong color, a relation that does not hold, a wrong count. It affects image captioning models and, prominently, vision–language models (VLMs), whose fluent answers read as confidently when wrong as when right, a concern for visually impaired users who rely on captions (Rohrbach et al., 2018).

Definition

A generated statement hallucinates when its content is absent from, or contradicted by, the image. The usual categories are:

• Object (existence): naming an object that is not there.
• Attribute: a wrong color, shape, size, material or state of a real object.
• Relation: a wrong spatial relation, contact or action between real objects.
• Count: the wrong number of real objects.

Of the corrections RLHF-V’s annotators made to 1.4K responses, 41.2% concerned objects, 20.3% positions, 16.5% numbers, 10.0% attributes and 5.3% actions (Yu et al., 2024).

An omission is a recall failure rather than a hallucination, since captions are not expected to list every object (Rohrbach et al., 2018), although Zhou et al. (2024) include omissions in their definition. Unlike factual hallucination in text-only language models, it is judged against the image, not world knowledge. HallusionBench separates the two sources inside a VLM: language hallucination, conclusions drawn from priors rather than the visual input, and visual illusion, a misreading of the image itself (Guan et al., 2024).

Intuition

A VLM generates each word from the image and the words already written; when visual evidence is weak, language expectations fill the gap. Rohrbach et al. (2018) illustrate this with the caption “A plate of food with broccoli and a fork”: an image-only classifier predicted bowl, broccoli, carrot and dining table, while a language model’s top guess for the last word was “fork”.

In detection terms, a hallucinated object is a false positive and an omission a false negative, so the metrics below borrow from precision and recall.

Formal Definition

CHAIR

CHAIR (Rohrbach et al., 2018) compares the objects a caption mentions with the objects in the image, over the 80 COCO object classes. Words are singularized and mapped to classes through a synonym list (“player” → person), with two-word names such as “hot dog” matched first, and the ground truth is the union of the image’s segmentation labels and the objects named in its reference captions. Over a set of captions,

$$\mathrm{CHAIR}_i = \frac{|\{\text{hallucinated objects}\}|}{|\{\text{all objects mentioned}\}|}, \qquad \mathrm{CHAIR}_s = \frac{|\{\text{captions with a hallucinated object}\}|}{|\{\text{all captions}\}|}.$$

Lower is better. For VLMs, Li et al. (2023) found CHAIR unstable: asking LLaVA for “a short caption” or “a brief description” gave CHAIR$_i$ of 10.5 and 18.8, with longer outputs for the second prompt.

POPE

POPE (Li et al., 2023) turns hallucination into binary classification. For each image it asks $l$ questions “Is there a/an ⟨object⟩ in the image?”, half about annotated objects (answer “yes”) and half about absent ones (“no”), chosen in one of three ways:

• Random: absent objects sampled uniformly.
• Popular: the $l/2$ most frequent objects in the dataset that are absent from the image.
• Adversarial: the $l/2$ absent objects that co-occur most often with the image’s objects.

The authors used 500 COCO validation images with more than three annotated objects and $l = 6$. With “yes” as the positive class, as the paper’s tables imply (its text words the definitions differently), they report accuracy, precision, recall, $F_1$ (the main metric) and the yes-ratio, the fraction of “yes” answers. Across four prompt wordings, LLaVA’s $F_1$ had a standard deviation of 0.78, against 3.22 for CHAIR$_i$ across four caption prompts.

Beyond object existence

• AMBER (Wang et al., 2023, preprint) annotates 1,004 images with objects, attributes (state, number, action), direct-contact relations, and plausible absent objects. Descriptions are scored with CHAIR and Cover, the fraction of annotated objects mentioned; yes/no questions cover existence, attributes and relations, with precision and recall computed on the “no” questions; the AMBER Score averages $1 - \mathrm{CHAIR}$ and that $F_1$. No language model is needed to score it.
• HallusionBench (Guan et al., 2024) pairs 346 images with 1,129 expert-written yes/no questions, about 45% of them on images edited by hand (flipped, masked, recolored), and groups questions into control pairs so that a model must answer consistently across an original and an edited image. Of 15 models, GPT-4V reached 31.42% question-pair accuracy (human-evaluated); the abstract puts all others below 16%, but the table lists Claude 3 at 21.76%.
• MMHal-Bench (Sun et al., 2024) has 96 open-ended questions on OpenImages images in eight types, such as attributes, absent objects, counting and spatial relations, chosen so that a 336-pixel LLaVA-13B checkpoint hallucinated. A text-only GPT-4 judge sees the question, the answer, the image’s category names and a human-written answer; for two models it agreed with human judgments 94% of the time.

Language-model judges need caution. RLHF-V’s authors found GPT-4 unreliable on MMHal-Bench, whose text annotations are incomplete, and used human annotators (Yu et al., 2024); HallusionBench’s GPT-4 judge varied between runs even at temperature 0 (Guan et al., 2024).

Example: CHAIR on invented captions

The script computes CHAIR$_i$, CHAIR$_s$ and coverage (the fraction of ground-truth objects mentioned) for two invented models on four synthetic scenes with object labels and a reference caption. It counts each distinct object once per caption, a simplification chosen here. It runs instantly with NumPy 2.3.5.

import re
import numpy as np

# Synonym map: surface word (singular) -> object class. Two-word names are matched first,
# so "hot dog" never also counts as "dog".
SYNONYMS = {
    "person": "person", "man": "person", "woman": "person", "boy": "person",
    "girl": "person", "player": "person", "people": "person", "child": "person",
    "dog": "dog", "puppy": "dog", "cat": "cat", "kitten": "cat",
    "frisbee": "frisbee", "bench": "bench", "table": "dining table",
    "dining table": "dining table", "fork": "fork", "knife": "knife",
    "cup": "cup", "mug": "cup", "plate": "plate", "pizza": "pizza",
    "hot dog": "hot dog", "laptop": "laptop", "keyboard": "keyboard",
    "mouse": "mouse", "chair": "chair", "car": "car", "bus": "bus",
    "traffic light": "traffic light", "bicycle": "bicycle", "bike": "bicycle",
}
IRREGULAR = {"people": "people", "children": "child", "men": "man", "women": "woman",
             "knives": "knife", "buses": "bus", "bus": "bus", "benches": "bench"}

def singular(w):
    if w in IRREGULAR:
        return IRREGULAR[w]
    return w[:-1] if w.endswith("s") and not w.endswith("ss") else w

def mentioned_objects(caption):
    """Object classes named in a caption, each distinct class counted once."""
    words = [singular(w) for w in re.findall(r"[a-z]+", caption.lower())]
    found, i = [], 0
    while i < len(words):
        pair = " ".join(words[i:i + 2])
        if pair in SYNONYMS:                         # compounds first
            found.append(SYNONYMS[pair]); i += 2
        elif words[i] in SYNONYMS:
            found.append(SYNONYMS[words[i]]); i += 1
        else:
            i += 1
    return list(dict.fromkeys(found))                # distinct, in order of mention

# Synthetic scenes: object labels (as from instance masks) plus one reference caption.
# As in CHAIR, the ground truth is the union of both sources. All captions are invented.
SCENES = [
    (["person", "dog", "frisbee"], "a woman throws a frisbee to her dog in a park"),
    (["pizza", "dining table", "knife"], "a pizza on a table next to a knife"),
    (["cat", "laptop", "keyboard"], "a kitten sleeping on a laptop keyboard"),
    (["car", "bus", "traffic light"], "cars and a bus waiting at a traffic light"),
]
CAPTIONS = {   # invented outputs of two hypothetical models
    "short captioner": [
        "a woman playing frisbee with a dog",
        "a pizza on a table",
        "a cat lying on a laptop",
        "a bus on a city street",
    ],
    "long describer": [
        "a woman throws a frisbee to her puppy while a man watches from a bench",
        "a pizza sits on a dining table with a knife, a fork and a cup of coffee",
        "a cat is curled up on a laptop keyboard with its paws on the keys",
        "a bus and several cars stop at a traffic light while people ride bikes",
    ],
}

gt = [set(labels) | set(mentioned_objects(ref)) for labels, ref in SCENES]
for model, caps in CAPTIONS.items():
    n_mentions = n_halluc = n_sent_halluc = n_covered = n_gt = 0
    halluc_words = []
    for caption, truth in zip(caps, gt):
        objs = mentioned_objects(caption)
        bad = [o for o in objs if o not in truth]
        n_mentions += len(objs); n_halluc += len(bad)
        n_sent_halluc += bool(bad)
        n_covered += len(set(objs) & truth); n_gt += len(truth)
        halluc_words += bad
    length = np.mean([len(c.split()) for c in caps])
    print(f"{model:15s} words/caption {length:4.1f}  CHAIR_i {n_halluc}/{n_mentions} = "
          f"{n_halluc / n_mentions:.3f}  CHAIR_s {n_sent_halluc}/{len(caps)} = "
          f"{n_sent_halluc / len(caps):.2f}  coverage {n_covered / n_gt:.2f}")
    print(f"{'':15s} hallucinated: {halluc_words}")
print("parse check:", mentioned_objects("two hot dogs and three men on benches"))

short captioner words/caption  6.0  CHAIR_i 0/8 = 0.000  CHAIR_s 0/4 = 0.00  coverage 0.67
                hallucinated: []
long describer  words/caption 15.2  CHAIR_i 5/17 = 0.294  CHAIR_s 3/4 = 0.75  coverage 1.00
                hallucinated: ['bench', 'fork', 'cup', 'person', 'bicycle']
parse check: ['hot dog', 'person', 'bench']

The terse captioner never hallucinates but omits a third of the objects; the verbose one covers everything but invents five objects, so neither number alone ranks the two. Class-level matching also hides an error: “a man watches” in scene 0 is invented, but “man” maps to person, which is present, so CHAIR does not count it.

Causes

Language priors and co-occurrence. Captioners that hallucinated more made errors more consistent with a language model than with an image classifier, and hallucination increased on a split whose test captions pair objects in combinations unseen in training (Rohrbach et al., 2018). VLMs most often hallucinate objects that are frequent in, or co-occur with the image’s objects in, COCO-based instruction data: for four models, on average 42–55% of an image’s hallucinated objects were among the ten most frequent COCO objects (Li et al., 2023). Adding noise to the image increased these hallucinations (Leng et al., 2024).

Training data. Li et al. (2023) suggest that InstructBLIP hallucinated least among their models because its instructions came from public datasets with short answers, while the others learned from longer instructions written by text-only language models. RLHF-V’s authors add noisy web captions and image augmentation: a random crop can remove an object the paired text still mentions (Yu et al., 2024).

Weak visual grounding. Captioners attending over detector regions hallucinated less than those using coarse feature maps (Rohrbach et al., 2018). LLaVA-1.5’s authors observed much less hallucination at $448 \times 448$ input and argue that a model learns to hallucinate when much of its training text describes details its input resolution cannot resolve (Liu et al., 2024).

Long outputs and decoding. Hallucinated objects tend to appear late: on average at word 6 of 9-word captions (Rohrbach et al., 2018), and in the later part of VLM descriptions and at high-uncertainty tokens (Zhou et al., 2024). OPERA’s authors observed that hallucinations often begin soon after “summary” tokens, such as punctuation, on which later tokens concentrate their attention, and argue that visual information fades as the text grows (Huang et al., 2024).

Agreeing with the question. In POPE, LLaVA, MultiModal-GPT and mPLUG-Owl answered “yes” to 95–100% of questions on every split (Li et al., 2023). LRV-Instruction’s authors attribute this partly to instruction data containing only positive examples (Liu et al., 2024, LRV).

Example: simulating POPE with a co-occurrence prior

The script samples synthetic image annotations whose objects depend on a scene type (kitchen, street, office, living room, beach), takes statistics from 5,000 training images, and builds POPE’s three question sets for 500 test images with at least three objects (the paper required more than three). Each simulated model sees the queried object through a detector score $s \sim \mathcal{N}(+1, 1)$ if present and $\mathcal{N}(-1, 1)$ if absent; two also use a co-occurrence prior $q$, the mean of $P(o \mid g)$ over the image’s other objects $g$. The answer is “yes” with probability $\sigma(w_v s + w_p \operatorname{logit} q + b)$. It runs in under a second with NumPy 2.3.5.

import sys
import numpy as np

rng = np.random.default_rng(int(sys.argv[1]) if len(sys.argv) > 1 else 3)

# A synthetic "dataset": each image has a scene type, and objects appear with
# type-specific probabilities (a COCO-like long tail with strong co-occurrence).
SCENES = {  # scene type: (share of images, {object: probability})
    "kitchen": (.30, {"dining table": .8, "cup": .6, "bowl": .6, "fork": .5, "knife": .45,
                      "bottle": .5, "chair": .6, "oven": .4, "sink": .4}),
    "street":  (.25, {"car": .85, "traffic light": .5, "bicycle": .35, "bus": .3,
                      "truck": .35, "handbag": .25, "bench": .25}),
    "office":  (.20, {"laptop": .75, "keyboard": .6, "mouse": .55, "chair": .7, "cup": .4,
                      "book": .5, "tv": .3}),
    "living":  (.15, {"couch": .7, "tv": .6, "chair": .5, "book": .4, "remote": .45,
                      "potted plant": .4, "cat": .2, "dog": .2}),
    "beach":   (.10, {"surfboard": .6, "umbrella": .5, "kite": .35, "boat": .35, "bird": .3}),
}
OBJ = sorted({o for _, p in SCENES.values() for o in p} | {"person"})
K, IDX = len(OBJ), {o: i for i, o in enumerate(OBJ)}

def sample_images(n):
    names = list(SCENES)
    shares = np.array([SCENES[s][0] for s in names])
    X = np.zeros((n, K), bool)
    for r, t in enumerate(rng.choice(len(names), n, p=shares)):
        p = np.full(K, .02)                       # rare out-of-context objects
        for o, q in SCENES[names[t]][1].items():
            p[IDX[o]] = q
        p[IDX["person"]] = .6
        X[r] = rng.random(K) < p
    return X

# 1. Statistics over a "training set" of 5,000 annotated images.
train = sample_images(5000)
freq = train.mean(0)                                   # P(object in image)
C = train.T.astype(float) @ train                      # co-occurrence counts
P_cond = (C + 1) / (np.diag(C)[:, None] + 2)           # P(b present | a present)

# 2. POPE-style question sets: 500 images with >= 3 objects, 3 yes + 3 no each.
test = sample_images(3000)
test = test[test.sum(1) >= 3][:500]

def negatives(present, setting):
    absent = np.flatnonzero(~present)
    if setting == "random":
        return rng.choice(absent, 3, replace=False)
    if setting == "popular":
        score = freq[absent]                            # most frequent overall
    else:                                               # adversarial
        score = C[present][:, absent].sum(0)            # co-occur most with true objects
    return absent[np.argsort(-score)[:3]]

# 3. Simulated models. Visual evidence: a detector score ~ N(+1, 1) if the object is
# present, N(-1, 1) if absent. Prior: mean P(object | other true object) over the
# image's other objects, a stand-in for co-occurrence learned from captions.
def answer(present, objs, w_vis, w_prior, bias):
    s = rng.normal(np.where(present[objs], 1.0, -1.0), 1.0)
    ctx = [np.flatnonzero(present & (np.arange(K) != o)) for o in objs]
    prior = np.array([P_cond[c, o].mean() for c, o in zip(ctx, objs)])
    logit = w_vis * s + w_prior * np.log(prior / (1 - prior)) + bias
    return rng.random(len(objs)) < 1 / (1 + np.exp(-logit))   # True = "yes"

MODELS = {"vision only":      (2.0, 0.0, 0.0),
          "vision + prior":   (2.0, 1.5, 1.0),
          "yes-biased prior": (0.5, 1.5, 3.0)}
print(f"{K} object classes; {len(test)} test images; most frequent: "
      + ", ".join(OBJ[i] for i in np.argsort(-freq)[:4]))
print(f"{'model':17s} {'setting':12s} {'acc':>5s} {'prec':>5s} {'rec':>5s} {'F1':>5s} {'yes%':>5s}")
for name, (wv, wp, b) in MODELS.items():
    for setting in ("random", "popular", "adversarial"):
        y_true, y_pred = [], []
        for present in test:
            pos = rng.choice(np.flatnonzero(present), 3, replace=False)
            objs = np.concatenate([pos, negatives(present, setting)])
            y_true += [True] * 3 + [False] * 3
            y_pred += list(answer(present, objs, wv, wp, b))
        t, p = np.array(y_true), np.array(y_pred)
        tp, fp, fn = (t & p).sum(), (~t & p).sum(), (t & ~p).sum()
        prec, rec = tp / (tp + fp), tp / (tp + fn)
        print(f"{name:17s} {setting:12s} {100 * (t == p).mean():5.1f} {100 * prec:5.1f} "
              f"{100 * rec:5.1f} {200 * prec * rec / (prec + rec):5.1f} {100 * p.mean():5.1f}")

32 object classes; 500 test images; most frequent: person, chair, cup, dining table
model             setting        acc  prec   rec    F1  yes%
vision only       random        77.4  76.9  78.4  77.6  51.0
vision only       popular       76.5  76.6  76.2  76.4  49.7
vision only       adversarial   76.9  77.0  76.8  76.9  49.9
vision + prior    random        83.1  92.4  72.2  81.1  39.1
vision + prior    popular       77.7  80.1  73.7  76.8  46.0
vision + prior    adversarial   74.2  74.7  73.0  73.9  48.8
yes-biased prior  random        77.7  74.7  83.7  79.0  56.0
yes-biased prior  popular       62.8  58.8  85.7  69.7  72.9
yes-biased prior  adversarial   53.9  52.5  83.9  64.5  79.9

The vision-only model scores about the same on all splits. With the prior, accuracy falls from 83.1% (random) to 77.7% (popular) and 74.2% (adversarial) as the negatives become more plausible and the yes-ratio rises; on the random split the prior helps, since a random absent object rarely fits the scene. The yes-biased model shows the pattern of POPE’s weakest models: high recall, precision falling toward 50%. Over seeds 0–9, the vision + prior model’s accuracy ranged over 82.7–84.3%, 76.1–79.4% and 73.7–75.6% on the three splits.

Reported results

POPE results on COCO validation from Li et al. (2023), in percent (500 images, 3,000 questions per split); LLaVA here is the original model with a 13B LLaMA:

Model (language model)	Split	Accuracy	Precision	Recall	$F_1$	Yes
InstructBLIP (Vicuna-13B)	random	88.73	85.08	93.93	89.29	55.20
InstructBLIP (Vicuna-13B)	adversarial	74.37	67.67	93.33	78.45	68.97
MiniGPT-4 (Vicuna-13B)	random	77.83	75.38	82.67	78.86	54.83
MiniGPT-4 (Vicuna-13B)	adversarial	66.60	62.45	83.27	71.37	66.67
LLaVA (LLaMA-13B)	random	54.43	52.32	99.80	68.65	95.37
LLaVA (LLaMA-13B)	adversarial	50.77	50.39	99.87	66.98	99.10

LLaVA-1.5-13B reported $F_1$ of 87.1, 86.2 and 84.5 on the random, popular and adversarial splits, against 76.3, 72.2 and 70.1 for a 7B LLaVA (Liu et al., 2024). Numbers from different papers are not directly comparable: on 50 sampled images, Woodpecker’s authors measured 86.00% random-split accuracy for a model they call LLaVA, against 54.43% in the POPE paper (Yin et al., 2024, arXiv version).

Mitigation

Better data. LRV-Instruction has 400K instructions that GPT-4 wrote from Visual Genome boxes and dense captions, with answers under 30 words, including negative instructions that mention nonexistent objects, give existing objects wrong attributes, or misstate knowledge. Fine-tuning MiniGPT-4 and mPLUG-Owl on it reduced hallucination, most robustly with balanced positive and negative instructions (Liu et al., 2024, LRV). RLHF-V’s authors fine-tuned on VQAv2 and dropped random cropping (Yu et al., 2024).

Preference optimization. LLaVA-RLHF trained a reward model on 10K human comparisons favoring the less hallucinated response, then ran reinforcement learning; its Factually Augmented RLHF also gives the reward model COCO captions or A-OKVQA rationales (Sun et al., 2024). RLHF-V instead had annotators correct the hallucinated segments of 1.4K responses and trained with dense DPO, which up-weights the corrected segments by a factor $\gamma > 1$ (see vision–language models for DPO). On Object HalBench, responses with a hallucinated object fell from 50.5% for the base Muffin model to 12.2% (GPT-4V: 13.6%); on the authors’ human-annotated MHumanEval, object hallucination fell from 33.6% to 21.9% of responses, the 34.8% relative reduction quoted in their abstract (Yu et al., 2024).

Decoding-time methods. Visual Contrastive Decoding runs the model on the image $v$ and on a noise-corrupted copy $v'$ and samples from

$$p_{\text{vcd}}(y \mid v, v', x) = \operatorname{softmax}\big[(1 + \alpha)\,\operatorname{logit}_\theta(y \mid v, x) - \alpha\,\operatorname{logit}_\theta(y \mid v', x)\big],$$

which demotes tokens that stay likely without clear visual evidence; only tokens whose probability given the clean image is at least $\beta$ times the maximum are kept, so the contrast cannot promote implausible tokens (Leng et al., 2024). With $\alpha = 1$ and $\beta = 0.1$, sampling-based decoding of the 7B LLaVA-1.5 on COCO’s adversarial POPE split rose from 77.57 to 81.33 $F_1$ (mean of five runs). OPERA penalizes beam-search candidates that follow a summary-token attention pattern and rolls back to re-select tokens when it persists; its authors report only marginal POPE gains, since one-line answers rarely show the pattern (Huang et al., 2024).

Post-hoc revision. LURE trains a revisor on descriptions that GPT-3.5 corrupted with likely co-occurring objects, with uncertain or late objects replaced by an “[IDK]” tag, then rewrites any VLM’s output (Zhou et al., 2024). Woodpecker needs no training: it extracts the key objects in a response, verifies them with the open-vocabulary detector Grounding DINO (counts) and BLIP-2 (attribute questions), and has GPT-3.5 correct the text; on POPE’s random split it raised MiniGPT-4’s accuracy from 54.67% to 85.33% (Yin et al., 2024, arXiv version).

Suppressing claims has a cost: short or evasive responses can score well on MMHal-Bench, a trade-off between honesty and helpfulness (Sun et al., 2024).

Common Misconceptions

• “A low CHAIR score means a good caption.” A caption that names almost nothing scores near zero; pair hallucination rates with coverage or human judgment.
• “High POPE accuracy rules out hallucination.” POPE probes object existence with one-word answers; yes/no results can disagree with a model’s detailed descriptions (Sun et al., 2024).
• “The metrics see every error.” CHAIR matches 80 classes at class level; POPE must find “yes” or “no” in free text (Li et al., 2023), and its accuracy alone hides yes-bias; language-model judges inherit the gaps of their reference annotations.

Where It Is Used

Hallucination benchmarks accompany task metrics in evaluating vision–language models and captioners. The problem is the generative counterpart of the language-prior problem in VQA, and an instance of the wider question of how multimodal models weigh evidence from each modality.