Upload 2398 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+OPERA/teaser.png filter=lfs diff=lfs merge=lfs -text

OPERA/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 QidongHuang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

OPERA/README.md

@@ -0,0 +1,185 @@
+# OPERA: Alleviating Hallucination in Multi-Modal Large Language Models via Over-Trust Penalty and Retrospection-Allocation (CVPR 2024 Highlight)
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-g.svg)](https://opensource.org/licenses/MIT)
+[![Arxiv](https://img.shields.io/badge/arXiv-2311.17911-B21A1B)](https://arxiv.org/pdf/2311.17911.pdf)
+[![Hugging Face Transformers](https://img.shields.io/badge/%F0%9F%A4%97-Transformers-blue)](https://github.com/huggingface/transformers)
+[![GitHub Stars](https://img.shields.io/github/stars/shikiw/OPERA?style=social)](https://github.com/shikiw/OPERA/stargazers)
+
+
+This repository provides the official PyTorch implementation of the following paper: 
+> [**OPERA: Alleviating Hallucination in Multi-Modal Large Language Models via Over-Trust Penalty and Retrospection-Allocation**](https://arxiv.org/pdf/2311.17911.pdf) <br>
+> [Qidong Huang](https://shikiw.github.io/)<sup>1,2</sup>, 
+> [Xiaoyi Dong](https://scholar.google.com/citations?user=FscToE0AAAAJ&hl=en)<sup>2</sup>, 
+> [Pan Zhang](https://panzhang0212.github.io/)<sup>2</sup>,
+> [Bin Wang](https://wangbindl.github.io/) <sup>2</sup>,
+> [Conghui He](https://conghui.github.io/) <sup>2</sup>, 
+> [Jiaqi Wang](https://myownskyw7.github.io/)<sup>2</sup>,
+> [Dahua Lin](http://dahua.site/)<sup>2</sup>, 
+> [Weiming Zhang](http://staff.ustc.edu.cn/~zhangwm/index.html)<sup>1</sup>, 
+> [Nenghai Yu](https://scholar.google.com/citations?user=7620QAMAAAAJ&hl=en)<sup>1</sup> <br>
+> <sup>1</sup>University of Science and Technology of China, <sup>2</sup>Shanghai AI Laboratory <br>
+
+
+## Overview
+
+<p align="center"><img src="./teaser.png" alt="teaser" width="500px" /></p>
+
+Hallucination, posed as a pervasive challenge of multimodal large language models (MLLMs), has significantly impeded their real-world usage that demands precise judgment. Existing methods mitigate this issue with either training with specific designed data or inferencing with external knowledge from other sources, incurring inevitable additional costs. In this paper, we present OPERA, a novel MLLM decoding method grounded in an Over-trust Penalty and a Retrospection-Allocation strategy, serving as a nearly free lunch to alleviate the hallucination issue without additional data, knowledge, or training. Our approach begins with an interesting observation that, most hallucinations are closely tied to the knowledge aggregation patterns manifested in the self-attention matrix, i.e., MLLMs tend to generate new tokens by focusing on a few summary tokens, but not all the previous tokens. Such partial overtrust inclination results in the neglecting of image tokens and describes the image content with hallucination. Based on the observation, OPERA introduces a penalty term on
+the model logits during the beam-search decoding to mitigate the over-trust issue, along with a rollback strategy that retrospects the presence of summary tokens in the previously generated tokens, and re-allocate the token selection if necessary. With extensive experiments, OPERA shows significant hallucination-mitigating performance on different MLLMs and metrics, proving its effectiveness and generality.
+
+## Setup
+
+The main implementation of OPERA is in `transformers-4.29.2/src/transformers/generation/utils.py`.
+
+So it is convenient to use OPERA decoding by just installing our modified `transformers` package.
+```
+conda env create -f environment.yml
+conda activate opera
+python -m pip install -e transformers-4.29.2
+```
+#### Note: to implement OPERA on other version of transformers, you can follow the steps as the follows:
+- Find the file at `transformers-4.29.2/src/transformers/generation/utils.py`.
+- Add the arguments in `transformers.generate` function [here](https://github.com/shikiw/OPERA/blob/aa968c7501f4d3d8362f4b3bcab855024f4da5f6/transformers-4.29.2/src/transformers/generation/utils.py#L1156-L1162).
+- Add the code in `transformers.generate` function [here](https://github.com/shikiw/OPERA/blob/aa968c7501f4d3d8362f4b3bcab855024f4da5f6/transformers-4.29.2/src/transformers/generation/utils.py#L1619-L1665).
+- Copy and paste the `opera_decoding` function [here](https://github.com/shikiw/OPERA/blob/aa968c7501f4d3d8362f4b3bcab855024f4da5f6/transformers-4.29.2/src/transformers/generation/utils.py#L3116-L3674).
+
+## TL;DR
+After setup the environment, you can directly use OPERA on your own MLLM model by:
+```
+# specify the location indexes of some input tokens
+START_INDEX_of_IMAGE_TOKENS = <the location index of the first image token>
+END_INDEX_of_IMAGE_TOKENS = <the location index of the last image token>
+NUM_of_TOKENS_IN_THE_PROMPT = <the total number of tokens in the user prompt (including image tokens)>
+
+key_position = {
+  "image_start": START_INDEX_of_IMAGE_TOKENS, 
+  "image_end": END_INDEX_of_IMAGE_TOKENS, 
+  "response_start": NUM_of_TOKENS_IN_THE_PROMPT,
+}
+
+# add some arguments in the generate function
+outputs = MLLM_model.generate(
+    input_ids=input_ids,
+    inputs_embeds=inputs_embeds,
+    attention_mask=attention_mask,
+    do_sample=False,
+    num_beams=5,
+    max_new_tokens=512,
+    # opera
+    opera_decoding=True,
+    key_position=key_position,
+    scale_factor=50,
+    threshold=15,
+    num_attn_candidates=5,
+    penalty_weights=1,
+)
+# for a more efficient version, please use the setting below:
+outputs = MLLM_model.generate(
+    input_ids=input_ids,
+    inputs_embeds=inputs_embeds,
+    attention_mask=attention_mask,
+    do_sample=False,
+    num_beams=5,
+    max_new_tokens=512,
+    # opera
+    opera_decoding=True,
+    key_position=key_position,
+    scale_factor=50,
+    threshold=25,
+    num_attn_candidates=1,
+    penalty_weights=1,
+)
+```
+
+Please refer to `demo.ipynb` [here](https://github.com/shikiw/OPERA/blob/1e74d8b5d082579c81e0e77ef1cf4a44d20ab91e/demo.ipynb) for more details.
+
+
+## Evaluation
+
+The following evaluation requires for MSCOCO 2014 dataset. Please download [here](https://cocodataset.org/#home) and extract it in your data path.
+
+Besides, it needs you to prepare the following checkpoints of 7B base models:
+
+- Download [LLaVA-1.5 merged 7B model](https://huggingface.co/liuhaotian/llava-v1.5-7b) and specify it at [Line 14](https://github.com/shikiw/OPERA/blob/bf18aa9c409f28b31168b0f71ebf8457ae8063d5/eval_configs/llava-1.5_eval.yaml#L14) of `eval_configs/llava-1.5_eval.yaml`.
+- Download [Vicuna 7B v1.1 model](https://github.com/lm-sys/FastChat) and specify it at [Line 25](https://github.com/shikiw/OPERA/blob/bf18aa9c409f28b31168b0f71ebf8457ae8063d5/minigpt4/configs/models/blip2_instruct_vicuna7b.yaml#L25) of `minigpt4/configs/models/blip2_instruct_vicuna7b.yaml`.
+- Download [Vicuna 7B v0 model](https://huggingface.co/Vision-CAIR/vicuna-7b/tree/main) and specify it at [Line 18](https://github.com/shikiw/OPERA/blob/bf18aa9c409f28b31168b0f71ebf8457ae8063d5/minigpt4/configs/models/minigpt4_vicuna0.yaml#L18) of `minigpt4/configs/models/minigpt4_vicuna0.yaml`.
+- Download [MiniGPT-4 7B pretrained weights](https://drive.google.com/file/d/1RY9jV0dyqLX-o38LrumkKRh6Jtaop58R/view?usp=sharing) and specify it at [Line 8](https://github.com/shikiw/OPERA/blob/bf18aa9c409f28b31168b0f71ebf8457ae8063d5/eval_configs/minigpt4_eval.yaml#L8) of `eval_configs/minigpt4_eval.yaml`.
+- Download [Shikra merged 7B model](https://github.com/shikras/shikra#checkpoint) and specify it at [Line 14](https://github.com/shikiw/OPERA/blob/bf18aa9c409f28b31168b0f71ebf8457ae8063d5/eval_configs/shikra_eval.yaml#L14) of `eval_configs/shikra_eval.yaml`.
+
+### Arguments
+
+| Argument             | Example             | Description   |
+| -------------------- | ------------------- | ------------- |
+| `--model`    | `llava-1.5` | Specify the MLLM model, this codebase supports `instructblip`, `minigpt4`, `llava-1.5`, `shikra`. |
+| `--data-path`     | `/path/to/dataset` | Path to the dataset file or folder, e.g., `COCO_2014/val2014/`. |
+| `--pope-type`     | `random` | Type for POPE evaluation, supports `random`, `popular`, `adversarial`. |
+| `--scale_factor`   | `50` | The scale factor to scale up the self-attention weights. Default: 50. |
+| `--threshold`      | `15` | The threshold for attending retrospection. Default: 15. |
+| `--num_attn_candidates`   | `5` | The number of candidates per beam. Default: 5. |
+| `--penalty_weights`| `1` | The weight of penalty term in decoding. Default: 1.  |
+
+### POPE
+```bash
+python pope_eval.py --model MODEL_NAME --data_path /path/to/COCO --pope-type random --gpu-id GPU_IDs --beam 5 --scale_factor 50 --threshold 15 --num_attn_candidates 5 --penalty_weights 1
+```
+Result on `Random` split:
+
+| Model | Accuracy | Precision | Recall | F1 score| Yes ratio |
+| ----- | -------- | --------- | ------ | ------- | --------- |
+| InstructBLIP 7B | 90.3 | 93.8 | 87.0 | 90.3 | 47.8 |
+| MiniGPT-4 7B | 79.8 | 89.7 | 68.7 | 77.8 | 39.5 |
+| LLaVA-1.5 7B | 89.4 | 90.4 | 88.8 | 89.6 | 50.6 |
+
+Result on `Popular` split:
+
+| Model | Accuracy | Precision | Recall | F1 score| Yes ratio |
+| ----- | -------- | --------- | ------ | ------- | --------- |
+| InstructBLIP 7B | 83.4 | 81.2 | 87.0 | 84.0 | 53.6 |
+| MiniGPT-4 7B | 73.6 | 75.9 | 69.0 | 72.3 | 45.4 |
+| LLaVA-1.5 7B | 86.0 | 84.1 | 88.8 | 86.4 | 52.8 |
+
+Result on `Adversarial` split:
+
+| Model | Accuracy | Precision | Recall | F1 score| Yes ratio |
+| ----- | -------- | --------- | ------ | ------- | --------- |
+| InstructBLIP 7B | 80.7 | 77.3 | 87.0 | 81.9 | 56.3 |
+| MiniGPT-4 7B | 71.6 | 72.9 | 68.9 | 70.8 | 47.3 |
+| LLaVA-1.5 7B | 79.1 | 74.4 | 88.8 | 81.0 | 59.7 |
+
+### CHAIR
+- Generate the MLLM's responses and save them in a jsonl file:
+```bash
+python chair_eval.py --model MODEL_NAME --data_path /path/to/COCO --gpu-id GPU_IDs --beam 5 --scale_factor 50 --threshold 15 --num_attn_candidates 5 --penalty_weights 1
+```
+Note: Please check out our released results in `log/chair_eval_results` for reproduction.
+
+- Calculate CHAIR using the generated jsonl file:
+```bash
+python chair.py --cap_file /path/to/jsonl --image_id_key image_id --caption_key caption --coco_path /path/to/COCO/annotations_trainval2014/annotations/ --save_path /path/to/save/jsonl
+```
+
+### GPT-4V
+The GPT-4V evaluation requires you to specify your API key in [Line 88](https://github.com/shikiw/OPERA/blob/559556048224d5c3eae995a21d529156fb150d5f/gpt4v_eval.py#L88) of `gpt4v_eval.py`.
+```bash
+python gpt4v_eval.py --model MODEL_NAME --data_path /path/to/COCO --gpu-id GPU_IDs --scale_factor 50 --threshold 15 --num_attn_candidates 5 --penalty_weights 1
+```
+
+
+
+
+## Acknowledgement
+This repo is based on the MLLM codebase of [LAVIS](https://github.com/salesforce/LAVIS) and [MiniGPT-4](https://github.com/Vision-CAIR/MiniGPT-4) and the CHAIR code of [Maxlinn](https://github.com/Maxlinn/CHAIR-metric-standalone). Thanks for their impressive works!
+
+## Citation
+If you find this work useful for your research, please cite [our paper](https://arxiv.org/pdf/2311.17911.pdf):
+```
+@inproceedings{huang2024opera,
+  title={Opera: Alleviating hallucination in multi-modal large language models via over-trust penalty and retrospection-allocation},
+  author={Huang, Qidong and Dong, Xiaoyi and Zhang, Pan and Wang, Bin and He, Conghui and Wang, Jiaqi and Lin, Dahua and Zhang, Weiming and Yu, Nenghai},
+  booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition},
+  pages={13418--13427},
+  year={2024}
+}
+```
+
+

OPERA/chair.py

@@ -0,0 +1,484 @@
+'''
+Copied from: https://github.com/LisaAnne/Hallucination/blob/master/utils/chair.py
+
+Modified by: Maxlinn
+
+1. adapt calculation of CHAIR-i and CHAIR-s for Python3, supports for both json and jsonl file input.
+2. integrate synonyms.txt to make the script standalone.
+3. remove machine-translation based metrics BLEU-n, CIDEr, ROGUE
+4. add new metric Recall, which represents the node words(i.e. lemmas of objects) coverage overall.
+5. add pickle cache mechanism to make it fast for repetitive evaluations.
+'''
+
+
+import os
+import sys
+import nltk
+import json
+# from pattern.en import singularize
+from nltk.corpus import wordnet
+from nltk.stem import WordNetLemmatizer
+import argparse
+import tqdm
+import pickle
+from collections import defaultdict
+
+
+# copied from: https://github.com/LisaAnne/Hallucination/blob/master/data/synonyms.txt
+synonyms_txt = '''
+person, girl, boy, man, woman, kid, child, chef, baker, people, adult, rider, children, baby, worker, passenger, sister, biker, policeman, cop, officer, lady, cowboy, bride, groom, male, female, guy, traveler, mother, father, gentleman, pitcher, player, skier, snowboarder, skater, skateboarder, person, woman, guy, foreigner, child, gentleman, caller, offender, coworker, trespasser, patient, politician, soldier, grandchild, serviceman, walker, drinker, doctor, bicyclist, thief, buyer, teenager, student, camper, driver, solider, hunter, shopper, villager
+bicycle, bike, bicycle, bike, unicycle, minibike, trike
+car, automobile, van, minivan, sedan, suv, hatchback, cab, jeep, coupe, taxicab, limo, taxi
+motorcycle, scooter,  motor bike, motor cycle, motorbike, scooter, moped
+airplane, jetliner, plane, air plane, monoplane, aircraft, jet, jetliner, airbus, biplane, seaplane
+bus, minibus, trolley
+train, locomotive, tramway, caboose
+truck, pickup, lorry, hauler, firetruck
+boat, ship, liner, sailboat, motorboat, dinghy, powerboat, speedboat, canoe, skiff, yacht, kayak, catamaran, pontoon, houseboat, vessel, rowboat, trawler, ferryboat, watercraft, tugboat, schooner, barge, ferry, sailboard, paddleboat, lifeboat, freighter, steamboat, riverboat, battleship, steamship
+traffic light, street light, traffic signal, stop light, streetlight, stoplight
+fire hydrant, hydrant
+stop sign
+parking meter
+bench, pew
+bird, ostrich, owl, seagull, goose, duck, parakeet, falcon, robin, pelican, waterfowl, heron, hummingbird, mallard, finch, pigeon, sparrow, seabird, osprey, blackbird, fowl, shorebird, woodpecker, egret, chickadee, quail, bluebird, kingfisher, buzzard, willet, gull, swan, bluejay, flamingo, cormorant, parrot, loon, gosling, waterbird, pheasant, rooster, sandpiper, crow, raven, turkey, oriole, cowbird, warbler, magpie, peacock, cockatiel, lorikeet, puffin, vulture, condor, macaw, peafowl, cockatoo, songbird
+cat, kitten, feline, tabby
+dog, puppy, beagle, pup, chihuahua, schnauzer, dachshund, rottweiler, canine, pitbull, collie, pug, terrier, poodle, labrador, doggie, doberman, mutt, doggy, spaniel, bulldog, sheepdog, weimaraner, corgi, cocker, greyhound, retriever, brindle, hound, whippet, husky
+horse, colt, pony, racehorse, stallion, equine, mare, foal, palomino, mustang, clydesdale, bronc, bronco
+sheep, lamb, ram, lamb, goat, ewe
+cow, cattle, oxen, ox, calf, cattle, holstein, heifer, buffalo, bull, zebu, bison 
+elephant
+bear, panda
+zebra
+giraffe
+backpack, knapsack
+umbrella
+handbag, wallet, purse, briefcase
+tie, bow, bow tie
+suitcase, suit case, luggage
+frisbee
+skis, ski
+snowboard
+sports ball, ball
+kite
+baseball bat
+baseball glove
+skateboard
+surfboard, longboard, skimboard, shortboard, wakeboard
+tennis racket, racket
+bottle
+wine glass
+cup
+fork
+knife, pocketknife, knive
+spoon
+bowl, container
+banana
+apple
+sandwich, burger, sub, cheeseburger, hamburger
+orange
+broccoli
+carrot
+hot dog
+pizza
+donut, doughnut, bagel
+cake,  cheesecake, cupcake, shortcake, coffeecake, pancake
+chair, seat, stool
+couch, sofa, recliner, futon, loveseat, settee, chesterfield 
+potted plant, houseplant
+bed
+dining table, table, desk
+toilet, urinal, commode, toilet, lavatory, potty
+tv, monitor, televison, television
+laptop, computer, notebook, netbook, lenovo, macbook, laptop computer
+mouse
+remote
+keyboard
+cell phone, mobile phone, phone, cellphone, telephone, phon, smartphone, iPhone
+microwave
+oven, stovetop, stove, stove top oven
+toaster
+sink
+refrigerator, fridge, fridge, freezer
+book
+clock
+vase
+scissors
+teddy bear, teddybear
+hair drier, hairdryer
+toothbrush
+'''
+
+
+def combine_coco_captions(annotation_path):
+
+    if not os.path.exists('%s/captions_%s2014.json' %(annotation_path, 'val')):
+        raise Exception("Please download MSCOCO caption annotations for val set")
+    if not os.path.exists('%s/captions_%s2014.json' %(annotation_path, 'train')):
+        raise Exception("Please download MSCOCO caption annotations for train set")
+
+    val_caps = json.load(open('%s/captions_%s2014.json' %(annotation_path, 'val')))
+    train_caps = json.load(open('%s/captions_%s2014.json' %(annotation_path, 'train')))
+    all_caps = {'info': train_caps['info'],
+                'licenses': train_caps['licenses'],
+                'images': val_caps['images'] + train_caps['images'],
+                'annotations': val_caps['annotations'] + train_caps['annotations']}
+
+    return all_caps 
+
+def combine_coco_instances(annotation_path):
+
+    if not os.path.exists('%s/instances_%s2014.json' %(annotation_path, 'val')):
+        raise Exception("Please download MSCOCO instance annotations for val set")
+    if not os.path.exists('%s/instances_%s2014.json' %(annotation_path, 'train')):
+        raise Exception("Please download MSCOCO instance annotations for train set")
+
+    val_instances = json.load(open('%s/instances_%s2014.json' %(annotation_path, 'val')))
+    train_instances = json.load(open('%s/instances_%s2014.json' %(annotation_path, 'train')))
+    all_instances = {'info': train_instances['info'],
+                     'licenses': train_instances['licenses'],
+                     'type': train_instances['licenses'],
+                     'categories': train_instances['categories'],
+                     'images': train_instances['images'] + val_instances['images'],
+                     'annotations': val_instances['annotations'] + train_instances['annotations']}
+
+    return all_instances 
+
+class CHAIR(object):
+
+    def __init__(self, coco_path):
+
+        self.imid_to_objects = defaultdict(list) # later become a dict of sets
+
+        self.coco_path = coco_path
+
+        #read in synonyms
+        synonyms = synonyms_txt.splitlines()
+        synonyms = [s.strip().split(', ') for s in synonyms]
+        self.mscoco_objects = [] #mscoco objects and *all* synonyms
+        self.inverse_synonym_dict = {}
+        for synonym in synonyms:
+            self.mscoco_objects.extend(synonym)
+            for s in synonym:
+                self.inverse_synonym_dict[s] = synonym[0]
+
+        #Some hard coded rules for implementing CHAIR metrics on MSCOCO
+        
+        #common 'double words' in MSCOCO that should be treated as a single word
+        coco_double_words = ['motor bike', 'motor cycle', 'air plane', 'traffic light', 'street light', 'traffic signal', 'stop light', 'fire hydrant', 'stop sign', 'parking meter', 'suit case', 'sports ball', 'baseball bat', 'baseball glove', 'tennis racket', 'wine glass', 'hot dog', 'cell phone', 'mobile phone', 'teddy bear', 'hair drier', 'potted plant', 'bow tie', 'laptop computer', 'stove top oven', 'hot dog', 'teddy bear', 'home plate', 'train track']
+        
+        #Hard code some rules for special cases in MSCOCO
+        #qualifiers like 'baby' or 'adult' animal will lead to a false fire for the MSCOCO object 'person'.  'baby bird' --> 'bird'.
+        animal_words = ['bird', 'cat', 'dog', 'horse', 'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe', 'animal', 'cub']
+        #qualifiers like 'passenger' vehicle will lead to a false fire for the MSCOCO object 'person'.  'passenger jet' --> 'jet'.
+        vehicle_words = ['jet', 'train']
+        
+        #double_word_dict will map double words to the word they should be treated as in our analysis
+        
+        self.double_word_dict = {}
+        for double_word in coco_double_words:
+            self.double_word_dict[double_word] = double_word
+        for animal_word in animal_words:
+            self.double_word_dict['baby %s' %animal_word] = animal_word
+            self.double_word_dict['adult %s' %animal_word] = animal_word
+        for vehicle_word in vehicle_words:
+            self.double_word_dict['passenger %s' %vehicle_word] = vehicle_word
+        self.double_word_dict['bow tie'] = 'tie'
+        self.double_word_dict['toilet seat'] = 'toilet'
+        self.double_word_dict['wine glas'] = 'wine glass'
+        
+        self.get_annotations()
+
+    def _load_generated_captions_into_evaluator(self, cap_file, image_id_key, caption_key):
+
+        '''
+        Meant to save time so imid_to_objects does not always need to be recomputed.
+        '''
+        #Read in captions        
+        self.caps, self.eval_imids = load_generated_captions(cap_file, image_id_key, caption_key)
+        assert len(self.caps) == len(self.eval_imids)
+
+    def get_wordnet_pos(self, tag):
+        if tag.startswith('J'):
+            return wordnet.ADJ
+        elif tag.startswith('V'):
+            return wordnet.VERB
+        elif tag.startswith('N'):
+            return wordnet.NOUN
+        elif tag.startswith('R'):
+            return wordnet.ADV
+        else:
+            return None
+
+    def caption_to_words(self, caption):
+    
+        '''
+        Input: caption
+        Output: MSCOCO words in the caption
+        '''
+    
+        #standard preprocessing
+        words = nltk.word_tokenize(caption.lower())
+        tagged_sent = nltk.pos_tag(words)
+        lemmas_sent = []
+        wnl = WordNetLemmatizer()
+        for tag in tagged_sent:
+            wordnet_pos = self.get_wordnet_pos(tag[1]) or wordnet.NOUN
+            lemmas_sent.append(wnl.lemmatize(tag[0], pos=wordnet_pos))
+        # words = [singularize(w) for w in words]
+        words = lemmas_sent
+    
+        #replace double words
+        i = 0
+        double_words = []
+        idxs = []
+        while i < len(words):
+           idxs.append(i) 
+           double_word = ' '.join(words[i:i+2])
+           if double_word in self.double_word_dict: 
+               double_words.append(self.double_word_dict[double_word])
+               i += 2
+           else:
+               double_words.append(words[i])
+               i += 1
+        words = double_words
+    
+        #toilet seat is not chair (sentences like "the seat of the toilet" will fire for "chair" if we do not include this line)
+        if ('toilet' in words) & ('seat' in words): words = [word for word in words if word != 'seat']
+    
+        #get synonyms for all words in the caption
+        idxs = [idxs[idx] for idx, word in enumerate(words) \
+                if word in set(self.mscoco_objects)]
+        words = [word for word in words if word in set(self.mscoco_objects)]
+        node_words = []
+        for word in words:
+            node_words.append(self.inverse_synonym_dict[word])
+        #return all the MSCOCO objects in the caption
+        return words, node_words, idxs, double_words
+
+    def get_annotations_from_segments(self):
+        '''
+        Add objects taken from MSCOCO segmentation masks
+        '''
+
+        coco_segments = combine_coco_instances(self.coco_path )
+        segment_annotations = coco_segments['annotations']
+
+        #make dict linking object name to ids
+        id_to_name = {} #dict with id to synsets 
+        for cat in coco_segments['categories']:
+            id_to_name[cat['id']] = cat['name']
+
+        for i, annotation in enumerate(segment_annotations):
+            sys.stdout.write("\rGetting annotations for %d/%d segmentation masks" 
+                              %(i, len(segment_annotations)))
+            imid = annotation['image_id']
+            
+            node_word = self.inverse_synonym_dict[id_to_name[annotation['category_id']]]
+            self.imid_to_objects[imid].append(node_word)
+        print("\n")
+
+    def get_annotations_from_captions(self):
+        '''
+        Add objects taken from MSCOCO ground truth captions 
+        '''
+
+        coco_caps = combine_coco_captions(self.coco_path)
+        caption_annotations = coco_caps['annotations']
+
+        for i, annotation in enumerate(caption_annotations):
+            sys.stdout.write('\rGetting annotations for %d/%d ground truth captions' 
+                              %(i, len(coco_caps['annotations'])))
+            imid = annotation['image_id']
+            
+            _, node_words, _, _ = self.caption_to_words(annotation['caption'])
+            # note here is update, so call get_annotations_from_segments first
+            self.imid_to_objects[imid].extend(node_words)
+        print("\n")
+
+
+    def get_annotations(self):
+
+        '''
+        Get annotations from both segmentation and captions.  Need both annotation types for CHAIR metric.
+        '''
+        
+        self.get_annotations_from_segments() 
+        self.get_annotations_from_captions()
+        # deduplicate
+        for imid in self.imid_to_objects:
+            self.imid_to_objects[imid] = set(self.imid_to_objects[imid])
+
+    def compute_chair(self, cap_file, image_id_key, caption_key):
+        '''
+        Given ground truth objects and generated captions, determine which sentences have hallucinated words.
+        '''
+        self._load_generated_captions_into_evaluator(cap_file, image_id_key, caption_key)
+        
+        imid_to_objects = self.imid_to_objects
+        caps = self.caps
+        eval_imids = self.eval_imids
+ 
+        num_caps = 0.
+        num_hallucinated_caps = 0.
+        hallucinated_word_count = 0.
+        coco_word_count = 0.
+        len_caps = 0.
+        
+        # :add:
+        num_recall_gt_objects = 0.
+        num_gt_objects = 0.
+
+        output = {'sentences': []} 
+        
+        for i in tqdm.trange(len(caps)):
+            cap :str = caps[i]
+            imid :int = eval_imids[i]
+    
+            #get all words in the caption, as well as corresponding node word
+            # pos = cap.rfind('.')
+            # cap = cap[:pos+1]
+            words, node_words, idxs, raw_words = self.caption_to_words(cap) 
+ 
+            gt_objects = imid_to_objects[imid]
+            cap_dict = {'image_id': imid, 
+                        'caption': cap,
+                        'mscoco_hallucinated_words': [],
+                        'mscoco_gt_words': list(gt_objects),
+                        'mscoco_generated_words': list(node_words),
+                        'hallucination_idxs': [], 
+                        'words': raw_words 
+                        }
+
+            # :add:
+            cap_dict['metrics'] = {'CHAIRs': 0,
+                                   'CHAIRi': 0,
+                                   'Recall': 0,
+                                   'Len': 0,
+                                   }
+ 
+            #count hallucinated words
+            coco_word_count += len(node_words) 
+            hallucinated = False
+            
+            # add
+            recall_gt_objects = set()
+            for word, node_word, idx in zip(words, node_words, idxs):
+                if node_word not in gt_objects:
+                    hallucinated_word_count += 1 
+                    cap_dict['mscoco_hallucinated_words'].append((word, node_word))
+                    cap_dict['hallucination_idxs'].append(idx)
+                    hallucinated = True
+                else:
+                    recall_gt_objects.add(node_word)
+    
+            #count hallucinated caps
+            num_caps += 1
+            len_caps += len(raw_words)
+            if hallucinated:
+               num_hallucinated_caps += 1
+            
+            # add
+            num_gt_objects += len(gt_objects)
+            num_recall_gt_objects += len(recall_gt_objects)
+    
+            cap_dict['metrics']['CHAIRs'] = int(hallucinated)
+            cap_dict['metrics']['CHAIRi'] = 0.
+            cap_dict['metrics']['Recall'] = 0.
+            cap_dict['metrics']['Len'] = 0.
+
+            
+            if len(words) > 0:
+                cap_dict['metrics']['CHAIRi'] = len(cap_dict['mscoco_hallucinated_words'])/float(len(words))
+            
+            # add
+            if len(gt_objects) > 0:
+                cap_dict['metrics']['Recall'] = len(recall_gt_objects) / len(gt_objects)
+   
+            output['sentences'].append(cap_dict)
+ 
+        chair_s = (num_hallucinated_caps/num_caps)
+        chair_i = (hallucinated_word_count/coco_word_count)
+        # add
+        recall = num_recall_gt_objects / num_gt_objects
+        avg_len = (0.01*len_caps/num_caps)
+    
+        output['overall_metrics'] = {'CHAIRs': chair_s,
+                                     'CHAIRi': chair_i,
+                                     'Recall': recall,
+                                     'Len': avg_len,}
+    
+        return output 
+
+def load_generated_captions(cap_file, image_id_key:str, caption_key:str):
+    #Read in captions        
+    # it should be list of dict
+    ext = os.path.splitext(cap_file)[-1]
+    if ext == '.json':
+        caps = json.load(open(cap_file))
+    elif ext == '.jsonl':
+        caps = [json.loads(s) for s in open(cap_file)]
+    else:
+        raise ValueError(f'Unspported extension {ext} for cap_file: {cap_file}')
+
+    # list of int
+    imids = [obj[image_id_key] for obj in caps]
+    
+    # list of str
+    caps = [obj[caption_key] for obj in caps]
+       
+    return caps, imids
+
+def save_hallucinated_words(cap_file, cap_dict): 
+    with open(cap_file, 'w') as f:
+        json.dump(cap_dict, f, indent=2, ensure_ascii=False)
+
+def print_metrics(hallucination_cap_dict, quiet=False):
+    sentence_metrics = hallucination_cap_dict['overall_metrics']
+    
+    for k, v in sentence_metrics.items():
+        k_str = str(k).ljust(10)
+        v_str = f'{v * 100:.01f}'
+        print(k_str, v_str, sep=': ')
+ 
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    
+    parser.add_argument("--cap_file", type=str, default='',
+                        help="path towards json or jsonl saving image ids and their captions in list of dict.")
+    parser.add_argument("--image_id_key", type=str, default="image_id",
+                        help="in each dict of cap_file, which key stores image id of coco.")
+    parser.add_argument("--caption_key", type=str, default="caption",
+                        help="in each dict of cap_file, which key stores caption of the image.")
+    
+    parser.add_argument("--cache", type=str, default="chair.pkl",
+                        help="pre inited CHAIR evaluator object, for fast loading.")
+    parser.add_argument("--coco_path", type=str, default='coco_annotations',
+                        help="only use for regenerating CHAIR evaluator object, will be ignored if uses cached evaluator.")
+    
+    parser.add_argument("--save_path", type=str, default="",
+                        help="saving CHAIR evaluate and results to json, useful for debugging the caption model.")
+    
+    args = parser.parse_args()
+
+    if args.cache and os.path.exists(args.cache):
+        evaluator = pickle.load(open(args.cache, 'rb'))
+        print(f"loaded evaluator from cache: {args.cache}")
+    else:
+        print(f"cache not setted or not exist yet, building from scratch...")
+        evaluator = CHAIR(args.coco_path)
+        pickle.dump(evaluator, open(args.cache, 'wb'))
+        print(f"cached evaluator to: {args.cache}")
+
+    cap_dict = evaluator.compute_chair(args.cap_file, args.image_id_key, args.caption_key) 
+    
+    print_metrics(cap_dict)
+    
+    if args.save_path:
+        save_hallucinated_words(args.save_path, cap_dict)
+
+
+# CUDA_VISIBLE_DEVICES=5 python chair.py \
+# --cap_file ../POPE-Adv/text_feat/chair-eval/instructblip/ours.jsonl \
+# --image_id_key image_id --caption_key caption \
+# --coco_path /mnt/petrelfs/share_data/wangjiaqi/mllm-data-alg/COCO_2014/ori/annotations_trainval2014/annotations/ \
+# --save_path ../POPE-Adv/text_feat/chair-eval/instructblip/ours_outputs.json

OPERA/chair_eval.py

@@ -0,0 +1,192 @@
+import argparse
+import os
+import random
+
+import numpy as np
+import torch
+import torch.backends.cudnn as cudnn
+from tqdm import tqdm
+
+from torchvision import transforms
+from torchvision.transforms.functional import InterpolationMode
+from torchvision.utils import save_image
+
+from pope_loader import POPEDataSet
+from minigpt4.common.dist_utils import get_rank
+from minigpt4.models import load_preprocess
+
+from minigpt4.common.config import Config
+from minigpt4.common.dist_utils import get_rank
+from minigpt4.common.registry import registry
+
+# imports modules for registration
+from minigpt4.datasets.builders import *
+from minigpt4.models import *
+from minigpt4.processors import *
+from minigpt4.runners import *
+from minigpt4.tasks import *
+
+from PIL import Image
+from torchvision.utils import save_image
+
+import matplotlib.pyplot as plt
+import matplotlib as mpl
+import seaborn
+import json
+
+
+MODEL_EVAL_CONFIG_PATH = {
+    "minigpt4": "eval_configs/minigpt4_eval.yaml",
+    "instructblip": "eval_configs/instructblip_eval.yaml",
+    "lrv_instruct": "eval_configs/lrv_instruct_eval.yaml",
+    "shikra": "eval_configs/shikra_eval.yaml",
+    "llava-1.5": "eval_configs/llava-1.5_eval.yaml",
+}
+
+INSTRUCTION_TEMPLATE = {
+    "minigpt4": "###Human: <Img><ImageHere></Img> <question> ###Assistant:",
+    "instructblip": "<ImageHere><question>",
+    "lrv_instruct": "###Human: <Img><ImageHere></Img> <question> ###Assistant:",
+    "shikra": "USER: <im_start><ImageHere><im_end> <question> ASSISTANT:",
+    "llava-1.5": "USER: <ImageHere> <question> ASSISTANT:"
+}
+
+
+def setup_seeds(config):
+    seed = config.run_cfg.seed + get_rank()
+
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+
+    cudnn.benchmark = False
+    cudnn.deterministic = True
+
+
+
+
+
+parser = argparse.ArgumentParser(description="POPE-Adv evaluation on LVLMs.")
+parser.add_argument("--model", type=str, help="model")
+parser.add_argument("--gpu-id", type=int, help="specify the gpu to load the model.")
+parser.add_argument(
+    "--options",
+    nargs="+",
+    help="override some settings in the used config, the key-value pair "
+    "in xxx=yyy format will be merged into config file (deprecate), "
+    "change to --cfg-options instead.",
+)
+parser.add_argument("--data_path", type=str, default="COCO_2014/val2014/", help="data path")
+parser.add_argument("--batch_size", type=int, default=1, help="batch size")
+parser.add_argument("--num_workers", type=int, default=2, help="num workers")
+
+parser.add_argument("--beam", type=int)
+parser.add_argument("--sample", action='store_true')
+parser.add_argument("--scale_factor", type=float, default=50)
+parser.add_argument("--threshold", type=int, default=15)
+parser.add_argument("--num_attn_candidates", type=int, default=5)
+parser.add_argument("--penalty_weights", type=float, default=1.0)
+args = parser.parse_known_args()[0]
+
+
+
+
+
+
+os.environ["CUDA_VISIBLE_DEVICES"] = str(args.gpu_id)
+args.cfg_path = MODEL_EVAL_CONFIG_PATH[args.model]
+cfg = Config(args)
+setup_seeds(cfg)
+device = torch.device("cuda") if torch.cuda.is_available() else "cpu"
+
+# ========================================
+#             Model Initialization
+# ========================================
+print('Initializing Model')
+
+model_config = cfg.model_cfg
+model_config.device_8bit = args.gpu_id
+model_cls = registry.get_model_class(model_config.arch)
+model = model_cls.from_config(model_config).to(device)
+model.eval()
+processor_cfg = cfg.get_config().preprocess
+processor_cfg.vis_processor.eval.do_normalize = False
+vis_processors, txt_processors = load_preprocess(processor_cfg)
+print(vis_processors["eval"].transform)
+print("Done!")
+
+mean = (0.48145466, 0.4578275, 0.40821073)
+std = (0.26862954, 0.26130258, 0.27577711)
+norm = transforms.Normalize(mean, std)
+
+
+img_files = os.listdir(args.data_path)
+random.shuffle(img_files)
+
+with open(args.data_path + '../annotations_trainval2014/annotations/instances_val2014.json', 'r') as f:
+    lines = f.readlines()
+coco_anns = json.loads(lines[0])
+
+img_dict = {}
+
+categories = coco_anns["categories"]
+category_names = [c["name"] for c in categories]
+category_dict = {int(c["id"]): c["name"] for c in categories}
+
+for img_info in coco_anns["images"]:
+    img_dict[img_info["id"]] = {"name": img_info["file_name"], "anns": []}
+
+for ann_info in coco_anns["annotations"]:
+    img_dict[ann_info["image_id"]]["anns"].append(
+        category_dict[ann_info["category_id"]]
+    )
+
+
+base_dir  = "./log/" + args.model
+if not os.path.exists(base_dir):
+    os.mkdir(base_dir)
+
+
+for img_id in tqdm(range(len(img_files))):
+    if img_id == 500:
+        break
+    img_file = img_files[img_id]
+    img_id = int(img_file.split(".jpg")[0][-6:])
+    img_info = img_dict[img_id]
+    assert img_info["name"] == img_file
+    img_anns = set(img_info["anns"])
+    img_save = {}
+    img_save["image_id"] = img_id
+
+    image_path = args.data_path + img_file
+    raw_image = Image.open(image_path).convert("RGB")
+    image = vis_processors["eval"](raw_image).unsqueeze(0)
+    image = image.to(device)
+    
+    qu = "Please describe this image in detail."
+    template = INSTRUCTION_TEMPLATE[args.model]
+    qu = template.replace("<question>", qu)
+    
+    with torch.inference_mode():
+        with torch.no_grad():
+            out = model.generate(
+                {"image": norm(image), "prompt":qu}, 
+                use_nucleus_sampling=args.sample, 
+                num_beams=args.beam,
+                max_new_tokens=512,
+                output_attentions=True,
+                opera_decoding=True,
+                scale_factor=args.scale_factor,
+                threshold=args.threshold,
+                num_attn_candidates=args.num_attn_candidates,
+                penalty_weights=args.penalty_weights,
+            )
+    img_save["caption"] = out[0]
+
+    # dump metric file
+    with open(os.path.join(base_dir, 'ours-s_{}-t_{}-num_can_{}-p_{}.jsonl'.format(args.scale_factor, args.threshold, args.num_attn_candidates, args.penalty_weights)), "a") as f:
+        json.dump(img_save, f)
+        f.write('\n')
+    
+
+

OPERA/dataset/README_1_STAGE.md

@@ -0,0 +1,96 @@
+## Download the filtered Conceptual Captions, SBU, LAION datasets
+
+### Pre-training datasets download:
+We use the filtered synthetic captions prepared by BLIP. For more details about the dataset, please refer to [BLIP](https://github.com/salesforce/BLIP).
+
+It requires ~2.3T to store LAION and CC3M+CC12M+SBU datasets
+
+Image source | Filtered synthetic caption by ViT-L
+--- | :---:
+CC3M+CC12M+SBU | <a href="https://storage.googleapis.com/sfr-vision-language-research/BLIP/datasets/ccs_synthetic_filtered_large.json">Download</a>
+LAION115M |  <a href="https://storage.googleapis.com/sfr-vision-language-research/BLIP/datasets/laion_synthetic_filtered_large.json">Download</a>
+
+This will download two json files 
+```
+ccs_synthetic_filtered_large.json
+laion_synthetic_filtered_large.json
+```
+
+## prepare the data step-by-step
+
+
+### setup the dataset folder and move the annotation file to the data storage folder
+```
+export MINIGPT4_DATASET=/YOUR/PATH/FOR/LARGE/DATASET/
+mkdir ${MINIGPT4_DATASET}/cc_sbu
+mkdir ${MINIGPT4_DATASET}/laion
+mv ccs_synthetic_filtered_large.json ${MINIGPT4_DATASET}/cc_sbu
+mv laion_synthetic_filtered_large.json ${MINIGPT4_DATASET}/laion
+```
+
+### Convert the scripts to data storate folder
+```
+cp convert_cc_sbu.py ${MINIGPT4_DATASET}/cc_sbu
+cp download_cc_sbu.sh ${MINIGPT4_DATASET}/cc_sbu
+cp convert_laion.py ${MINIGPT4_DATASET}/laion
+cp download_laion.sh ${MINIGPT4_DATASET}/laion
+```
+
+
+### Convert the laion and cc_sbu annotation file format to be img2dataset format
+```
+cd ${MINIGPT4_DATASET}/cc_sbu
+python convert_cc_sbu.py
+
+cd ${MINIGPT4_DATASET}/laion
+python convert_laion.py
+```
+
+### Download the datasets with img2dataset
+```
+cd ${MINIGPT4_DATASET}/cc_sbu
+sh download_cc_sbu.sh
+cd ${MINIGPT4_DATASET}/laion
+sh download_laion.sh
+```
+
+
+The final dataset structure
+
+```
+.
+├── ${MINIGPT4_DATASET}
+│   ├── cc_sbu
+│       ├── convert_cc_sbu.py
+│       ├── download_cc_sbu.sh
+│       ├── ccs_synthetic_filtered_large.json
+│       ├── ccs_synthetic_filtered_large.tsv
+│       └── cc_sbu_dataset
+│           ├── 00000.tar
+│           ├── 00000.parquet
+│           ...
+│   ├── laion
+│       ├── convert_laion.py
+│       ├── download_laion.sh
+│       ├── laion_synthetic_filtered_large.json
+│       ├── laion_synthetic_filtered_large.tsv
+│       └── laion_dataset
+│           ├── 00000.tar
+│           ├── 00000.parquet
+│           ...
+...   
+```
+
+
+## Set up the dataset configuration files
+
+Then, set up the LAION dataset loading path in 
+[here](../minigpt4/configs/datasets/laion/defaults.yaml#L5) at Line 5 as 
+${MINIGPT4_DATASET}/laion/laion_dataset/{00000..10488}.tar
+
+and the Conceptual Captoin and SBU datasets loading path in 
+[here](../minigpt4/configs/datasets/cc_sbu/defaults.yaml#L5) at Line 5 as 
+${MINIGPT4_DATASET}/cc_sbu/cc_sbu_dataset/{00000..01255}.tar
+
+
+

OPERA/dataset/README_2_STAGE.md

@@ -0,0 +1,19 @@
+## Second Stage Data Preparation
+
+Our second stage dataset can be downloaded from 
+[here](https://drive.google.com/file/d/1nJXhoEcy3KTExr17I7BXqY5Y9Lx_-n-9/view?usp=share_link) 
+After extraction, you will get a data follder with the following structure:
+
+```
+cc_sbu_align
+├── filter_cap.json
+└── image
+    ├── 2.jpg
+    ├── 3.jpg
+    ...   
+```
+
+Put the folder to any path you want.
+Then, set up the dataset path in the dataset config file 
+[here](../minigpt4/configs/datasets/cc_sbu/align.yaml#L5) at Line 5.
+

OPERA/dataset/convert_cc_sbu.py

@@ -0,0 +1,20 @@
+import json
+import csv
+
+# specify input and output file paths
+input_file = 'ccs_synthetic_filtered_large.json'
+output_file = 'ccs_synthetic_filtered_large.tsv'
+
+# load JSON data from input file
+with open(input_file, 'r') as f:
+    data = json.load(f)
+
+# extract header and data from JSON
+header = data[0].keys()
+rows = [x.values() for x in data]
+
+# write data to TSV file
+with open(output_file, 'w') as f:
+    writer = csv.writer(f, delimiter='\t')
+    writer.writerow(header)
+    writer.writerows(rows)

OPERA/dataset/convert_laion.py

@@ -0,0 +1,20 @@
+import json
+import csv
+
+# specify input and output file paths
+input_file = 'laion_synthetic_filtered_large.json'
+output_file = 'laion_synthetic_filtered_large.tsv'
+
+# load JSON data from input file
+with open(input_file, 'r') as f:
+    data = json.load(f)
+
+# extract header and data from JSON
+header = data[0].keys()
+rows = [x.values() for x in data]
+
+# write data to TSV file
+with open(output_file, 'w') as f:
+    writer = csv.writer(f, delimiter='\t')
+    writer.writerow(header)
+    writer.writerows(rows)

OPERA/dataset/download_cc_sbu.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+img2dataset --url_list ccs_synthetic_filtered_large.tsv --input_format "tsv"\
+         --url_col "url" --caption_col "caption" --output_format webdataset\
+           --output_folder cc_sbu_dataset --processes_count 16 --thread_count 128 --image_size 256 \
+             --enable_wandb True

OPERA/dataset/download_laion.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+img2dataset --url_list laion_synthetic_filtered_large.tsv --input_format "tsv"\
+         --url_col "url" --caption_col "caption" --output_format webdataset\
+           --output_folder laion_dataset --processes_count 16 --thread_count 128 --image_size 256 \
+             --enable_wandb True

OPERA/environment.yml

@@ -0,0 +1,317 @@
+name: opera
+channels:
+  - pytorch
+  - defaults
+dependencies:
+  - _libgcc_mutex=0.1
+  - _openmp_mutex=5.1
+  - blas=1.0
+  - brotlipy=0.7.0
+  - bzip2=1.0.8
+  - ca-certificates=2023.01.10
+  - certifi=2022.12.7
+  - cffi=1.15.1
+  - charset-normalizer=2.0.4
+  - cryptography=39.0.1
+  - cudatoolkit=11.3.1
+  - ffmpeg=4.3
+  - freetype=2.12.1
+  - giflib=5.2.1
+  - gmp=6.2.1
+  - gnutls=3.6.15
+  - idna=3.4
+  - intel-openmp=2023.1.0
+  - jpeg=9e
+  - lame=3.100
+  - lcms2=2.12
+  - ld_impl_linux-64=2.38
+  - lerc=3.0
+  - libdeflate=1.17
+  - libffi=3.4.2
+  - libgcc-ng=11.2.0
+  - libgomp=11.2.0
+  - libiconv=1.16
+  - libidn2=2.3.2
+  - libpng=1.6.39
+  - libstdcxx-ng=11.2.0
+  - libtasn1=4.19.0
+  - libtiff=4.5.0
+  - libunistring=0.9.10
+  - libwebp=1.2.4
+  - libwebp-base=1.2.4
+  - lz4-c=1.9.4
+  - mkl=2023.1.0
+  - mkl-service=2.4.0
+  - mkl_fft=1.3.6
+  - mkl_random=1.2.2
+  - ncurses=6.4
+  - nettle=3.7.3
+  - numpy=1.24.3
+  - numpy-base=1.24.3
+  - openh264=2.1.1
+  - openssl=1.1.1t
+  - pillow=9.4.0
+  - pip=23.0.1
+  - pycparser=2.21
+  - pyopenssl=23.0.0
+  - pysocks=1.7.1
+  - python=3.9.16
+  - pytorch-mutex=1.0
+  - readline=8.2
+  - requests=2.29.0
+  - setuptools=66.0.0
+  - sqlite=3.41.2
+  - tbb=2021.8.0
+  - tk=8.6.12
+  - torchaudio=0.12.1
+  - typing_extensions=4.5.0
+  - urllib3=1.26.15
+  - wheel=0.38.4
+  - xz=5.4.2
+  - zlib=1.2.13
+  - zstd=1.5.5
+  - pip:
+      - accelerate==0.19.0
+      - aiofiles==23.1.0
+      - aiohttp==3.8.4
+      - aiosignal==1.3.1
+      - altair==4.2.2
+      - antlr4-python3-runtime==4.9.3
+      - anyio==3.6.2
+      - argon2-cffi==21.3.0
+      - argon2-cffi-bindings==21.2.0
+      - arrow==1.2.3
+      - asttokens==2.2.1
+      - async-lru==2.0.2
+      - async-timeout==4.0.2
+      - attrs==23.1.0
+      - babel==2.12.1
+      - backcall==0.2.0
+      - beautifulsoup4==4.12.2
+      - bertviz==1.4.0
+      - bitsandbytes==0.39.0
+      - bleach==6.0.0
+      - blinker==1.6.2
+      - blis==0.7.9
+      - boto3==1.28.63
+      - botocore==1.31.63
+      - braceexpand==0.1.7
+      - cachetools==5.3.0
+      - catalogue==2.0.8
+      - cfgv==3.3.1
+      - click==8.1.3
+      - cmake==3.26.3
+      - comm==0.1.3
+      - confection==0.0.4
+      - contexttimer==0.3.3
+      - contourpy==1.0.7
+      - curated-tokenizers==0.0.8
+      - curated-transformers==0.1.1
+      - cycler==0.11.0
+      - cymem==2.0.7
+      - debugpy==1.6.7
+      - decorator==5.1.1
+      - decord==0.6.0
+      - defusedxml==0.7.1
+      - distlib==0.3.6
+      - distro==1.8.0
+      - einops==0.6.1
+      - entrypoints==0.4
+      - et-xmlfile==1.1.0
+      - executing==1.2.0
+      - fairscale==0.4.4
+      - fastapi==0.95.2
+      - fastjsonschema==2.16.3
+      - ffmpy==0.3.0
+      - filelock==3.12.0
+      - fonttools==4.39.4
+      - fqdn==1.5.1
+      - frozenlist==1.3.3
+      - fsspec==2023.5.0
+      - ftfy==6.1.1
+      - gdown==4.7.1
+      - gitdb==4.0.10
+      - gitpython==3.1.31
+      - gradio==3.31.0
+      - gradio-client==0.2.5
+      - h11==0.14.0
+      - httpcore==0.17.1
+      - httpx==0.24.1
+      - huggingface-hub==0.14.1
+      - identify==2.5.24
+      - imageio==2.28.1
+      - importlib-metadata==6.6.0
+      - importlib-resources==5.12.0
+      - iopath==0.1.10
+      - ipykernel==6.23.1
+      - ipython==8.13.2
+      - ipython-genutils==0.2.0
+      - ipywidgets==8.0.6
+      - isoduration==20.11.0
+      - jedi==0.18.2
+      - jinja2==3.1.2
+      - jmespath==1.0.1
+      - joblib==1.2.0
+      - json5==0.9.14
+      - jsonpointer==2.3
+      - jsonschema==4.17.3
+      - jupyter==1.0.0
+      - jupyter-client==8.2.0
+      - jupyter-console==6.6.3
+      - jupyter-core==5.3.0
+      - jupyter-events==0.6.3
+      - jupyter-lsp==2.1.0
+      - jupyter-server==2.5.0
+      - jupyter-server-terminals==0.4.4
+      - jupyterlab==4.0.7
+      - jupyterlab-pygments==0.2.2
+      - jupyterlab-server==2.22.1
+      - jupyterlab-widgets==3.0.7
+      - kaggle==1.5.13
+      - kiwisolver==1.4.4
+      - langcodes==3.3.0
+      - lazy-loader==0.2
+      - linkify-it-py==2.0.2
+      - lit==16.0.5
+      - markdown-it-py==2.2.0
+      - markupsafe==2.1.2
+      - matplotlib==3.7.1
+      - matplotlib-inline==0.1.6
+      - mdit-py-plugins==0.3.3
+      - mdurl==0.1.2
+      - mistune==2.0.5
+      - mpmath==1.3.0
+      - multidict==6.0.4
+      - murmurhash==1.0.9
+      - nbclassic==1.0.0
+      - nbclient==0.7.4
+      - nbconvert==7.4.0
+      - nbformat==5.8.0
+      - nest-asyncio==1.5.6
+      - networkx==3.1
+      - nltk==3.8.1
+      - nodeenv==1.8.0
+      - notebook==7.0.6
+      - notebook-shim==0.2.3
+      - nvidia-cublas-cu11==11.10.3.66
+      - nvidia-cuda-cupti-cu11==11.7.101
+      - nvidia-cuda-nvrtc-cu11==11.7.99
+      - nvidia-cuda-runtime-cu11==11.7.99
+      - nvidia-cudnn-cu11==8.5.0.96
+      - nvidia-cufft-cu11==10.9.0.58
+      - nvidia-curand-cu11==10.2.10.91
+      - nvidia-cusolver-cu11==11.4.0.1
+      - nvidia-cusparse-cu11==11.7.4.91
+      - nvidia-nccl-cu11==2.14.3
+      - nvidia-nvtx-cu11==11.7.91
+      - omegaconf==2.3.0
+      - openai==0.28.1
+      - opencv-python==4.7.0.72
+      - opencv-python-headless==4.5.5.64
+      - opendatasets==0.1.22
+      - openpyxl==3.1.2
+      - orjson==3.8.12
+      - packaging==23.1
+      - pandas==2.0.1
+      - pandocfilters==1.5.0
+      - parso==0.8.3
+      - pathy==0.10.1
+      - pexpect==4.8.0
+      - pickleshare==0.7.5
+      - platformdirs==3.5.1
+      - plotly==5.14.1
+      - portalocker==2.7.0
+      - pre-commit==3.3.2
+      - preshed==3.0.8
+      - prometheus-client==0.16.0
+      - prompt-toolkit==3.0.38
+      - protobuf==3.20.3
+      - psutil==5.9.5
+      - ptyprocess==0.7.0
+      - pure-eval==0.2.2
+      - pyarrow==12.0.0
+      - pycocoevalcap==1.2
+      - pycocotools==2.0.6
+      - pydantic==1.10.7
+      - pydeck==0.8.1b0
+      - pydub==0.25.1
+      - pygments==2.15.1
+      - pympler==1.0.1
+      - pyparsing==3.0.9
+      - pyrsistent==0.19.3
+      - python-dateutil==2.8.2
+      - python-json-logger==2.0.7
+      - python-magic==0.4.27
+      - python-multipart==0.0.6
+      - python-slugify==8.0.1
+      - pytz==2023.3
+      - pywavelets==1.4.1
+      - pyyaml==6.0
+      - pyzmq==25.0.2
+      - qtconsole==5.4.3
+      - qtpy==2.3.1
+      - regex==2023.5.5
+      - rfc3339-validator==0.1.4
+      - rfc3986-validator==0.1.1
+      - rich==13.3.5
+      - s3transfer==0.7.0
+      - safetensors==0.3.1
+      - scikit-image==0.20.0
+      - scikit-learn==1.2.2
+      - scipy==1.9.1
+      - seaborn==0.13.0
+      - semantic-version==2.10.0
+      - send2trash==1.8.2
+      - sentencepiece==0.1.99
+      - six==1.16.0
+      - sklearn==0.0.post5
+      - smart-open==6.3.0
+      - smmap==5.0.0
+      - sniffio==1.3.0
+      - soupsieve==2.4.1
+      - spacy==3.7.0.dev0
+      - spacy-curated-transformers==0.2.0
+      - spacy-legacy==3.0.12
+      - spacy-loggers==1.0.4
+      - srsly==2.4.6
+      - stack-data==0.6.2
+      - starlette==0.27.0
+      - streamlit==1.22.0
+      - sympy==1.12
+      - tenacity==8.2.2
+      - terminado==0.17.1
+      - text-unidecode==1.3
+      - thinc==8.1.10
+      - threadpoolctl==3.1.0
+      - tifffile==2023.4.12
+      - timm==0.4.12
+      - tinycss2==1.2.1
+      - tokenizers==0.13.3
+      - toml==0.10.2
+      - tomli==2.0.1
+      - toolz==0.12.0
+      - torch==2.0.1
+      - torchvision==0.15.2
+      - tornado==6.3.2
+      - tqdm==4.65.0
+      - traitlets==5.9.0
+      - triton==2.0.0
+      - typer==0.7.0
+      - tzdata==2023.3
+      - tzlocal==5.0.1
+      - uc-micro-py==1.0.2
+      - uri-template==1.2.0
+      - uvicorn==0.22.0
+      - validators==0.20.0
+      - virtualenv==20.23.0
+      - wasabi==1.1.1
+      - watchdog==3.0.0
+      - wcwidth==0.2.6
+      - webcolors==1.13
+      - webdataset==0.2.48
+      - webencodings==0.5.1
+      - websocket-client==1.5.1
+      - websockets==11.0.3
+      - widgetsnbextension==4.0.7
+      - yarl==1.9.2
+      - zipp==3.15.0

OPERA/eval_configs/instructblip_eval.yaml

@@ -0,0 +1,23 @@
+model:
+  arch: blip2_vicuna_instruct
+  model_type: vicuna7b
+  max_txt_len: 128
+  # end_sym: "###"
+  # low_resource: True
+  # prompt_template: '###Human: {} ###Assistant: '
+  # ckpt: '/mnt/petrelfs/share_data/huangqidong/lvlm/minigpt4/prerained_minigpt4_7b.pth'
+
+
+datasets:
+  cc_sbu_align:
+    vis_processor:
+      train:
+        name: "blip2_image_eval"
+        image_size: 224
+    text_processor:
+      train:
+        name: "blip_caption"
+
+run:
+  task: image_text_pretrain
+  seed: 42

OPERA/eval_configs/llava-1.5_eval.yaml

@@ -0,0 +1,29 @@
+model:
+  arch: llava-1.5
+  model_type: vicuna7b
+  freeze_vit: True
+  freeze_backbone: True
+  tune_mm_mlp_adapter: False
+  freeze_mm_mlp_adapter: True
+  max_txt_len: 160
+  end_sym: "###"
+  low_resource: False
+  # prompt_path: "prompts/alignment.txt"
+  prompt_template: 'USER: {} ASSISTANT: '
+  system_message: "A chat between a curious user and an artificial intelligence assistant. The assistant gives helpful, detailed, and polite answers to the user's questions." 
+  merged_ckpt: "/mnt/petrelfs/share_data/huangqidong/lvlm/llava-v1.5-7b/"
+
+  
+datasets:
+  cc_sbu_align:
+    vis_processor:
+      train:
+        name: "clip_image_eval"
+        proc_type: "openai/clip-vit-large-patch14-336"
+    text_processor:
+      train:
+        name: "blip_caption"
+
+run:
+  task: image_text_pretrain
+  seed: 42

OPERA/eval_configs/minigpt4_eval.yaml

@@ -0,0 +1,23 @@
+model:
+  arch: mini_gpt4
+  model_type: pretrain_vicuna0
+  max_txt_len: 160
+  end_sym: "###"
+  low_resource: False
+  prompt_template: '###Human: {} ###Assistant: '
+  ckpt: '/mnt/petrelfs/share_data/huangqidong/lvlm/minigpt4/prerained_minigpt4_7b.pth'
+
+
+datasets:
+  cc_sbu_align:
+    vis_processor:
+      train:
+        name: "blip2_image_eval"
+        image_size: 224
+    text_processor:
+      train:
+        name: "blip_caption"
+
+run:
+  task: image_text_pretrain
+  seed: 42

OPERA/eval_configs/minigpt4_llama2_eval.yaml

@@ -0,0 +1,22 @@
+model:
+  arch: mini_gpt4
+  model_type: pretrain_llama2
+  max_txt_len: 160
+  end_sym: "</s>"
+  low_resource: False
+  prompt_template: '[INST] {} [/INST] '
+  ckpt: '/path/to/checkpoint/'
+
+
+datasets:
+  cc_sbu_align:
+    vis_processor:
+      train:
+        name: "blip2_image_eval"
+        image_size: 224
+    text_processor:
+      train:
+        name: "blip_caption"
+
+run:
+  task: image_text_pretrain

OPERA/eval_configs/shikra_eval.yaml

@@ -0,0 +1,29 @@
+model:
+  arch: shikra
+  model_type: vicuna7b
+  freeze_vit: True
+  freeze_backbone: True
+  tune_mm_mlp_adapter: False
+  freeze_mm_mlp_adapter: True
+  max_txt_len: 160
+  end_sym: "###"
+  low_resource: False
+  # prompt_path: "prompts/alignment.txt"
+  prompt_template: 'USER: {} ASSISTANT: '
+  system_message: "A chat between a curious user and an artificial intelligence assistant. The assistant gives helpful, detailed, and polite answers to the user's questions." 
+  merged_ckpt: '/mnt/petrelfs/share_data/zhaohanqing/merged_shikra_7B/'
+
+  
+datasets:
+  cc_sbu_align:
+    vis_processor:
+      train:
+        name: "clip_image_eval"
+        proc_type: "openai/clip-vit-large-patch14"
+    text_processor:
+      train:
+        name: "blip_caption"
+
+run:
+  task: image_text_pretrain
+  seed: 42

OPERA/gpt4v_eval.py

@@ -0,0 +1,306 @@
+import base64
+import requests
+from PIL import Image
+from io import BytesIO
+
+
+
+import argparse
+import os
+import random
+
+import numpy as np
+import torch
+import torch.backends.cudnn as cudnn
+from tqdm import tqdm
+
+from torchvision import transforms
+from torchvision.transforms.functional import InterpolationMode
+from torchvision.utils import save_image
+
+from pope_loader import POPEDataSet
+from minigpt4.common.dist_utils import get_rank
+from minigpt4.models import load_preprocess
+
+from minigpt4.common.config import Config
+from minigpt4.common.dist_utils import get_rank
+from minigpt4.common.registry import registry
+
+# imports modules for registration
+from minigpt4.datasets.builders import *
+from minigpt4.models import *
+from minigpt4.processors import *
+from minigpt4.runners import *
+from minigpt4.tasks import *
+
+# from PIL import Image
+from torchvision.utils import save_image
+
+import matplotlib.pyplot as plt
+import matplotlib as mpl
+import seaborn
+import json
+
+
+MODEL_EVAL_CONFIG_PATH = {
+    "minigpt4": "eval_configs/minigpt4_eval.yaml",
+    "instructblip": "eval_configs/instructblip_eval.yaml",
+    "lrv_instruct": "eval_configs/lrv_instruct_eval.yaml",
+    "shikra": "eval_configs/shikra_eval.yaml",
+    "llava-1.5": "eval_configs/llava-1.5_eval.yaml",
+}
+
+INSTRUCTION_TEMPLATE = {
+    "minigpt4": "###Human: <Img><ImageHere></Img> <question> ###Assistant:",
+    "instructblip": "<ImageHere><question>",
+    "lrv_instruct": "###Human: <Img><ImageHere></Img> <question> ###Assistant:",
+    "shikra": "USER: <im_start><ImageHere><im_end> <question> ASSISTANT:",
+    "llava-1.5": "USER: <ImageHere> <question> ASSISTANT:"
+}
+
+
+
+
+GPT_JUDGE_PROMPT = '''
+You are required to score the performance of two AI assistants in describing a given image. You should pay extra attention to the hallucination, which refers to the part of descriptions that are inconsistent with the image content, such as claiming the existence of something not present in the image or describing incorrectly in terms of the counts, positions, or colors of objects in the image. Please rate the responses of the assistants on a scale of 1 to 10, where a higher score indicates better performance, according to the following criteria:
+1: Accuracy: whether the response is accurate with respect to the image content. Responses with fewer hallucinationsshould be given higher scores.
+2: Detailedness: whether the response is rich in necessary details. Note that hallucinated descriptions should not countas necessary details.
+Please output the scores for each criterion, containing only two values indicating the scores for Assistant 1 and 2, respectively. The two scores are separated by a space. Following the scores, please provide an explanation of your evaluation, avoiding any potential bias and ensuring that the order in which the responses were presented does not affect your judgment.
+
+[Assistant 1]
+{}
+[End of Assistant 1]
+
+[Assistant 2]
+{}
+[End of Assistant 2]
+
+Output format:
+Accuracy: <Scores of the two answers>
+Reason:
+
+Detailedness: <Scores of the two answers>
+Reason: 
+'''
+
+
+# OpenAI API Key
+API_KEY = "YOUR_API_KEY"
+
+
+
+def setup_seeds(config):
+    seed = config.run_cfg.seed + get_rank()
+
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+
+    cudnn.benchmark = False
+    cudnn.deterministic = True
+
+
+
+
+def call_api(prompt, image_path):
+    # Function to encode the image
+    def encode_image(image_path):
+        with open(image_path, "rb") as image_file:
+            return base64.b64encode(image_file.read()).decode('utf-8')
+
+    # Getting the base64 string
+    base64_image = encode_image(image_path)
+
+    headers = {
+    "Content-Type": "application/json",
+    "Authorization": f"Bearer {API_KEY}"
+    }
+
+    payload = {
+    "model": "gpt-4-vision-preview",
+    "messages": [
+        {
+        "role": "user",
+        "content": [
+            {
+            "type": "text",
+            "text": prompt
+            },
+            {
+            "type": "image_url",
+            "image_url": {
+                "url": f"data:image/jpeg;base64,{base64_image}"
+            }
+            }
+        ]
+        }
+    ],
+    "max_tokens": 300
+    }
+
+    response = requests.post("https://api.openai.com/v1/chat/completions", headers=headers, json=payload)
+
+    print(response.json().keys())
+    return response.json()
+
+
+def get_gpt4v_answer(prompt, image_path):
+    while 1:
+        try:
+            res = call_api(prompt, image_path)
+            if "choices" in res.keys():
+                return res["choices"][0]["message"]["content"]
+            else:
+                assert False
+        except Exception as e:
+            print("retry")
+            # pass
+    # return call_api(prompt, image_path)
+
+
+parser = argparse.ArgumentParser(description="POPE-Adv evaluation on LVLMs.")
+parser.add_argument("--model", type=str, help="model")
+parser.add_argument("--gpu-id", type=int, help="specify the gpu to load the model.")
+parser.add_argument(
+    "--options",
+    nargs="+",
+    help="override some settings in the used config, the key-value pair "
+    "in xxx=yyy format will be merged into config file (deprecate), "
+    "change to --cfg-options instead.",
+)
+parser.add_argument("--data_path", type=str, default="COCO_2014/val2014/", help="data path")
+parser.add_argument("--batch_size", type=int, help="batch size")
+parser.add_argument("--num_workers", type=int, default=2, help="num workers")
+
+parser.add_argument("--scale_factor", type=float, default=50)
+parser.add_argument("--threshold", type=int, default=15)
+parser.add_argument("--num_attn_candidates", type=int, default=5)
+parser.add_argument("--penalty_weights", type=float, default=1.0)
+args = parser.parse_known_args()[0]
+
+
+
+os.environ["CUDA_VISIBLE_DEVICES"] = str(args.gpu_id)
+args.cfg_path = MODEL_EVAL_CONFIG_PATH[args.model]
+cfg = Config(args)
+setup_seeds(cfg)
+device = torch.device("cuda") if torch.cuda.is_available() else "cpu"
+
+# ========================================
+#             Model Initialization
+# ========================================
+print('Initializing Model')
+
+model_config = cfg.model_cfg
+model_config.device_8bit = args.gpu_id
+model_cls = registry.get_model_class(model_config.arch)
+model = model_cls.from_config(model_config).to(device)
+model.eval()
+processor_cfg = cfg.get_config().preprocess
+processor_cfg.vis_processor.eval.do_normalize = False
+vis_processors, txt_processors = load_preprocess(processor_cfg)
+print(vis_processors["eval"].transform)
+print("Done!")
+
+mean = (0.48145466, 0.4578275, 0.40821073)
+std = (0.26862954, 0.26130258, 0.27577711)
+norm = transforms.Normalize(mean, std)
+
+
+
+
+img_files = os.listdir(args.data_path)
+random.shuffle(img_files)
+
+base_path = "log/gpt4v-eval"
+if not os.path.exists(base_path + f"/{args.model}"):
+    os.mkdir(base_path + f"/{args.model}")
+
+gpt_answer_records = {}
+assistant_answer_records = {}
+avg_hal_score_1 = 0
+avg_hal_score_2 = 0
+avg_det_score_1 = 0
+avg_det_score_2 = 0
+num_count = 0
+
+for idx in range(50):
+    img = img_files[idx]
+    image_path = args.data_path + img
+    raw_image = Image.open(image_path)
+    raw_image = raw_image.convert("RGB")
+    image = vis_processors["eval"](raw_image).unsqueeze(0)
+    image = image.to(device)
+    qu = "Please describe this image in detail."
+
+    template = INSTRUCTION_TEMPLATE[args.model]
+    qu = template.replace("<question>", qu)
+    assistant_answer_records[str(img)] = {}
+
+    with torch.inference_mode():
+        with torch.no_grad():
+            out = model.generate(
+                {"image": norm(image), "prompt":qu}, 
+                use_nucleus_sampling=False, 
+                num_beams=5,
+                max_new_tokens=512,
+            )
+    model_response_1 = out[0]
+    assistant_answer_records[str(img)]["assistant_1"] = model_response_1
+    print("Beam-5 output:") 
+    print(model_response_1)
+
+
+    with torch.inference_mode():
+        with torch.no_grad():
+            out = model.generate(
+                {"image": norm(image), "prompt":qu}, 
+                use_nucleus_sampling=False, 
+                num_beams=5,
+                max_new_tokens=512,
+                output_attentions=True,
+                opera_decoding=True,
+                scale_factor=args.scale_factor,
+                threshold=args.threshold,
+                num_attn_candidates=args.num_attn_candidates,
+                penalty_weights=args.penalty_weights,
+            )
+    model_response_2 = out[0]
+    assistant_answer_records[str(img)]["assistant_2"] = model_response_2
+    print("OPERA output:")
+    print(model_response_2)
+
+    # gpt-4v eval
+    prompt = GPT_JUDGE_PROMPT.format(model_response_1, model_response_2)
+
+    gpt_answer = get_gpt4v_answer(prompt, image_path)
+    print(gpt_answer)
+    gpt_answer_records[str(img)] = gpt_answer
+    print(gpt_answer.split("Accuracy: ")[-1].split("\n")[0].split(" "))
+    print(len(gpt_answer.split("Accuracy: ")[-1].split("\n")[0].split(" ")))
+    try:
+        hal_score_1, hal_score_2 = gpt_answer.split("Accuracy: ")[-1].split("\n")[0].split(" ")
+        det_score_1, det_score_2 = gpt_answer.split("Detailedness: ")[-1].split("\n")[0].split(" ")
+    except:
+        continue
+    avg_hal_score_1 += int(hal_score_1)
+    avg_hal_score_2 += int(hal_score_2)
+    avg_det_score_1 += int(det_score_1)
+    avg_det_score_2 += int(det_score_2)
+    num_count += 1
+    print("=========================================")
+
+    # dump metric file
+    with open(os.path.join(base_path + f"/{args.model}", 'answers.json'), "w") as f:
+        json.dump(assistant_answer_records, f)
+
+    # dump metric file
+    with open(os.path.join(base_path + f"/{args.model}", 'records.json'), "w") as f:
+        json.dump(gpt_answer_records, f)
+
+avg_score = float(avg_hal_score_1) / num_count
+avg_score = float(avg_hal_score_2) / num_count
+avg_score = float(avg_det_score_1) / num_count
+avg_score = float(avg_det_score_2) / num_count
+print(f"The avg hal score for Assistant 1 and Assistent 2: {avg_hal_score_1}; {avg_hal_score_2}")
+print(f"The avg det score for Assistant 1 and Assistent 2: {avg_det_score_1}; {avg_det_score_2}")

OPERA/minigpt4/__init__.py

@@ -0,0 +1,31 @@
+"""
+ Copyright (c) 2022, salesforce.com, inc.
+ All rights reserved.
+ SPDX-License-Identifier: BSD-3-Clause
+ For full license text, see the LICENSE_Lavis file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+"""
+
+import os
+import sys
+
+from omegaconf import OmegaConf
+
+from minigpt4.common.registry import registry
+
+from minigpt4.datasets.builders import *
+from minigpt4.models import *
+from minigpt4.processors import *
+from minigpt4.tasks import *
+
+
+root_dir = os.path.dirname(os.path.abspath(__file__))
+default_cfg = OmegaConf.load(os.path.join(root_dir, "configs/default.yaml"))
+
+registry.register_path("library_root", root_dir)
+repo_root = os.path.join(root_dir, "..")
+registry.register_path("repo_root", repo_root)
+cache_root = os.path.join(repo_root, default_cfg.env.cache_root)
+registry.register_path("cache_root", cache_root)
+
+registry.register("MAX_INT", sys.maxsize)
+registry.register("SPLIT_NAMES", ["train", "val", "test"])

OPERA/minigpt4/common/config.py

@@ -0,0 +1,468 @@
+"""
+ Copyright (c) 2022, salesforce.com, inc.
+ All rights reserved.
+ SPDX-License-Identifier: BSD-3-Clause
+ For full license text, see the LICENSE_Lavis file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+"""
+
+import logging
+import json
+from typing import Dict
+
+from omegaconf import OmegaConf
+from minigpt4.common.registry import registry
+
+
+class Config:
+    def __init__(self, args):
+        self.config = {}
+
+        self.args = args
+
+        # Register the config and configuration for setup
+        registry.register("configuration", self)
+
+        user_config = self._build_opt_list(self.args.options)
+
+        config = OmegaConf.load(self.args.cfg_path)
+
+        runner_config = self.build_runner_config(config)
+        model_config = self.build_model_config(config, **user_config)
+        dataset_config = self.build_dataset_config(config)
+
+        # Validate the user-provided runner configuration
+        # model and dataset configuration are supposed to be validated by the respective classes
+        # [TODO] validate the model/dataset configuration
+        # self._validate_runner_config(runner_config)
+
+        # Override the default configuration with user options.
+        self.config = OmegaConf.merge(
+            runner_config, model_config, dataset_config, user_config
+        )
+
+    def _validate_runner_config(self, runner_config):
+        """
+        This method validates the configuration, such that
+            1) all the user specified options are valid;
+            2) no type mismatches between the user specified options and the config.
+        """
+        runner_config_validator = create_runner_config_validator()
+        runner_config_validator.validate(runner_config)
+
+    def _build_opt_list(self, opts):
+        opts_dot_list = self._convert_to_dot_list(opts)
+        return OmegaConf.from_dotlist(opts_dot_list)
+
+    @staticmethod
+    def build_model_config(config, **kwargs):
+        model = config.get("model", None)
+        assert model is not None, "Missing model configuration file."
+
+        model_cls = registry.get_model_class(model.arch)
+        assert model_cls is not None, f"Model '{model.arch}' has not been registered."
+
+        model_type = kwargs.get("model.model_type", None)
+        if not model_type:
+            model_type = model.get("model_type", None)
+        # else use the model type selected by user.
+
+        assert model_type is not None, "Missing model_type."
+
+        model_config_path = model_cls.default_config_path(model_type=model_type)
+
+        model_config = OmegaConf.create()
+        # hierarchy override, customized config > default config
+        model_config = OmegaConf.merge(
+            model_config,
+            OmegaConf.load(model_config_path),
+            {"model": config["model"]},
+        )
+
+        return model_config
+
+    @staticmethod
+    def build_runner_config(config):
+        return {"run": config.run}
+
+    @staticmethod
+    def build_dataset_config(config):
+        datasets = config.get("datasets", None)
+        if datasets is None:
+            raise KeyError(
+                "Expecting 'datasets' as the root key for dataset configuration."
+            )
+
+        dataset_config = OmegaConf.create()
+
+        for dataset_name in datasets:
+            builder_cls = registry.get_builder_class(dataset_name)
+
+            dataset_config_type = datasets[dataset_name].get("type", "default")
+            dataset_config_path = builder_cls.default_config_path(
+                type=dataset_config_type
+            )
+
+            # hierarchy override, customized config > default config
+            dataset_config = OmegaConf.merge(
+                dataset_config,
+                OmegaConf.load(dataset_config_path),
+                {"datasets": {dataset_name: config["datasets"][dataset_name]}},
+            )
+
+        return dataset_config
+
+    def _convert_to_dot_list(self, opts):
+        if opts is None:
+            opts = []
+
+        if len(opts) == 0:
+            return opts
+
+        has_equal = opts[0].find("=") != -1
+
+        if has_equal:
+            return opts
+
+        return [(opt + "=" + value) for opt, value in zip(opts[0::2], opts[1::2])]
+
+    def get_config(self):
+        return self.config
+
+    @property
+    def run_cfg(self):
+        return self.config.run
+
+    @property
+    def datasets_cfg(self):
+        return self.config.datasets
+
+    @property
+    def model_cfg(self):
+        return self.config.model
+
+    def pretty_print(self):
+        logging.info("\n=====  Running Parameters    =====")
+        logging.info(self._convert_node_to_json(self.config.run))
+
+        logging.info("\n======  Dataset Attributes  ======")
+        datasets = self.config.datasets
+
+        for dataset in datasets:
+            if dataset in self.config.datasets:
+                logging.info(f"\n======== {dataset} =======")
+                dataset_config = self.config.datasets[dataset]
+                logging.info(self._convert_node_to_json(dataset_config))
+            else:
+                logging.warning(f"No dataset named '{dataset}' in config. Skipping")
+
+        logging.info(f"\n======  Model Attributes  ======")
+        logging.info(self._convert_node_to_json(self.config.model))
+
+    def _convert_node_to_json(self, node):
+        container = OmegaConf.to_container(node, resolve=True)
+        return json.dumps(container, indent=4, sort_keys=True)
+
+    def to_dict(self):
+        return OmegaConf.to_container(self.config)
+
+
+def node_to_dict(node):
+    return OmegaConf.to_container(node)
+
+
+class ConfigValidator:
+    """
+    This is a preliminary implementation to centralize and validate the configuration.
+    May be altered in the future.
+
+    A helper class to validate configurations from yaml file.
+
+    This serves the following purposes:
+        1. Ensure all the options in the yaml are defined, raise error if not.
+        2. when type mismatches are found, the validator will raise an error.
+        3. a central place to store and display helpful messages for supported configurations.
+
+    """
+
+    class _Argument:
+        def __init__(self, name, choices=None, type=None, help=None):
+            self.name = name
+            self.val = None
+            self.choices = choices
+            self.type = type
+            self.help = help
+
+        def __str__(self):
+            s = f"{self.name}={self.val}"
+            if self.type is not None:
+                s += f", ({self.type})"
+            if self.choices is not None:
+                s += f", choices: {self.choices}"
+            if self.help is not None:
+                s += f", ({self.help})"
+            return s
+
+    def __init__(self, description):
+        self.description = description
+
+        self.arguments = dict()
+
+        self.parsed_args = None
+
+    def __getitem__(self, key):
+        assert self.parsed_args is not None, "No arguments parsed yet."
+
+        return self.parsed_args[key]
+
+    def __str__(self) -> str:
+        return self.format_help()
+
+    def add_argument(self, *args, **kwargs):
+        """
+        Assume the first argument is the name of the argument.
+        """
+        self.arguments[args[0]] = self._Argument(*args, **kwargs)
+
+    def validate(self, config=None):
+        """
+        Convert yaml config (dict-like) to list, required by argparse.
+        """
+        for k, v in config.items():
+            assert (
+                k in self.arguments
+            ), f"""{k} is not a valid argument. Support arguments are {self.format_arguments()}."""
+
+            if self.arguments[k].type is not None:
+                try:
+                    self.arguments[k].val = self.arguments[k].type(v)
+                except ValueError:
+                    raise ValueError(f"{k} is not a valid {self.arguments[k].type}.")
+
+            if self.arguments[k].choices is not None:
+                assert (
+                    v in self.arguments[k].choices
+                ), f"""{k} must be one of {self.arguments[k].choices}."""
+
+        return config
+
+    def format_arguments(self):
+        return str([f"{k}" for k in sorted(self.arguments.keys())])
+
+    def format_help(self):
+        # description + key-value pair string for each argument
+        help_msg = str(self.description)
+        return help_msg + ", available arguments: " + self.format_arguments()
+
+    def print_help(self):
+        # display help message
+        print(self.format_help())
+
+
+def create_runner_config_validator():
+    validator = ConfigValidator(description="Runner configurations")
+
+    validator.add_argument(
+        "runner",
+        type=str,
+        choices=["runner_base", "runner_iter"],
+        help="""Runner to use. The "runner_base" uses epoch-based training while iter-based
+            runner runs based on iters. Default: runner_base""",
+    )
+    # add argumetns for training dataset ratios
+    validator.add_argument(
+        "train_dataset_ratios",
+        type=Dict[str, float],
+        help="""Ratios of training dataset. This is used in iteration-based runner.
+        Do not support for epoch-based runner because how to define an epoch becomes tricky.
+        Default: None""",
+    )
+    validator.add_argument(
+        "max_iters",
+        type=float,
+        help="Maximum number of iterations to run.",
+    )
+    validator.add_argument(
+        "max_epoch",
+        type=int,
+        help="Maximum number of epochs to run.",
+    )
+    # add arguments for iters_per_inner_epoch
+    validator.add_argument(
+        "iters_per_inner_epoch",
+        type=float,
+        help="Number of iterations per inner epoch. This is required when runner is runner_iter.",
+    )
+    lr_scheds_choices = registry.list_lr_schedulers()
+    validator.add_argument(
+        "lr_sched",
+        type=str,
+        choices=lr_scheds_choices,
+        help="Learning rate scheduler to use, from {}".format(lr_scheds_choices),
+    )
+    task_choices = registry.list_tasks()
+    validator.add_argument(
+        "task",
+        type=str,
+        choices=task_choices,
+        help="Task to use, from {}".format(task_choices),
+    )
+    # add arguments for init_lr
+    validator.add_argument(
+        "init_lr",
+        type=float,
+        help="Initial learning rate. This will be the learning rate after warmup and before decay.",
+    )
+    # add arguments for min_lr
+    validator.add_argument(
+        "min_lr",
+        type=float,
+        help="Minimum learning rate (after decay).",
+    )
+    # add arguments for warmup_lr
+    validator.add_argument(
+        "warmup_lr",
+        type=float,
+        help="Starting learning rate for warmup.",
+    )
+    # add arguments for learning rate decay rate
+    validator.add_argument(
+        "lr_decay_rate",
+        type=float,
+        help="Learning rate decay rate. Required if using a decaying learning rate scheduler.",
+    )
+    # add arguments for weight decay
+    validator.add_argument(
+        "weight_decay",
+        type=float,
+        help="Weight decay rate.",
+    )
+    # add arguments for training batch size
+    validator.add_argument(
+        "batch_size_train",
+        type=int,
+        help="Training batch size.",
+    )
+    # add arguments for evaluation batch size
+    validator.add_argument(
+        "batch_size_eval",
+        type=int,
+        help="Evaluation batch size, including validation and testing.",
+    )
+    # add arguments for number of workers for data loading
+    validator.add_argument(
+        "num_workers",
+        help="Number of workers for data loading.",
+    )
+    # add arguments for warm up steps
+    validator.add_argument(
+        "warmup_steps",
+        type=int,
+        help="Number of warmup steps. Required if a warmup schedule is used.",
+    )
+    # add arguments for random seed
+    validator.add_argument(
+        "seed",
+        type=int,
+        help="Random seed.",
+    )
+    # add arguments for output directory
+    validator.add_argument(
+        "output_dir",
+        type=str,
+        help="Output directory to save checkpoints and logs.",
+    )
+    # add arguments for whether only use evaluation
+    validator.add_argument(
+        "evaluate",
+        help="Whether to only evaluate the model. If true, training will not be performed.",
+    )
+    # add arguments for splits used for training, e.g. ["train", "val"]
+    validator.add_argument(
+        "train_splits",
+        type=list,
+        help="Splits to use for training.",
+    )
+    # add arguments for splits used for validation, e.g. ["val"]
+    validator.add_argument(
+        "valid_splits",
+        type=list,
+        help="Splits to use for validation. If not provided, will skip the validation.",
+    )
+    # add arguments for splits used for testing, e.g. ["test"]
+    validator.add_argument(
+        "test_splits",
+        type=list,
+        help="Splits to use for testing. If not provided, will skip the testing.",
+    )
+    # add arguments for accumulating gradient for iterations
+    validator.add_argument(
+        "accum_grad_iters",
+        type=int,
+        help="Number of iterations to accumulate gradient for.",
+    )
+
+    # ====== distributed training ======
+    validator.add_argument(
+        "device",
+        type=str,
+        choices=["cpu", "cuda"],
+        help="Device to use. Support 'cuda' or 'cpu' as for now.",
+    )
+    validator.add_argument(
+        "world_size",
+        type=int,
+        help="Number of processes participating in the job.",
+    )
+    validator.add_argument("dist_url", type=str)
+    validator.add_argument("distributed", type=bool)
+    # add arguments to opt using distributed sampler during evaluation or not
+    validator.add_argument(
+        "use_dist_eval_sampler",
+        type=bool,
+        help="Whether to use distributed sampler during evaluation or not.",
+    )
+
+    # ====== task specific ======
+    # generation task specific arguments
+    # add arguments for maximal length of text output
+    validator.add_argument(
+        "max_len",
+        type=int,
+        help="Maximal length of text output.",
+    )
+    # add arguments for minimal length of text output
+    validator.add_argument(
+        "min_len",
+        type=int,
+        help="Minimal length of text output.",
+    )
+    # add arguments number of beams
+    validator.add_argument(
+        "num_beams",
+        type=int,
+        help="Number of beams used for beam search.",
+    )
+
+    # vqa task specific arguments
+    # add arguments for number of answer candidates
+    validator.add_argument(
+        "num_ans_candidates",
+        type=int,
+        help="""For ALBEF and BLIP, these models first rank answers according to likelihood to select answer candidates.""",
+    )
+    # add arguments for inference method
+    validator.add_argument(
+        "inference_method",
+        type=str,
+        choices=["genearte", "rank"],
+        help="""Inference method to use for question answering. If rank, requires a answer list.""",
+    )
+
+    # ====== model specific ======
+    validator.add_argument(
+        "k_test",
+        type=int,
+        help="Number of top k most similar samples from ITC/VTC selection to be tested.",
+    )
+
+    return validator

OPERA/minigpt4/common/dist_utils.py

@@ -0,0 +1,151 @@
+"""
+ Copyright (c) 2022, salesforce.com, inc.
+ All rights reserved.
+ SPDX-License-Identifier: BSD-3-Clause
+ For full license text, see the LICENSE_Lavis file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+"""
+
+import datetime
+import functools
+import os
+
+import torch
+import torch.distributed as dist
+import timm.models.hub as timm_hub
+
+
+def setup_for_distributed(is_master):
+    """
+    This function disables printing when not in master process
+    """
+    import builtins as __builtin__
+
+    builtin_print = __builtin__.print
+
+    def print(*args, **kwargs):
+        force = kwargs.pop("force", False)
+        if is_master or force:
+            builtin_print(*args, **kwargs)
+
+    __builtin__.print = print
+
+
+def is_dist_avail_and_initialized():
+    if not dist.is_available():
+        return False
+    if not dist.is_initialized():
+        return False
+    return True
+
+
+def get_world_size():
+    if not is_dist_avail_and_initialized():
+        return 1
+    return dist.get_world_size()
+
+
+def get_rank():
+    if not is_dist_avail_and_initialized():
+        return 0
+    return dist.get_rank()
+
+
+def is_main_process():
+    return get_rank() == 0
+
+
+def init_distributed_mode(args):
+    if args.distributed is False:
+        print("Not using distributed mode")
+        return
+    elif "RANK" in os.environ and "WORLD_SIZE" in os.environ:
+        args.rank = int(os.environ["RANK"])
+        args.world_size = int(os.environ["WORLD_SIZE"])
+        args.gpu = int(os.environ["LOCAL_RANK"])
+    elif "SLURM_PROCID" in os.environ:
+        args.rank = int(os.environ["SLURM_PROCID"])
+        args.gpu = args.rank % torch.cuda.device_count()
+    else:
+        print("Not using distributed mode")
+        args.distributed = False
+        return
+
+    args.distributed = True
+
+    torch.cuda.set_device(args.gpu)
+    args.dist_backend = "nccl"
+    print(
+        "| distributed init (rank {}, world {}): {}".format(
+            args.rank, args.world_size, args.dist_url
+        ),
+        flush=True,
+    )
+    torch.distributed.init_process_group(
+        backend=args.dist_backend,
+        init_method=args.dist_url,
+        world_size=args.world_size,
+        rank=args.rank,
+        timeout=datetime.timedelta(
+            days=365
+        ),  # allow auto-downloading and de-compressing
+    )
+    torch.distributed.barrier()
+    setup_for_distributed(args.rank == 0)
+
+
+def get_dist_info():
+    if torch.__version__ < "1.0":
+        initialized = dist._initialized
+    else:
+        initialized = dist.is_initialized()
+    if initialized:
+        rank = dist.get_rank()
+        world_size = dist.get_world_size()
+    else:  # non-distributed training
+        rank = 0
+        world_size = 1
+    return rank, world_size
+
+
+def main_process(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        rank, _ = get_dist_info()
+        if rank == 0:
+            return func(*args, **kwargs)
+
+    return wrapper
+
+
+def download_cached_file(url, check_hash=True, progress=False):
+    """
+    Download a file from a URL and cache it locally. If the file already exists, it is not downloaded again.
+    If distributed, only the main process downloads the file, and the other processes wait for the file to be downloaded.
+    """
+
+    def get_cached_file_path():
+        # a hack to sync the file path across processes
+        parts = torch.hub.urlparse(url)
+        filename = os.path.basename(parts.path)
+        cached_file = os.path.join(timm_hub.get_cache_dir(), filename)
+
+        return cached_file
+
+    if is_main_process():
+        timm_hub.download_cached_file(url, check_hash, progress)
+
+    if is_dist_avail_and_initialized():
+        dist.barrier()
+
+    return get_cached_file_path()
+
+
+def all_reduce_mean(x):
+    world_size = get_world_size()
+    if world_size > 1:
+        x_reduce = torch.tensor(x).cuda()
+        dist.all_reduce(x_reduce)
+        x_reduce /= world_size
+        return x_reduce.item()
+    else:
+        return x

OPERA/minigpt4/common/gradcam.py

@@ -0,0 +1,24 @@
+import numpy as np
+from matplotlib import pyplot as plt
+from scipy.ndimage import filters
+from skimage import transform as skimage_transform
+
+
+def getAttMap(img, attMap, blur=True, overlap=True):
+    attMap -= attMap.min()
+    if attMap.max() > 0:
+        attMap /= attMap.max()
+    attMap = skimage_transform.resize(attMap, (img.shape[:2]), order=3, mode="constant")
+    if blur:
+        attMap = filters.gaussian_filter(attMap, 0.02 * max(img.shape[:2]))
+        attMap -= attMap.min()
+        attMap /= attMap.max()
+    cmap = plt.get_cmap("jet")
+    attMapV = cmap(attMap)
+    attMapV = np.delete(attMapV, 3, 2)
+    if overlap:
+        attMap = (
+            1 * (1 - attMap**0.7).reshape(attMap.shape + (1,)) * img
+            + (attMap**0.7).reshape(attMap.shape + (1,)) * attMapV
+        )
+    return attMap

OPERA/minigpt4/common/logger.py

@@ -0,0 +1,195 @@
+"""
+ Copyright (c) 2022, salesforce.com, inc.
+ All rights reserved.
+ SPDX-License-Identifier: BSD-3-Clause
+ For full license text, see the LICENSE_Lavis file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+"""
+
+import datetime
+import logging
+import time
+from collections import defaultdict, deque
+
+import torch
+import torch.distributed as dist
+
+from minigpt4.common import dist_utils
+
+
+class SmoothedValue(object):
+    """Track a series of values and provide access to smoothed values over a
+    window or the global series average.
+    """
+
+    def __init__(self, window_size=20, fmt=None):
+        if fmt is None:
+            fmt = "{median:.4f} ({global_avg:.4f})"
+        self.deque = deque(maxlen=window_size)
+        self.total = 0.0
+        self.count = 0
+        self.fmt = fmt
+
+    def update(self, value, n=1):
+        self.deque.append(value)
+        self.count += n
+        self.total += value * n
+
+    def synchronize_between_processes(self):
+        """
+        Warning: does not synchronize the deque!
+        """
+        if not dist_utils.is_dist_avail_and_initialized():
+            return
+        t = torch.tensor([self.count, self.total], dtype=torch.float64, device="cuda")
+        dist.barrier()
+        dist.all_reduce(t)
+        t = t.tolist()
+        self.count = int(t[0])
+        self.total = t[1]
+
+    @property
+    def median(self):
+        d = torch.tensor(list(self.deque))
+        return d.median().item()
+
+    @property
+    def avg(self):
+        d = torch.tensor(list(self.deque), dtype=torch.float32)
+        return d.mean().item()
+
+    @property
+    def global_avg(self):
+        return self.total / self.count
+
+    @property
+    def max(self):
+        return max(self.deque)
+
+    @property
+    def value(self):
+        return self.deque[-1]
+
+    def __str__(self):
+        return self.fmt.format(
+            median=self.median,
+            avg=self.avg,
+            global_avg=self.global_avg,
+            max=self.max,
+            value=self.value,
+        )
+
+
+class MetricLogger(object):
+    def __init__(self, delimiter="\t"):
+        self.meters = defaultdict(SmoothedValue)
+        self.delimiter = delimiter
+
+    def update(self, **kwargs):
+        for k, v in kwargs.items():
+            if isinstance(v, torch.Tensor):
+                v = v.item()
+            assert isinstance(v, (float, int))
+            self.meters[k].update(v)
+
+    def __getattr__(self, attr):
+        if attr in self.meters:
+            return self.meters[attr]
+        if attr in self.__dict__:
+            return self.__dict__[attr]
+        raise AttributeError(
+            "'{}' object has no attribute '{}'".format(type(self).__name__, attr)
+        )
+
+    def __str__(self):
+        loss_str = []
+        for name, meter in self.meters.items():
+            loss_str.append("{}: {}".format(name, str(meter)))
+        return self.delimiter.join(loss_str)
+
+    def global_avg(self):
+        loss_str = []
+        for name, meter in self.meters.items():
+            loss_str.append("{}: {:.4f}".format(name, meter.global_avg))
+        return self.delimiter.join(loss_str)
+
+    def synchronize_between_processes(self):
+        for meter in self.meters.values():
+            meter.synchronize_between_processes()
+
+    def add_meter(self, name, meter):
+        self.meters[name] = meter
+
+    def log_every(self, iterable, print_freq, header=None):
+        i = 0
+        if not header:
+            header = ""
+        start_time = time.time()
+        end = time.time()
+        iter_time = SmoothedValue(fmt="{avg:.4f}")
+        data_time = SmoothedValue(fmt="{avg:.4f}")
+        space_fmt = ":" + str(len(str(len(iterable)))) + "d"
+        log_msg = [
+            header,
+            "[{0" + space_fmt + "}/{1}]",
+            "eta: {eta}",
+            "{meters}",
+            "time: {time}",
+            "data: {data}",
+        ]
+        if torch.cuda.is_available():
+            log_msg.append("max mem: {memory:.0f}")
+        log_msg = self.delimiter.join(log_msg)
+        MB = 1024.0 * 1024.0
+        for obj in iterable:
+            data_time.update(time.time() - end)
+            yield obj
+            iter_time.update(time.time() - end)
+            if i % print_freq == 0 or i == len(iterable) - 1:
+                eta_seconds = iter_time.global_avg * (len(iterable) - i)
+                eta_string = str(datetime.timedelta(seconds=int(eta_seconds)))
+                if torch.cuda.is_available():
+                    print(
+                        log_msg.format(
+                            i,
+                            len(iterable),
+                            eta=eta_string,
+                            meters=str(self),
+                            time=str(iter_time),
+                            data=str(data_time),
+                            memory=torch.cuda.max_memory_allocated() / MB,
+                        )
+                    )
+                else:
+                    print(
+                        log_msg.format(
+                            i,
+                            len(iterable),
+                            eta=eta_string,
+                            meters=str(self),
+                            time=str(iter_time),
+                            data=str(data_time),
+                        )
+                    )
+            i += 1
+            end = time.time()
+        total_time = time.time() - start_time
+        total_time_str = str(datetime.timedelta(seconds=int(total_time)))
+        print(
+            "{} Total time: {} ({:.4f} s / it)".format(
+                header, total_time_str, total_time / len(iterable)
+            )
+        )
+
+
+class AttrDict(dict):
+    def __init__(self, *args, **kwargs):
+        super(AttrDict, self).__init__(*args, **kwargs)
+        self.__dict__ = self
+
+
+def setup_logger():
+    logging.basicConfig(
+        level=logging.INFO if dist_utils.is_main_process() else logging.WARN,
+        format="%(asctime)s [%(levelname)s] %(message)s",
+        handlers=[logging.StreamHandler()],
+    )

OPERA/minigpt4/common/optims.py

@@ -0,0 +1,119 @@
+"""
+ Copyright (c) 2022, salesforce.com, inc.
+ All rights reserved.
+ SPDX-License-Identifier: BSD-3-Clause
+ For full license text, see the LICENSE_Lavis file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+"""
+
+import math
+
+from minigpt4.common.registry import registry
+
+
+@registry.register_lr_scheduler("linear_warmup_step_lr")
+class LinearWarmupStepLRScheduler:
+    def __init__(
+        self,
+        optimizer,
+        max_epoch,
+        min_lr,
+        init_lr,
+        decay_rate=1,
+        warmup_start_lr=-1,
+        warmup_steps=0,
+        **kwargs
+    ):
+        self.optimizer = optimizer
+
+        self.max_epoch = max_epoch
+        self.min_lr = min_lr
+
+        self.decay_rate = decay_rate
+
+        self.init_lr = init_lr
+        self.warmup_steps = warmup_steps
+        self.warmup_start_lr = warmup_start_lr if warmup_start_lr >= 0 else init_lr
+
+    def step(self, cur_epoch, cur_step):
+        if cur_epoch == 0:
+            warmup_lr_schedule(
+                step=cur_step,
+                optimizer=self.optimizer,
+                max_step=self.warmup_steps,
+                init_lr=self.warmup_start_lr,
+                max_lr=self.init_lr,
+            )
+        else:
+            step_lr_schedule(
+                epoch=cur_epoch,
+                optimizer=self.optimizer,
+                init_lr=self.init_lr,
+                min_lr=self.min_lr,
+                decay_rate=self.decay_rate,
+            )
+
+
+@registry.register_lr_scheduler("linear_warmup_cosine_lr")
+class LinearWarmupCosineLRScheduler:
+    def __init__(
+        self,
+        optimizer,
+        max_epoch,
+        iters_per_epoch,
+        min_lr,
+        init_lr,
+        warmup_steps=0,
+        warmup_start_lr=-1,
+        **kwargs
+    ):
+        self.optimizer = optimizer
+
+        self.max_epoch = max_epoch
+        self.iters_per_epoch = iters_per_epoch
+        self.min_lr = min_lr
+
+        self.init_lr = init_lr
+        self.warmup_steps = warmup_steps
+        self.warmup_start_lr = warmup_start_lr if warmup_start_lr >= 0 else init_lr
+
+    def step(self, cur_epoch, cur_step):
+        total_cur_step = cur_epoch * self.iters_per_epoch + cur_step
+        if total_cur_step < self.warmup_steps:
+            warmup_lr_schedule(
+                step=cur_step,
+                optimizer=self.optimizer,
+                max_step=self.warmup_steps,
+                init_lr=self.warmup_start_lr,
+                max_lr=self.init_lr,
+            )
+        else:
+            cosine_lr_schedule(
+                epoch=total_cur_step,
+                optimizer=self.optimizer,
+                max_epoch=self.max_epoch * self.iters_per_epoch,
+                init_lr=self.init_lr,
+                min_lr=self.min_lr,
+            )
+
+
+def cosine_lr_schedule(optimizer, epoch, max_epoch, init_lr, min_lr):
+    """Decay the learning rate"""
+    lr = (init_lr - min_lr) * 0.5 * (
+        1.0 + math.cos(math.pi * epoch / max_epoch)
+    ) + min_lr
+    for param_group in optimizer.param_groups:
+        param_group["lr"] = lr
+
+
+def warmup_lr_schedule(optimizer, step, max_step, init_lr, max_lr):
+    """Warmup the learning rate"""
+    lr = min(max_lr, init_lr + (max_lr - init_lr) * step / max(max_step, 1))
+    for param_group in optimizer.param_groups:
+        param_group["lr"] = lr
+
+
+def step_lr_schedule(optimizer, epoch, init_lr, min_lr, decay_rate):
+    """Decay the learning rate"""
+    lr = max(min_lr, init_lr * (decay_rate**epoch))
+    for param_group in optimizer.param_groups:
+        param_group["lr"] = lr

OPERA/minigpt4/common/registry.py

@@ -0,0 +1,329 @@
+"""
+ Copyright (c) 2022, salesforce.com, inc.
+ All rights reserved.
+ SPDX-License-Identifier: BSD-3-Clause
+ For full license text, see the LICENSE_Lavis file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+"""
+
+
+class Registry:
+    mapping = {
+        "builder_name_mapping": {},
+        "task_name_mapping": {},
+        "processor_name_mapping": {},
+        "model_name_mapping": {},
+        "lr_scheduler_name_mapping": {},
+        "runner_name_mapping": {},
+        "state": {},
+        "paths": {},
+    }
+
+    @classmethod
+    def register_builder(cls, name):
+        r"""Register a dataset builder to registry with key 'name'
+
+        Args:
+            name: Key with which the builder will be registered.
+
+        Usage:
+
+            from minigpt4.common.registry import registry
+            from minigpt4.datasets.base_dataset_builder import BaseDatasetBuilder
+        """
+
+        def wrap(builder_cls):
+            from minigpt4.datasets.builders.base_dataset_builder import BaseDatasetBuilder
+
+            assert issubclass(
+                builder_cls, BaseDatasetBuilder
+            ), "All builders must inherit BaseDatasetBuilder class, found {}".format(
+                builder_cls
+            )
+            if name in cls.mapping["builder_name_mapping"]:
+                raise KeyError(
+                    "Name '{}' already registered for {}.".format(
+                        name, cls.mapping["builder_name_mapping"][name]
+                    )
+                )
+            cls.mapping["builder_name_mapping"][name] = builder_cls
+            return builder_cls
+
+        return wrap
+
+    @classmethod
+    def register_task(cls, name):
+        r"""Register a task to registry with key 'name'
+
+        Args:
+            name: Key with which the task will be registered.
+
+        Usage:
+
+            from minigpt4.common.registry import registry
+        """
+
+        def wrap(task_cls):
+            from minigpt4.tasks.base_task import BaseTask
+
+            assert issubclass(
+                task_cls, BaseTask
+            ), "All tasks must inherit BaseTask class"
+            if name in cls.mapping["task_name_mapping"]:
+                raise KeyError(
+                    "Name '{}' already registered for {}.".format(
+                        name, cls.mapping["task_name_mapping"][name]
+                    )
+                )
+            cls.mapping["task_name_mapping"][name] = task_cls
+            return task_cls
+
+        return wrap
+
+    @classmethod
+    def register_model(cls, name):
+        r"""Register a task to registry with key 'name'
+
+        Args:
+            name: Key with which the task will be registered.
+
+        Usage:
+
+            from minigpt4.common.registry import registry
+        """
+
+        def wrap(model_cls):
+            from minigpt4.models import BaseModel
+
+            assert issubclass(
+                model_cls, BaseModel
+            ), "All models must inherit BaseModel class"
+            if name in cls.mapping["model_name_mapping"]:
+                raise KeyError(
+                    "Name '{}' already registered for {}.".format(
+                        name, cls.mapping["model_name_mapping"][name]
+                    )
+                )
+            cls.mapping["model_name_mapping"][name] = model_cls
+            return model_cls
+
+        return wrap
+
+    @classmethod
+    def register_processor(cls, name):
+        r"""Register a processor to registry with key 'name'
+
+        Args:
+            name: Key with which the task will be registered.
+
+        Usage:
+
+            from minigpt4.common.registry import registry
+        """
+
+        def wrap(processor_cls):
+            from minigpt4.processors import BaseProcessor
+
+            assert issubclass(
+                processor_cls, BaseProcessor
+            ), "All processors must inherit BaseProcessor class"
+            if name in cls.mapping["processor_name_mapping"]:
+                raise KeyError(
+                    "Name '{}' already registered for {}.".format(
+                        name, cls.mapping["processor_name_mapping"][name]
+                    )
+                )
+            cls.mapping["processor_name_mapping"][name] = processor_cls
+            return processor_cls
+
+        return wrap
+
+    @classmethod
+    def register_lr_scheduler(cls, name):
+        r"""Register a model to registry with key 'name'
+
+        Args:
+            name: Key with which the task will be registered.
+
+        Usage:
+
+            from minigpt4.common.registry import registry
+        """
+
+        def wrap(lr_sched_cls):
+            if name in cls.mapping["lr_scheduler_name_mapping"]:
+                raise KeyError(
+                    "Name '{}' already registered for {}.".format(
+                        name, cls.mapping["lr_scheduler_name_mapping"][name]
+                    )
+                )
+            cls.mapping["lr_scheduler_name_mapping"][name] = lr_sched_cls
+            return lr_sched_cls
+
+        return wrap
+
+    @classmethod
+    def register_runner(cls, name):
+        r"""Register a model to registry with key 'name'
+
+        Args:
+            name: Key with which the task will be registered.
+
+        Usage:
+
+            from minigpt4.common.registry import registry
+        """
+
+        def wrap(runner_cls):
+            if name in cls.mapping["runner_name_mapping"]:
+                raise KeyError(
+                    "Name '{}' already registered for {}.".format(
+                        name, cls.mapping["runner_name_mapping"][name]
+                    )
+                )
+            cls.mapping["runner_name_mapping"][name] = runner_cls
+            return runner_cls
+
+        return wrap
+
+    @classmethod
+    def register_path(cls, name, path):
+        r"""Register a path to registry with key 'name'
+
+        Args:
+            name: Key with which the path will be registered.
+
+        Usage:
+
+            from minigpt4.common.registry import registry
+        """
+        assert isinstance(path, str), "All path must be str."
+        if name in cls.mapping["paths"]:
+            raise KeyError("Name '{}' already registered.".format(name))
+        cls.mapping["paths"][name] = path
+
+    @classmethod
+    def register(cls, name, obj):
+        r"""Register an item to registry with key 'name'
+
+        Args:
+            name: Key with which the item will be registered.
+
+        Usage::
+
+            from minigpt4.common.registry import registry
+
+            registry.register("config", {})
+        """
+        path = name.split(".")
+        current = cls.mapping["state"]
+
+        for part in path[:-1]:
+            if part not in current:
+                current[part] = {}
+            current = current[part]
+
+        current[path[-1]] = obj
+
+    # @classmethod
+    # def get_trainer_class(cls, name):
+    #     return cls.mapping["trainer_name_mapping"].get(name, None)
+
+    @classmethod
+    def get_builder_class(cls, name):
+        return cls.mapping["builder_name_mapping"].get(name, None)
+
+    @classmethod
+    def get_model_class(cls, name):
+        return cls.mapping["model_name_mapping"].get(name, None)
+
+    @classmethod
+    def get_task_class(cls, name):
+        return cls.mapping["task_name_mapping"].get(name, None)
+
+    @classmethod
+    def get_processor_class(cls, name):
+        return cls.mapping["processor_name_mapping"].get(name, None)
+
+    @classmethod
+    def get_lr_scheduler_class(cls, name):
+        return cls.mapping["lr_scheduler_name_mapping"].get(name, None)
+
+    @classmethod
+    def get_runner_class(cls, name):
+        return cls.mapping["runner_name_mapping"].get(name, None)
+
+    @classmethod
+    def list_runners(cls):
+        return sorted(cls.mapping["runner_name_mapping"].keys())
+
+    @classmethod
+    def list_models(cls):
+        return sorted(cls.mapping["model_name_mapping"].keys())
+
+    @classmethod
+    def list_tasks(cls):
+        return sorted(cls.mapping["task_name_mapping"].keys())
+
+    @classmethod
+    def list_processors(cls):
+        return sorted(cls.mapping["processor_name_mapping"].keys())
+
+    @classmethod
+    def list_lr_schedulers(cls):
+        return sorted(cls.mapping["lr_scheduler_name_mapping"].keys())
+
+    @classmethod
+    def list_datasets(cls):
+        return sorted(cls.mapping["builder_name_mapping"].keys())
+
+    @classmethod
+    def get_path(cls, name):
+        return cls.mapping["paths"].get(name, None)
+
+    @classmethod
+    def get(cls, name, default=None, no_warning=False):
+        r"""Get an item from registry with key 'name'
+
+        Args:
+            name (string): Key whose value needs to be retrieved.
+            default: If passed and key is not in registry, default value will
+                     be returned with a warning. Default: None
+            no_warning (bool): If passed as True, warning when key doesn't exist
+                               will not be generated. Useful for MMF's
+                               internal operations. Default: False
+        """
+        original_name = name
+        name = name.split(".")
+        value = cls.mapping["state"]
+        for subname in name:
+            value = value.get(subname, default)
+            if value is default:
+                break
+
+        if (
+            "writer" in cls.mapping["state"]
+            and value == default
+            and no_warning is False
+        ):
+            cls.mapping["state"]["writer"].warning(
+                "Key {} is not present in registry, returning default value "
+                "of {}".format(original_name, default)
+            )
+        return value
+
+    @classmethod
+    def unregister(cls, name):
+        r"""Remove an item from registry with key 'name'
+
+        Args:
+            name: Key which needs to be removed.
+        Usage::
+
+            from mmf.common.registry import registry
+
+            config = registry.unregister("config")
+        """
+        return cls.mapping["state"].pop(name, None)
+
+
+registry = Registry()

OPERA/minigpt4/common/utils.py

@@ -0,0 +1,424 @@
+"""
+ Copyright (c) 2022, salesforce.com, inc.
+ All rights reserved.
+ SPDX-License-Identifier: BSD-3-Clause
+ For full license text, see the LICENSE_Lavis file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+"""
+
+import io
+import json
+import logging
+import os
+import pickle
+import re
+import shutil
+import urllib
+import urllib.error
+import urllib.request
+from typing import Optional
+from urllib.parse import urlparse
+
+import numpy as np
+import pandas as pd
+import yaml
+from iopath.common.download import download
+from iopath.common.file_io import file_lock, g_pathmgr
+from minigpt4.common.registry import registry
+from torch.utils.model_zoo import tqdm
+from torchvision.datasets.utils import (
+    check_integrity,
+    download_file_from_google_drive,
+    extract_archive,
+)
+
+
+def now():
+    from datetime import datetime
+
+    return datetime.now().strftime("%Y%m%d%H%M")[:-1]
+
+
+def is_url(url_or_filename):
+    parsed = urlparse(url_or_filename)
+    return parsed.scheme in ("http", "https")
+
+
+def get_cache_path(rel_path):
+    return os.path.expanduser(os.path.join(registry.get_path("cache_root"), rel_path))
+
+
+def get_abs_path(rel_path):
+    return os.path.join(registry.get_path("library_root"), rel_path)
+
+
+def load_json(filename):
+    with open(filename, "r") as f:
+        return json.load(f)
+
+
+# The following are adapted from torchvision and vissl
+# torchvision: https://github.com/pytorch/vision
+# vissl: https://github.com/facebookresearch/vissl/blob/main/vissl/utils/download.py
+
+
+def makedir(dir_path):
+    """
+    Create the directory if it does not exist.
+    """
+    is_success = False
+    try:
+        if not g_pathmgr.exists(dir_path):
+            g_pathmgr.mkdirs(dir_path)
+        is_success = True
+    except BaseException:
+        print(f"Error creating directory: {dir_path}")
+    return is_success
+
+
+def get_redirected_url(url: str):
+    """
+    Given a URL, returns the URL it redirects to or the
+    original URL in case of no indirection
+    """
+    import requests
+
+    with requests.Session() as session:
+        with session.get(url, stream=True, allow_redirects=True) as response:
+            if response.history:
+                return response.url
+            else:
+                return url
+
+
+def to_google_drive_download_url(view_url: str) -> str:
+    """
+    Utility function to transform a view URL of google drive
+    to a download URL for google drive
+    Example input:
+        https://drive.google.com/file/d/137RyRjvTBkBiIfeYBNZBtViDHQ6_Ewsp/view
+    Example output:
+        https://drive.google.com/uc?export=download&id=137RyRjvTBkBiIfeYBNZBtViDHQ6_Ewsp
+    """
+    splits = view_url.split("/")
+    assert splits[-1] == "view"
+    file_id = splits[-2]
+    return f"https://drive.google.com/uc?export=download&id={file_id}"
+
+
+def download_google_drive_url(url: str, output_path: str, output_file_name: str):
+    """
+    Download a file from google drive
+    Downloading an URL from google drive requires confirmation when
+    the file of the size is too big (google drive notifies that
+    anti-viral checks cannot be performed on such files)
+    """
+    import requests
+
+    with requests.Session() as session:
+
+        # First get the confirmation token and append it to the URL
+        with session.get(url, stream=True, allow_redirects=True) as response:
+            for k, v in response.cookies.items():
+                if k.startswith("download_warning"):
+                    url = url + "&confirm=" + v
+
+        # Then download the content of the file
+        with session.get(url, stream=True, verify=True) as response:
+            makedir(output_path)
+            path = os.path.join(output_path, output_file_name)
+            total_size = int(response.headers.get("Content-length", 0))
+            with open(path, "wb") as file:
+                from tqdm import tqdm
+
+                with tqdm(total=total_size) as progress_bar:
+                    for block in response.iter_content(
+                        chunk_size=io.DEFAULT_BUFFER_SIZE
+                    ):
+                        file.write(block)
+                        progress_bar.update(len(block))
+
+
+def _get_google_drive_file_id(url: str) -> Optional[str]:
+    parts = urlparse(url)
+
+    if re.match(r"(drive|docs)[.]google[.]com", parts.netloc) is None:
+        return None
+
+    match = re.match(r"/file/d/(?P<id>[^/]*)", parts.path)
+    if match is None:
+        return None
+
+    return match.group("id")
+
+
+def _urlretrieve(url: str, filename: str, chunk_size: int = 1024) -> None:
+    with open(filename, "wb") as fh:
+        with urllib.request.urlopen(
+            urllib.request.Request(url, headers={"User-Agent": "vissl"})
+        ) as response:
+            with tqdm(total=response.length) as pbar:
+                for chunk in iter(lambda: response.read(chunk_size), ""):
+                    if not chunk:
+                        break
+                    pbar.update(chunk_size)
+                    fh.write(chunk)
+
+
+def download_url(
+    url: str,
+    root: str,
+    filename: Optional[str] = None,
+    md5: Optional[str] = None,
+) -> None:
+    """Download a file from a url and place it in root.
+    Args:
+        url (str): URL to download file from
+        root (str): Directory to place downloaded file in
+        filename (str, optional): Name to save the file under.
+                                  If None, use the basename of the URL.
+        md5 (str, optional): MD5 checksum of the download. If None, do not check
+    """
+    root = os.path.expanduser(root)
+    if not filename:
+        filename = os.path.basename(url)
+    fpath = os.path.join(root, filename)
+
+    makedir(root)
+
+    # check if file is already present locally
+    if check_integrity(fpath, md5):
+        print("Using downloaded and verified file: " + fpath)
+        return
+
+    # expand redirect chain if needed
+    url = get_redirected_url(url)
+
+    # check if file is located on Google Drive
+    file_id = _get_google_drive_file_id(url)
+    if file_id is not None:
+        return download_file_from_google_drive(file_id, root, filename, md5)
+
+    # download the file
+    try:
+        print("Downloading " + url + " to " + fpath)
+        _urlretrieve(url, fpath)
+    except (urllib.error.URLError, IOError) as e:  # type: ignore[attr-defined]
+        if url[:5] == "https":
+            url = url.replace("https:", "http:")
+            print(
+                "Failed download. Trying https -> http instead."
+                " Downloading " + url + " to " + fpath
+            )
+            _urlretrieve(url, fpath)
+        else:
+            raise e
+
+    # check integrity of downloaded file
+    if not check_integrity(fpath, md5):
+        raise RuntimeError("File not found or corrupted.")
+
+
+def download_and_extract_archive(
+    url: str,
+    download_root: str,
+    extract_root: Optional[str] = None,
+    filename: Optional[str] = None,
+    md5: Optional[str] = None,
+    remove_finished: bool = False,
+) -> None:
+    download_root = os.path.expanduser(download_root)
+    if extract_root is None:
+        extract_root = download_root
+    if not filename:
+        filename = os.path.basename(url)
+
+    download_url(url, download_root, filename, md5)
+
+    archive = os.path.join(download_root, filename)
+    print("Extracting {} to {}".format(archive, extract_root))
+    extract_archive(archive, extract_root, remove_finished)
+
+
+def cache_url(url: str, cache_dir: str) -> str:
+    """
+    This implementation downloads the remote resource and caches it locally.
+    The resource will only be downloaded if not previously requested.
+    """
+    parsed_url = urlparse(url)
+    dirname = os.path.join(cache_dir, os.path.dirname(parsed_url.path.lstrip("/")))
+    makedir(dirname)
+    filename = url.split("/")[-1]
+    cached = os.path.join(dirname, filename)
+    with file_lock(cached):
+        if not os.path.isfile(cached):
+            logging.info(f"Downloading {url} to {cached} ...")
+            cached = download(url, dirname, filename=filename)
+    logging.info(f"URL {url} cached in {cached}")
+    return cached
+
+
+# TODO (prigoyal): convert this into RAII-style API
+def create_file_symlink(file1, file2):
+    """
+    Simply create the symlinks for a given file1 to file2.
+    Useful during model checkpointing to symlinks to the
+    latest successful checkpoint.
+    """
+    try:
+        if g_pathmgr.exists(file2):
+            g_pathmgr.rm(file2)
+        g_pathmgr.symlink(file1, file2)
+    except Exception as e:
+        logging.info(f"Could NOT create symlink. Error: {e}")
+
+
+def save_file(data, filename, append_to_json=True, verbose=True):
+    """
+    Common i/o utility to handle saving data to various file formats.
+    Supported:
+        .pkl, .pickle, .npy, .json
+    Specifically for .json, users have the option to either append (default)
+    or rewrite by passing in Boolean value to append_to_json.
+    """
+    if verbose:
+        logging.info(f"Saving data to file: {filename}")
+    file_ext = os.path.splitext(filename)[1]
+    if file_ext in [".pkl", ".pickle"]:
+        with g_pathmgr.open(filename, "wb") as fopen:
+            pickle.dump(data, fopen, pickle.HIGHEST_PROTOCOL)
+    elif file_ext == ".npy":
+        with g_pathmgr.open(filename, "wb") as fopen:
+            np.save(fopen, data)
+    elif file_ext == ".json":
+        if append_to_json:
+            with g_pathmgr.open(filename, "a") as fopen:
+                fopen.write(json.dumps(data, sort_keys=True) + "\n")
+                fopen.flush()
+        else:
+            with g_pathmgr.open(filename, "w") as fopen:
+                fopen.write(json.dumps(data, sort_keys=True) + "\n")
+                fopen.flush()
+    elif file_ext == ".yaml":
+        with g_pathmgr.open(filename, "w") as fopen:
+            dump = yaml.dump(data)
+            fopen.write(dump)
+            fopen.flush()
+    else:
+        raise Exception(f"Saving {file_ext} is not supported yet")
+
+    if verbose:
+        logging.info(f"Saved data to file: {filename}")
+
+
+def load_file(filename, mmap_mode=None, verbose=True, allow_pickle=False):
+    """
+    Common i/o utility to handle loading data from various file formats.
+    Supported:
+        .pkl, .pickle, .npy, .json
+    For the npy files, we support reading the files in mmap_mode.
+    If the mmap_mode of reading is not successful, we load data without the
+    mmap_mode.
+    """
+    if verbose:
+        logging.info(f"Loading data from file: {filename}")
+
+    file_ext = os.path.splitext(filename)[1]
+    if file_ext == ".txt":
+        with g_pathmgr.open(filename, "r") as fopen:
+            data = fopen.readlines()
+    elif file_ext in [".pkl", ".pickle"]:
+        with g_pathmgr.open(filename, "rb") as fopen:
+            data = pickle.load(fopen, encoding="latin1")
+    elif file_ext == ".npy":
+        if mmap_mode:
+            try:
+                with g_pathmgr.open(filename, "rb") as fopen:
+                    data = np.load(
+                        fopen,
+                        allow_pickle=allow_pickle,
+                        encoding="latin1",
+                        mmap_mode=mmap_mode,
+                    )
+            except ValueError as e:
+                logging.info(
+                    f"Could not mmap {filename}: {e}. Trying without g_pathmgr"
+                )
+                data = np.load(
+                    filename,
+                    allow_pickle=allow_pickle,
+                    encoding="latin1",
+                    mmap_mode=mmap_mode,
+                )
+                logging.info("Successfully loaded without g_pathmgr")
+            except Exception:
+                logging.info("Could not mmap without g_pathmgr. Trying without mmap")
+                with g_pathmgr.open(filename, "rb") as fopen:
+                    data = np.load(fopen, allow_pickle=allow_pickle, encoding="latin1")
+        else:
+            with g_pathmgr.open(filename, "rb") as fopen:
+                data = np.load(fopen, allow_pickle=allow_pickle, encoding="latin1")
+    elif file_ext == ".json":
+        with g_pathmgr.open(filename, "r") as fopen:
+            data = json.load(fopen)
+    elif file_ext == ".yaml":
+        with g_pathmgr.open(filename, "r") as fopen:
+            data = yaml.load(fopen, Loader=yaml.FullLoader)
+    elif file_ext == ".csv":
+        with g_pathmgr.open(filename, "r") as fopen:
+            data = pd.read_csv(fopen)
+    else:
+        raise Exception(f"Reading from {file_ext} is not supported yet")
+    return data
+
+
+def abspath(resource_path: str):
+    """
+    Make a path absolute, but take into account prefixes like
+    "http://" or "manifold://"
+    """
+    regex = re.compile(r"^\w+://")
+    if regex.match(resource_path) is None:
+        return os.path.abspath(resource_path)
+    else:
+        return resource_path
+
+
+def makedir(dir_path):
+    """
+    Create the directory if it does not exist.
+    """
+    is_success = False
+    try:
+        if not g_pathmgr.exists(dir_path):
+            g_pathmgr.mkdirs(dir_path)
+        is_success = True
+    except BaseException:
+        logging.info(f"Error creating directory: {dir_path}")
+    return is_success
+
+
+def is_url(input_url):
+    """
+    Check if an input string is a url. look for http(s):// and ignoring the case
+    """
+    is_url = re.match(r"^(?:http)s?://", input_url, re.IGNORECASE) is not None
+    return is_url
+
+
+def cleanup_dir(dir):
+    """
+    Utility for deleting a directory. Useful for cleaning the storage space
+    that contains various training artifacts like checkpoints, data etc.
+    """
+    if os.path.exists(dir):
+        logging.info(f"Deleting directory: {dir}")
+        shutil.rmtree(dir)
+    logging.info(f"Deleted contents of directory: {dir}")
+
+
+def get_file_size(filename):
+    """
+    Given a file, get the size of file in MB
+    """
+    size_in_mb = os.path.getsize(filename) / float(1024**2)
+    return size_in_mb

OPERA/minigpt4/configs/datasets/cc_sbu/align.yaml

@@ -0,0 +1,5 @@
+datasets:
+  cc_sbu_align:
+    data_type: images
+    build_info:
+      storage: /path/to/cc_sbu_align/

OPERA/minigpt4/configs/datasets/cc_sbu/defaults.yaml

@@ -0,0 +1,5 @@
+datasets:
+  cc_sbu:
+    data_type: images
+    build_info:
+      storage: /path/to/cc_sbu_dataset/{00000..01255}.tar

OPERA/minigpt4/configs/datasets/laion/defaults.yaml

@@ -0,0 +1,5 @@
+datasets:
+  laion:
+    data_type: images
+    build_info:
+      storage: /path/to/laion_dataset/{00000..10488}.tar

OPERA/minigpt4/configs/default.yaml

@@ -0,0 +1,5 @@
+env:
+  # For default users
+  # cache_root: "cache"
+  # For internal use with persistent storage
+  cache_root: "/export/home/.cache/minigpt4"

OPERA/minigpt4/configs/models/blip2_instruct_vicuna13b.yaml

@@ -0,0 +1,43 @@
+ # Copyright (c) 2022, salesforce.com, inc.
+ # All rights reserved.
+ # SPDX-License-Identifier: BSD-3-Clause
+ # For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+
+model:
+  arch: instruct_vicuna13b
+  load_finetuned: False
+  load_pretrained: True
+
+  pretrained: "https://storage.googleapis.com/sfr-vision-language-research/LAVIS/models/InstructBLIP/instruct_blip_vicuna13b_trimmed.pth"
+  finetuned: ""
+
+  # vit encoder
+  image_size: 224
+  drop_path_rate: 0
+  use_grad_checkpoint: False
+  vit_precision: "fp16"
+  freeze_vit: True
+
+  # Q-Former
+  num_query_token: 32
+
+  # path to Vicuna checkpoint
+  llm_model: "/mnt/petrelfs/share_data/wangbin/mllm/minigpt4/vicuna-13b-v1-1"
+
+  # generation configs
+  prompt: ""
+
+
+preprocess:
+    vis_processor:
+        train:
+          name: "blip2_image_train"
+          image_size: 224
+        eval:
+          name: "blip_image_eval"
+          image_size: 224
+    text_processor:
+        train:
+          name: "blip_caption"
+        eval:
+          name: "blip_caption"

OPERA/minigpt4/configs/models/blip2_instruct_vicuna7b.yaml

@@ -0,0 +1,43 @@
+ # Copyright (c) 2022, salesforce.com, inc.
+ # All rights reserved.
+ # SPDX-License-Identifier: BSD-3-Clause
+ # For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+
+model:
+  arch: instruct_vicuna7b
+  load_finetuned: False
+  load_pretrained: True
+
+  pretrained: "https://storage.googleapis.com/sfr-vision-language-research/LAVIS/models/InstructBLIP/instruct_blip_vicuna7b_trimmed.pth"
+  finetuned: ""
+
+  # vit encoder
+  image_size: 224
+  drop_path_rate: 0
+  use_grad_checkpoint: False
+  vit_precision: "fp16"
+  freeze_vit: True
+
+  # Q-Former
+  num_query_token: 32
+
+  # path to Vicuna checkpoint
+  llm_model: "/mnt/petrelfs/share_data/wangbin/mllm/minigpt4/vicuna-7b-v1-1"
+
+  # generation configs
+  prompt: ""
+
+
+preprocess:
+    vis_processor:
+        train:
+          name: "blip2_image_train"
+          image_size: 224
+        eval:
+          name: "blip_image_eval"
+          image_size: 224
+    text_processor:
+        train:
+          name: "blip_caption"
+        eval:
+          name: "blip_caption"

OPERA/minigpt4/configs/models/llava-1.5_vicuna7b.yaml

@@ -0,0 +1,40 @@
+model:
+  arch: llava-1.5
+  version: 'v1.5'
+
+  # vit encoder
+  cache_dir: None
+  vit_model: "openai/clip-vit-large-patch14"
+  freeze_vit: True
+
+  # finetune config
+  freeze_backbone: False
+  tune_mm_mlp_adapter: False
+  freeze_mm_mlp_adapter: False
+
+  # model config
+  mm_vision_select_layer: -2
+  model_max_length: 2048
+
+  # data process config
+  image_token_len: 576
+  mm_use_im_start_end: True
+
+  # training config
+  bf16: False
+  fp16: True
+
+
+preprocess:
+    vis_processor:
+        train:
+          name: "clip_image_train_336"
+          proc_type: "openai/clip-vit-large-patch14-336"
+        eval:
+          name: "clip_image_eval_336"
+          proc_type: "openai/clip-vit-large-patch14-336"
+    text_processor:
+        train:
+          name: "blip_caption"
+        eval:
+          name: "blip_caption"

OPERA/minigpt4/configs/models/minigpt4_llama2.yaml

@@ -0,0 +1,29 @@
+model:
+  arch: mini_gpt4
+
+  # vit encoder
+  image_size: 224
+  drop_path_rate: 0
+  use_grad_checkpoint: False
+  vit_precision: "fp16"
+  freeze_vit: True
+  has_qformer: False
+
+  # generation configs
+  prompt: ""
+
+  llama_model: "/path/to/llama2/weight"
+
+preprocess:
+    vis_processor:
+        train:
+          name: "blip2_image_train"
+          image_size: 224
+        eval:
+          name: "blip2_image_eval"
+          image_size: 224
+    text_processor:
+        train:
+          name: "blip_caption"
+        eval:
+          name: "blip_caption"

OPERA/minigpt4/configs/models/minigpt4_vicuna0.yaml

@@ -0,0 +1,32 @@
+model:
+  arch: mini_gpt4
+
+  # vit encoder
+  image_size: 224
+  drop_path_rate: 0
+  use_grad_checkpoint: False
+  vit_precision: "fp16"
+  freeze_vit: True
+  freeze_qformer: True
+
+  # Q-Former
+  num_query_token: 32
+
+  # generation configs
+  prompt: ""
+
+  llama_model: "/mnt/petrelfs/share_data/wangbin/mllm/minigpt4/vicuna-7b-v0"
+
+preprocess:
+    vis_processor:
+        train:
+          name: "blip2_image_train"
+          image_size: 224
+        eval:
+          name: "blip2_image_eval"
+          image_size: 224
+    text_processor:
+        train:
+          name: "blip_caption"
+        eval:
+          name: "blip_caption"

OPERA/minigpt4/configs/models/shikra_vicuna7b.yaml

@@ -0,0 +1,40 @@
+model:
+  arch: shikra
+  version: 'v1'
+
+  # vit encoder
+  cache_dir: None
+  vit_model: "openai/clip-vit-large-patch14"
+  freeze_vit: True
+
+  # finetune config
+  freeze_backbone: False
+  tune_mm_mlp_adapter: False
+  freeze_mm_mlp_adapter: False
+
+  # model config
+  mm_vision_select_layer: -2
+  model_max_length: 2048
+
+  # data process config
+  image_token_len: 256
+  mm_use_im_start_end: True
+
+  # training config
+  bf16: False
+  fp16: True
+
+
+preprocess:
+    vis_processor:
+        train:
+          name: "clip_image_train"
+          proc_type: "openai/clip-vit-large-patch14"
+        eval:
+          name: "clip_image_eval"
+          proc_type: "openai/clip-vit-large-patch14"
+    text_processor:
+        train:
+          name: "blip_caption"
+        eval:
+          name: "blip_caption"