Logical Closed Loop: Uncovering Object Hallucinations in Large Vision-Language Models (2024)

Abstract: Junfei Wu, Qiang Liu, Ding Wang, Jinghao Zhang, Shu Wu*, Liang Wang, Tieniu Tan 1 New Laboratory of Pattern Recognition (NLPR), State Key Laboratory of Multimodal Artificial Intelligence Systems, Institute of Automation, Chinese Academy of Sciences School of Artificial Intelligence, University of Chinese Academy of Sciences Nanjing University junfei.wu@cripac.ia.ac.cn, qiang.liu@nlpr.ia.ac.cn, wangding2024@ia.ac.cn jinghao.zhang@cripac.ia.ac.cn, {shu.wu, wangliang, tnt}@nlpr.ia.ac.cn Abstract

heading: 1 Introduction
text: With the great advancement of large language models (LLMs) (Ouyang et al., 2022; Touvron et al., 2023; Zhao et al., 2023), they have showcased impressive abilities, such as text generation, instruction following. Recent studies have been devoted to introduce the powerful capabilities of LLMs to the field of multimodal models. Empowered by LLMs,
*To whom correspondence should be addressed. 1The source code is publicly available at:
https://github.com/Hyperwjf/LogicCheckGPT.
large vision-language models (LVLMs) (Liu et al., 2023; Ye et al., 2023; Zhu et al., 2023; Li et al., 2023; Bai et al., 2023; Dai et al., 2023b) are facilitated to perform strong multimodal understanding and reasoning.
Despite the exciting breakthrough in LVLMs, they all suffer from hallucination issues inevitably, particularly object hallucination. Object hallucination refers to the phenomenon that the LVLMs generate inconsistent descriptions of the given image, for example, making up non-existent objects. Taking Fig. 1 as an example, the LVLM hallucinates several objects which are not existent in the image, including an apple and a boy. This issue hinders more widespread application of LVLMs. In safety-related scenarios, the consequences of
6944
hallucinations would be unbearable. There have been several efforts made to alleviate hallucinations in LVLMs. Generally, these methods can be categorized into three groups. The first as well as the most popular approach (Liu et al., 2024; Lee et al., 2023) mainly resorts to instruction tuning or specific retraining to facilitate LVLMs to generate less hallucinated contents. The second approach (Yin et al., 2023; Zhou et al., 2024) incorporates external detection models or specific LVLMs to enhance visual understanding, thereby refining the outputs of the original LVLMs. The last approach (Huang et al., 2023; Leng et al., 2023) investigates the decoding process of LVLMs and devise novel decoding strategies to avoid hallucinations. Although these methods have achieved some effectiveness in alleviating hallucinations, there are still some drawbacks: requiring significant computational resources, depending on external models, or necessitating access to the internal parameters of the model.
However, we argue that the logical consistency of LVLM behaviors have the potential to elucidate the underlying hallucination it encapsulates. As illustrated in Fig. 1, we first obtain the attributes “red” for “apple” and “on the table” for “banana” by inquiring the LVLM. Subsequently, when we inquire about which object possesses these attributes, the LVLM can correctly respond with “banana” but fails to answer for the hallucinated object “apple”. It demonstrates that when we pose a series of logically connected questions about a particular object, the LVLM exhibits better logical consistency for existing objects, while its performance tends to degrade for hallucinated objects. It is reasonable because the described attributes of hallucinated objects primarily originate from two sources: attributes from other objects in the image, or fabricated attributes absent in the image. Consequently, the model may fail to answer the hallucinated object when we question what possesses these attributes.
Inspired by this observation, we propose a novel and effective framework called Logic Closed Loop for Object Hallucination Detection and Mitigation, namely LogicCheckGPT, which is training-free and only requires language interaction. Our aim is to formulate two types of questions in two stages: the first stage involves inquiring attributes based on objects, followed by inquiring objects based on attributes. Whether their responses can form a logical closed loop serves as an indicator of object
hallucination. In specific, according to the different stages of questioning, we divide our framework into 5 steps: (1) Object extraction extracts objects in the responses of LVLMs. (2) Object-to-Attribute inquiring inquiries into the detailed attributes of the target objects. (3) Attribute-to-Object inquiring further formulates follow-up questions to inquire what object possesses the attributes mentioned in previous answers. (4) Logic closed loop check examines whether the logical relationships from objects to attributes and attributes to objects can form a closed loop. (5) Hallucination detection and mitigation rectifies hallucinated objects if the ratio of closed loops to the total number of questions exceeds a certain threshold. Our method is a plug-and-play approach that can be applied to various LVLMs without training or relying on external detection models. Furthermore, the question-answer process in natural language enhances its interpretability.
We evaluated the effectiveness of our framework across multiple advanced LVLMs on several benchmarks (Yifan et al., 2023; Fu et al., 2023), as well as GPT-4v assisted evaluation(Liu et al., 2024; Yin et al., 2023). Our method demonstrates significant improvements across state-of-the-art LVLMs, including a 31.33%/10.00% improvement on the POPE dataset for mPLUG-Owl (Ye et al., 2023)/MiniGPT-4 (Zhu et al., 2023).
Overall, our main contributions can be summarized as follows:
• We are the first to adopt the logical closed loop in the context of object hallucination alleviation in LVLMs.
• We propose a novel framework LogicCheckGPT for detecting and mitigating object hallucinations in LVLMs, which is trainingfree and offers language interaction for userfriendly interpretation.
• Comprehensive experiments are conducted to validate the effectiveness of our method, where the results demonstrate the superiority and universality.

heading: 2 Related Work

heading: 2.1 Large Vision-Language Models
text: With the surge in the capabilities of large language models (LLMs) (Ouyang et al., 2022; Zhao et al., 2023; Brown et al., 2020), there is currently
a growing interest in how to integrate the general artificial intelligence of LLMs into the multimodal domains. In consequence, large visionlanguage models (LVLMs) powered by LLMs are proposed (Ye et al., 2023; Zhu et al., 2023; Liu et al., 2023; Li et al., 2023; Dai et al., 2023a; Bai et al., 2023), which can understand multimodal contents and perform multimodal tasks under instructions. In general, existing LVLMs follow the following paradigm: leveraging a multimodal alignment module to comprehend multimodal inputs, followed by utilizing a LLM to generate responses. Therefore, the training process of LVLMs typically involves modalities alignment pre-training and instruction tuning. Specifically, mPLUG-Owl (Ye et al., 2023) pre-trains the encoder and alignment module, and then finetunes LLaMa (Touvron et al., 2023) by low-rank adaption. In contrast, LLaVA (Liu et al., 2023) only pre-trains the alignment network and finetunes the alignment network and Vicuna (Chiang et al., 2023) on constructed instructions. MiniGPT-4 (Zhu et al., 2023) only finetunes the cross-modal alignment network with other modules frozen.

heading: 2.2 Hallucination in LVLMs
text: Despite the strong capabilities of these LVLMs, they all grapple with hallucination issues unexpectedly. To tackle with this issue, several benchmarks (Fu et al., 2023; Xu et al., 2023; Yifan et al., 2023; Lovenia et al., 2023; Jing et al., 2023; Chen et al., 2024) have been proposed to provide detailed evaluations of the hallucination degree exhibited by LVLMs.
Existing hallucination mitigation strategies for LVLMs can be roughly divided into three groups. The first and most widely adopted approach (Liu et al., 2024; Gunjal et al., 2023; Lee et al., 2023; Wang et al., 2023) primarily relies on instruction tuning and retraining. LRV-Instruction (Liu et al., 2024) introduces a comprehensive instruction tuning dataset encompassing positive and negative instructions. (Wang et al., 2023) adopts an iterative instruction generation strategy to improve diversity and accuracy of instructions. Volcano (Lee et al., 2023) facilitates the model with the ability to utilize self-feedback to self-revise responses through training. However, these methods heavily depend on the quality of instruction data construction and require substantial computational resources.
The second group of approaches, exemplified by Woodpecker (Yin et al., 2023) and LURE (Zhou
et al., 2024), aim to integrate external detection models or specific LVLMs as revisors to enhance accurate visual understanding, thereby refining base LVLMs’ hallucinated generation. Nevertheless, these approaches rely on external models and fail to explore the intrinsic capabilities of the base model.
The third group of approaches aim to devise decoding strategies to mitigate hallucinations during the process of decoding. OPERA (Huang et al., 2023) propose a penalty-based decoding method along with roll-back strategy to avoid over-trust during decoding. On the other hand, VCD (Leng et al., 2023) introduces contrastive decoding to reduce over-reliance on spurious bias and learned priors. However, obtaining internal states of LVLMs during the decoding process poses a challenge for common users.
Compared to existing approaches, our proposed method is training-free and mitigates hallucinations solely through language interactions. It not only explores the potential of LVLMs to alleviate hallucinations but also offers better interpretability.

heading: 2.3 Consistency Checking for Hallucination Detection
text: There have also been some works on hallucination detection in LLMs (Manakul et al., 2023; Kuhn et al., 2022; Lin et al., 2023), which view the consistency of responses reflects the model’s uncertainty. (Kuhn et al., 2022) propose semantic entropy to measure the degree of semantic divergence among responses to accommodate semantic equivalence in free-form text. SelfCheckGPT (Manakul et al., 2023) extend the method to black-box LLMs, eliminating the need for tokens’ probability. (Lin et al., 2023) introduce and compare various uncertainty estimation metrics for black-box LLMs. In contrast to prior works that focus on consistency among responses to the same question, we propose LogicCheckGPT, a logic consistency-based method that involves logic-related questions and answers. LogicCheckGPT is more capable of delving deeper into the internal uncertainty and the degree of hallucination within the LVLMs.

heading: 3 Method
text: In this section, we first introduce the overall framework of LogicCheckGPT, and then elaborate each component. Our framework is shown in Fig. 2.

heading: 3.1 Overall
text: To alleviate object hallucinations, we delve into the logical consistency of LVLMs’ responses. Specifically, we examine whether the responses demonstrate logical coherence. For each object mentioned in a response, we pose two types of sequential questions: one regarding the attributes of the object, and another about which object possesses those attributes. The logical consistency of the LVLM’s responses, i.e., whether they form a closed loop of logical reasoning, serves as an indicator of object hallucination. Here, the “logical closed loop” refers to the subsequent object answered being consistent with the initial object.
This process is decomposed into the following steps: object extraction, object-to-attribute inquiring, attribute-to-object inquiring, logical closed loop checking, and hallucination detection and mitigation.

heading: 3.2 Object Extraction
text: To determine the object hallucination, we first need to extract candidate objects from the responses of LVLMs for further querying and checking. For simplicity and versatility, we adopt an LLM to complete each sub-task, including object extraction. Specifically, we employ GPT-3.5 2 as our LLM because of its strong capabilities. The prompt we used
2https://platform.openai.com/docs/models/gpt-3-5-turbo
can be referred in Appendix D.1. The extracted objects are represented as O = {o1, ..., oi, ..., om}, where m is the total number of examinee objects.

heading: 3.3 Object-to-Attribute Inquiring
text: As discussed in Section 3.1, the primary step involves constructing object-to-attribute questions to inquire about the attributes of the object. However, it is impractical to enumerate all possible attributes, given their infinite nature. Additionally, it is challenging to create generic attribute question templates applicable to all objects, as different objects typically possess their own specific attributes. For example, attributes related to material for a “dining table” differ from those related to clothing for a “person”.
For better flexibility and adaptability, we prompt the LVLM to provide a detailed description of the object oi in free-form text. The template question is formulated as follows: “Could you please describe the {object} in the image?” We ask the LVLM to respond multiple times. This approach allows us to obtain detailed and specific attribute descriptions from the LVLM regarding the object, thereby facilitating the construction of attribute-to-object questions in subsequent steps. The average number of extracted attributes of existent or hallucinated objects has also been studied in Section C.

heading: 3.4 Attribute-to-Object Inquiring
text: In the attribute-to-object inquiring stage, our goal is to formulate questions from the attributes to the object, in contrast to Section 3.3. After obtaining the attribute descriptions of the object, follow-up questions can be raised based on them. Rather than directly prompting the LLM to formulate questions from the descriptions, we break down this task into two subtasks: attribute extraction and question formulation. This approach avoids potential issues of misleading the LLM to not follow instructions and inadvertently revealing object identity in the questions. It has also been observed that decomposing a task into several simple sub-tasks for LLMs to fulfill yields better performance (Wei et al., 2022; Zhao et al., 2023).
In specific, we prompt the LLM to extract attributes of the target object oi from the description, wherein the target object is represented as “The object”. For instance, extracted attributes such as “The object is made of wood in the image”, “The object is red in color”. For the examinee object oi, the extracted attributes are represented as Ai = {ai,1, ..., ai,j , ..., ai,ni}, where the number of extracted attributes is denoted as ni. Detailed prompting instructions can be found in Appendix D.2.1.
Subsequently, we instruct the LLM to convert these extracted attributes into questions that inquire about what object possesses the specific attributes. However, we have noticed that asking questions like “What is/has {attribute} in the image?” often yield answers about the most obvious objects with the target attributes, potentially leading to the omission of other less conspicuous yet existent objects. To deal with this issue, we frame our questions Qi = {qi,1, ..., qi,j , ..., qi,ni} in the format “Could you tell me all the objects that {attribute} in the image?”. The ablation study of this prompt design can be referred in Section 4.3. This format enables the LVLM to comprehensively cover objects that meet the specified attribute constraints. Detailed prompting instructions can be found in Appendix D.2.2.

heading: 3.5 Logical Closed Loop Checking
text: After obtaining the answers Ri = {ri,1, ..., ri,j , ..., ri,ni} from the attribute-toobject inquiring stage, we can assess whether each answer forms a logical closed loop, meaning that the object mentioned in the answer is consistent
with the examinee object oi. In specific, we prompt the LLM to check whether the oi is covered in each LVLM’s response ri,j . The judgement is limited to “Yes” and “No”. For the i-th examinee object, the judgement of the j-th answer is mapped into score xi,j through the mapping {Yes: 1.0, No: 0.0}. The prompt is listed in Appendix D.3.

heading: 3.6 Hallucination Detection and Mitigation
text: Finally, the logical closed loop rate for each examinee object, defined as the number of logical closed loops divided by the total number of attribute-toobject question-answer pairs ni, can be formulated as
S(oi) = 1
ni
ni∑
j
xi,j (1)
where S(oi) denotes the logical closed loop rate for the i-th object.
As discussed before, the object is likely to be hallucinated when S(oi) is low. On the other hand, when it’s close to 1, it’s more likely that the object truly exists. Therefore, S(oi) serves as an indicator of object hallucination. Through a valid hallucination threshold λ, our method can effectively detect objects that are likely to be hallucinated, i.e., S(oi) is below λ.
After identifying hallucinated objects, we guide the LLM to eliminate contents related to hallucinated objects, aiming to minimize hallucinations. The detailed prompt can be found in Appendix D.4.

heading: 4 Experiment

heading: 4.1 Experimental Setup

heading: 4.1.1 Dataset
text: POPE (Yifan et al., 2023) is proposed to provide a detailed evaluation of object hallucination in LVLMs, by querying the models about the presence of specific objects in given images. POPE adopts three sampling settings to construct negative samples: random, popular, and adversarial. The random setting selects non-present objects at random, whereas the popular setting chooses from a list of frequently occurring but absent objects, and the adversarial method selects based on common co-occurrence in contexts despite the absence in the target image. For each sampling setting, we sample 50 images and 6 questions for each image, with an even distribution of positive and negative samples (50% - 50%). Accuracy and F1-score are employed as the evaluation metrics.
MME (Fu et al., 2023) serves as a comprehensive benchmark for evaluating the perecptual and cognitive capabilities of LVLMs across a wide spectrum of tasks. For the purpose of this study, we only utilize the existence subset to evaluate the phenomenon of object-level hallucination within these models. This approach mirrors the methodology employed in the POPE framework, wherein each subset consists of binary “Yes-or-No” questions. We use accuracy and accuracy+ as metrics, where the former is calculated based on each question, while the latter is based on each image, requiring both questions to be answered correctly.
GPT-4v Assisted Evaluation To assess the effectiveness of our method for hallucination mitigation in open-ended generation, we adopted the GPT-4v Assisted Evaluation, inspired by Yin et al. (2023) and Liu et al. (2024). Our evaluation samples a set of 50 images from the COCO 2014 validation dataset, and asks the model to generate detailed descriptions. Subsequently, we prompt GPT-4v to score original outputs and our outputs in accuracy and relevancy, based on the image and instruction. The detailed prompt example is shown in Appendix

heading: D.5.

heading: 4.1.2 Baselines
text: We selected several widely used open-source LVLMs as backbones to evaluate the effectiveness of our LogicCheckGPT, including mPLUGOwl (mplug-owl-llama-7b) (Ye et al., 2023), LLaVA (llava-1.5-7b) (Liu et al., 2023), MiniGPT4 (vicuna-13b) (Zhu et al., 2023), QWEN-VL-Chat (Bai et al., 2023).
We also compare our method with advanced hallucination detection and mitigation methods, including LRV-Instruction (Liu et al., 2024), LURE (Zhou et al., 2024) and SelfCheckGPT (Manakul et al., 2023). IRV-Instruction constructs a comprehensive instruction dataset for instruction tuning. However, as they only released the checkpoints of fine-tuned mPLUG-Owl and MiniGPT-4, we report the results of these two models. LURE trains a LVLM revisor to post-hoc rectify the hallucinated outputs of base models. SelfCheckGPT employs semantic uncertainty to detect hallucinations. We integrate it into our framework to fulfill hallucination mitigation. In addition, the base LVLMs are referred to as vanilla.

heading: 4.2 Experimental Results
text: Results on POPE The overall performance of our proposed method LogicCheckGPT on POPE is shown in Table 1, from which we have the following observations:
Firstly, our LogicCheckGPT consistently demonstrates significant performance improvements across various LVLMs under different settings. It can be observed that there is a significant performance decline of LVLMs as we transition from random to popular and adversarial settings, indicating that LVLMs tend to hallucinate non-existent objects that are related to the input image. In specific, mPLUG-Owl only achieved accuracies of 50.67%, 51.66%, and 55.33% across the three settings. For MiniGPT-4, its performance in adversarial settings is over 10% lower compared to that in random settings. However, with the help of LogicCheckGPT, all LVLMs outperform the vanilla ones significantly under all settings. More specifically, mPLUG-Owl equipped with LogicCheckGPT achieves an accuracy enhancement exceeding 30% across three settings. Despite the already promising performance of LLaVA-1.5, our method still brings a substantial improvement to it, achieving about a 6.67% increase in accuracy. This demonstrates the effectiveness and robustness of our approach.
Secondly, our proposed LogiCheckGPT outperforms other competitors by a significant margin. While LRV-Instruction facilitates robust instruction tuning of LVLMs, it remains challenging to completely eliminate potential hallucination issues within the model. Due to that SelfCheckGPT relies on semantic consistency in model responses, it is difficult to detect hallucinated objects when the LVLM is overconfident. LURE demonstrates significant improvements on models like mPLUGOwl and MiniGPT-4, but shows only marginal enhancements on more powerful models such as LLaVA-1.5 and QWEN-VL-Chat. We attribute this to the fact that LURE is built upon MiniGPT4, thus inheriting the limitations of the underlying model. By contrast, our LogicCheckGPT yields the most substantial improvements across all LVLMs, indicating the superiority of our method.
Results on MME Existence Subset As shown in Table 2, we also evaluate our method on MME existence subset, which focuses on the object existence hallucination. It can be observed that, although mPLUG-Owl performs worst, our method results in substantial increases in both accuracy and accuracy+, by 31.67% and 58.33%, respectively, achieving remarkably high levels of performance. It also demonstrates mPLUG-Owl inherently contains information pertaining to object hallucinations, which can be unearthed by our method. In addition, LogicCheckGPT consistently brings significant improvement for MiniGPT-4 and QWEN-VLChat, while maintaining the strong performance of LLaVA-1.5.
Results on GPT-4v Assisted Evaluation Apart from “Yes” or “No” questions in POPE and MME,

heading: Closed Loop Rate
text: we employed GPT-4v to assist in evaluating our LogicCheckGPT for open-text generation, following previous works (Liu et al., 2024; Yin et al., 2023). The results are summarized in Table 3. It can be observed that our method significantly enhances the accuracy of each model, demonstrating the effectiveness of our approach in object hallucination mitigation. In addition, as LogicCheckGPT can remove irrelevant hallucinated information and preserving fluent language structures, it can maintain or even improve relevancy.

heading: 4.3 Ablation Study
text: We conduct ablation study for several variants, as illustrated in Fig. 4.
• vanilla adopts no hallucination mitigation method.
• FreeCheck employs an LLM (GPT-3.5) to autonomously interrogate LVLMs through multiturn interactions, similiar to (Cohen et al.,
2023). This iterative process continues until either the LLM reaches a conclusion or the predefined iteration limit (set at 5 here) is reached. The prompt can be referred in Appendix E.
• LogicCheckGPT w/o AOP refers to replacing the Attribute-to-Object prompt in Section 3.4 by inquire only object instead of covering all objects, e.g. “What is/has {attribute} in the image?”.
• LogicCheckGPT w/o LCL employs an LLM to determine the logical consistency directly without Logical Closed Loop rate.
We can observe that FreeCheck performs worse for most LVLMs, primarily because the LLM fails to raise valuable questions to detect hallucinations. For the existent object, FreeCheck often raises questions about other objects that have been mentioned by the LVLMs during the interactions and cannot focus on the examinee object. For the hallucinated object, the questions raised are often simplistic, making it easy for FreeCheck to be misled and fail to detect object hallucination. LogicCheckGPT w/o AOP brings significant improvements to several models but still falls below our method, indicating that covering a sufficient number of objects is beneficial. Though LogicCheckGPT w/o LCL falls between vanilla and w/o AOP, demonstrating the effectiveness of calculating logical closed loop rate. For the powerful QWEN-VL-Chat, which has already achieved impressive performance, only our LogicCheckGPT can enhance its capabilities.

heading: 5 Hyperparameter Analysis
text: In this section, we conduct experiments on POPE under adversarial and popular setting to analyze the performance fluctuation of LogicCheckGPT with different values of key hyperparameters.

heading: 5.1 Logical closed loop threshold λ
text: We test our method with values of threshold λ ranging from 0.0 to 0.9 as shown in Figure 5 and have the following observations:
There is a significant increase when threshold λ is increasing from 0.0 initially for all models with LogicCheckGPT under both settings. It indicates that our method can significantly distinguish existent objects and hallucinated objects by valid threshold, as models tend to provide logically consistent responses for existent objects.
Subsequently, these these models reach their respective performance peaks. For instance, the performance of mPLUG-Owl achieves the best when λ is 0.4 under adversarial setting, and the best λ for LLaVA is also 0.4. For MiniGPT-4, the λ at which it reached its performance peak varied across different settings, 0.2 and 0.1 respectively. With the continued increase of the threshold, a noticeable decrease in performance can be observed. This is reasonable, as it leads to the misclassification of a large number of existent objects as non-existent.

heading: 5.2 The number of attributes n
text: The number of attributes n obtained during the object-to-attribute stage determines the number
of questions that can be generated from these attributes. We report the performance when n = 1, 2, 3, 4, 5 and ≥ 5 (See Figure 6) and summarize the observations as follows:
It can be observed that there is an obvious performance improvement when the number of attributes increases across the four LVLMs. This improvement is reasonable as it allows for a greater range of inquiries to verify the presence of the object. As n exceeds 5, the improvement becomes marginal.

heading: 5.3 Qualitative Examples
text: In this section, we have selected two representative examples for mPLUG-Owl covering distinct types of questions, including a binary question, “Is there a dining table in the image?” and an open-ended query, “Please describe this image in detail.”, as illustrated in Fig 3. In the first case 3(a), the model answers “yes” to the binary question, while our method detects that dining table is hallucinated and corrects the output. As for open-ended text generation, the models tends to hallucinate nonexistent objects as the length of the generated sequence increases. However, our method is capable of individually verifying the existence of objects, thereby mitigating hallucinations. More qualitative analysis can be referred in Section F.

heading: 6 Conclusion
text: We propose a novel logical closed loop-based framework LogicCheckGPT for object hallucination mitigation in LVLMs. Our motivation stems from the observation that LVLMs often exhibit logically inconsistent responses to hallucinated objects. Therefore, we devise logic consistency probing, which involves asking questions with logical correlations, such as inquiring about attributes from objects and vice versa. Specifically, we break down this process into several steps: object extraction, object-to-attribute inquiring, attribute-to-object inquiring, logical closed-loop checking, and hallucination detection and mitigation. Comprehensive experiments conducted on several benchmarks demonstrate the superiority of our framework.

heading: Limitations
text: In this work, we propose a logical closed loopbased framework for object hallucination mitigation. However, our method still has the following two limitations. Firstly, adopting our framework inevitably incurs costs, as we rely on the GPT-3.5
API. Secondly, our work only focuses on addressing object hallucinations. There are also other types of hallucinations, including attribute hallucinations and knowledge hallucinations. Therefore, extending our framework to encompass a broader range of hallucination mitigation represents our future directions.

heading: Acknowledgements
text: This work is supported by National Natural Science Foundation of China (62372454,62141608, 62236010).

heading: B The Choice of LLM for LogicCheckGPT
text: To investigate the flexibility of our framework, we have conducted experiments by replacing GPT-3.5 with Vicuna-13b-v1.53 (Chiang et al., 2023) . The results of the Vicuna variant and GPT variant on POPE are summarized in Table 4.
It can be observed that LogicCheckGPT implemented by Vicuna exhibits strong performance across the four LVLMs. Though the Vicuna variant performs slightly worse than the GPT variant, it still demonstrates a strong capability to detect and mitigate object hallucinations within LVLMs.
3https://huggingface.co/lmsys/vicuna-13b-v1.5
We also delve into the failure cases of the Vicuna variant and observe that this was due to errors occurring in object extraction and logical closed loop checking. These shortcomings primarily stem from inherent limitations within Vicuna itself and the design of prompts. This underscores the efficacy of our approach and the potential for substituting GPT with alternatives at each stage. As we have unified the framework and divided the whole process into several simple steps, including object extraction, attribute extraction, and rephrasing, we retain the flexibility to substitute GPT with alternative methods tailored to each step, potentially enhancing both efficiency and accuracy.

heading: C The distribution of the number of extracted attributes
text: To investigate whether there is a difference in the distribution of the number of extracted attributes between existent and hallucinated objects, we analyzed the number of attributes extracted from each description for both types of objects across 300 POPE adversarial instances, as shown in Table 5.
We have the following observations. There is a greater abundance of described attributes and a wider variance of existent objects among existent objects compared to hallucinated objects across the four LVLMs. This phenomenon can be attributed to the LVLMs could provide more detailed descriptions of existent objects based on the image while lacking a solid foundation for hallucinated objects. Notably, the MiniGPT-4 tends to describe more attributes for both existent and hallucinated objects, which aligns with our observation that responses generated by MiniGPT-4 are lengthier. However, as the numbers of attributes for both objects are close, it is still difficult to distinguish them only by the attribute count.
In our work, the number of attributes obtained during the object-to-attribute stage is set to at least 5. Specifically, in the object-to-attribute inquiring stage, we keep sampling responses from LVLMs until we have obtained at least 5 factored attributes or until we have sampled a maximum of 3 responses. This approach aims to gather a sufficient number of attributes for the Logical Closed Loop checking process, without being hindered by limitations in attribute quantity. It has been validated in Section 5.2 that as the number of attributes exceeds 5, the improvement becomes marginal.

heading: D Prompts

heading: D.1 Object Extraction
text: The prompt for object extraction is illustrated in Fig. 7.

heading: D.2 Attribute-to-Object Inquiring

heading: D.2.1 Attribute Extraction
text: The prompt for attribute extraction in attribute-toobject inquiring is illustrated in Fig. 8.

heading: D.2.2 Question Formulation
text: The prompt for question formulation in attributeto-object inquiring is illustrated in Fig. 9.

heading: D.3 Logical Closed Loop Checking
text: The prompt for logical closed loop checking is illustrated in Fig. 10.

heading: D.4 Hallucination Detection and Mitigation
text: The prompt for hallucination dection and mitigation is illustrated in Fig. 11.

heading: D.5 GPT-4V Assisted Evaluation
text: The prompt for hallucination dection and mitigation is illustrated in Fig. 12.

heading: E FreeCheck Prompts
text: The prompts for the ablation variant FreeCheck in different stages is illustrated in Table 6.

heading: F Qualitative Analysis
text: In this section, we visualize several examples of our LogicCheckGPT applied to various LVLMs, as shown in Fig. 13, 14, 15. As depicted in 13, for the MPLUG-Owl example, our method effectively identifies the hallucinated objects “people” and “handbag” both of which have logical closed-loop rates of 0.0. In contrast, for MiniGPT-4 (see Fig. 14), our method successfully detects the “building” but fails to identify the hallucinated object “trees”. This failure is attributed to the fact that the described hallucinated attributes are strongly correlated with the object and may inadvertently reveal the object’s identity. For instance, phrases like “have branches that stretch out from their trunks” and “have lush green leaves” suggest that the objects are trees. In addition, for LLaVA-1.5 in Fig. 15, LogicCheckGPT assigns a score of 1.00 to the existent object “clock” and 0.25 to the hallucinated object “person”. Since the score for "person" is below the threshold utilized in our study, we can detect the hallucinated object "person".

heading: System prompt

heading: Now complete the following:

heading: Here are some examples:

heading: Now complete the following:

heading: Here are some examples:

heading: System prompt

heading: System prompt

heading: Now complete the following:

heading: Here are some examples:

heading: You are given a statement and a question.

heading: System prompt

heading: Now complete the following:

heading: Here are some examples:

heading: System prompt

heading: Output format:

heading: 2: Relevancy: whether the response directly follows the instruction.

heading: 1: Accuracy: whether the response is accurate with respect to the image content. Responses with fewer hallucinations should be given higher scores.

heading: System prompt

heading: Now complete the following:

heading: Here are some examples:

heading: Q: Could you tell me all the objects that have branches that stretch out from their trunks in the image?

heading: Future Work
text: Therefore, extending our framework to encompass a broader range of hallucination mitigation represents our future directions