Delete minigpt4

minigpt4/__init__.py

@@ -1,31 +0,0 @@
-"""
- 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"])

minigpt4/common/config.py

@@ -1,496 +0,0 @@
-"""
- 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)
-        evaluation_dataset_config = self.build_evaluation_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,evaluation_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
-
-
-    @staticmethod
-    def build_evaluation_dataset_config(config):
-        datasets = config.get("evaluation_datasets", None)
-        # if datasets is None:
-        #     raise KeyError(
-        #         "Expecting 'datasets' as the root key for dataset configuration."
-        #     )
-
-        dataset_config = OmegaConf.create()
-
-        if datasets is not None:
-            for dataset_name in datasets:
-                builder_cls = registry.get_builder_class(dataset_name)
-
-                # hierarchy override, customized config > default config
-                dataset_config = OmegaConf.merge(
-                    dataset_config,
-                    {"evaluation_datasets": {dataset_name: config["evaluation_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 evaluation_datasets_cfg(self):
-        return self.config.evaluation_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

minigpt4/common/dist_utils.py

@@ -1,140 +0,0 @@
-"""
- 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()

minigpt4/common/eval_utils.py

@@ -1,76 +0,0 @@
-import argparse
-import numpy as np
-from nltk.translate.bleu_score import sentence_bleu
-
-from minigpt4.common.registry import registry
-from minigpt4.common.config import Config
-
-# 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 *
-
-
-
-def eval_parser():
-    parser = argparse.ArgumentParser(description="Demo")
-    parser.add_argument("--cfg-path", required=True, help="path to configuration file.")
-    parser.add_argument("--name", type=str, default='A2', help="evaluation name")
-    parser.add_argument("--ckpt", type=str, help="path to configuration file.")
-    parser.add_argument("--eval_opt", type=str, default='all', help="path to configuration file.")
-    parser.add_argument("--max_new_tokens", type=int, default=10, help="max number of generated tokens")
-    parser.add_argument("--batch_size", type=int, default=32)
-    parser.add_argument("--lora_r", type=int, default=64, help="lora rank of the model")
-    parser.add_argument("--lora_alpha", type=int, default=16, help="lora alpha")
-    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.",
-    )
-    return parser
-
-
-def prepare_texts(texts, conv_temp):
-    convs = [conv_temp.copy() for _ in range(len(texts))]
-    [conv.append_message(
-        conv.roles[0], '<Img><ImageHere></Img> {}'.format(text)) for conv, text in zip(convs, texts)]
-    [conv.append_message(conv.roles[1], None) for conv in convs]
-    texts = [conv.get_prompt() for conv in convs]
-    return texts
-
-
-def init_model(args):
-    print('Initialization Model')
-    cfg = Config(args)
-    # cfg.model_cfg.ckpt = args.ckpt
-    # cfg.model_cfg.lora_r = args.lora_r
-    # cfg.model_cfg.lora_alpha = args.lora_alpha
-
-    model_config = cfg.model_cfg
-    model_cls = registry.get_model_class(model_config.arch)
-    model = model_cls.from_config(model_config).to('cuda:0')
-
-#     import pudb; pudb.set_trace()
-    key = list(cfg.datasets_cfg.keys())[0]
-    vis_processor_cfg = cfg.datasets_cfg.get(key).vis_processor.train
-    vis_processor = registry.get_processor_class(vis_processor_cfg.name).from_config(vis_processor_cfg)
-    print('Initialization Finished')
-    return model, vis_processor
-
-def computeIoU(bbox1, bbox2):
-    x1, y1, x2, y2 = bbox1
-    x3, y3, x4, y4 = bbox2
-    intersection_x1 = max(x1, x3)
-    intersection_y1 = max(y1, y3)
-    intersection_x2 = min(x2, x4)
-    intersection_y2 = min(y2, y4)
-    intersection_area = max(0, intersection_x2 - intersection_x1 + 1) * max(0, intersection_y2 - intersection_y1 + 1)
-    bbox1_area = (x2 - x1 + 1) * (y2 - y1 + 1)
-    bbox2_area = (x4 - x3 + 1) * (y4 - y3 + 1)
-    union_area = bbox1_area + bbox2_area - intersection_area
-    iou = intersection_area / union_area
-    return iou

minigpt4/common/gradcam.py

@@ -1,24 +0,0 @@
-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

minigpt4/common/logger.py

@@ -1,195 +0,0 @@
-"""
- 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()],
-    )

minigpt4/common/optims.py

@@ -1,119 +0,0 @@
-"""
- 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

minigpt4/common/registry.py

@@ -1,329 +0,0 @@
-"""
- 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()

minigpt4/common/utils.py

@@ -1,424 +0,0 @@
-"""
- 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

minigpt4/common/vqa_tools/VQA/PythonEvaluationTools/vqaEvalDemo.py

@@ -1,89 +0,0 @@
-# coding: utf-8
-
-import sys
-dataDir = '../../VQA'
-sys.path.insert(0, '%s/PythonHelperTools/vqaTools' %(dataDir))
-from vqa import VQA
-from vqaEvaluation.vqaEval import VQAEval
-import matplotlib.pyplot as plt
-import skimage.io as io
-import json
-import random
-import os
-
-# set up file names and paths
-versionType ='v2_' # this should be '' when using VQA v2.0 dataset
-taskType    ='OpenEnded' # 'OpenEnded' only for v2.0. 'OpenEnded' or 'MultipleChoice' for v1.0
-dataType    ='mscoco'  # 'mscoco' only for v1.0. 'mscoco' for real and 'abstract_v002' for abstract for v1.0. 
-dataSubType ='train2014'
-annFile     ='%s/Annotations/%s%s_%s_annotations.json'%(dataDir, versionType, dataType, dataSubType)
-quesFile    ='%s/Questions/%s%s_%s_%s_questions.json'%(dataDir, versionType, taskType, dataType, dataSubType)
-imgDir      ='%s/Images/%s/%s/' %(dataDir, dataType, dataSubType)
-resultType  ='fake'
-fileTypes   = ['results', 'accuracy', 'evalQA', 'evalQuesType', 'evalAnsType'] 
-
-# An example result json file has been provided in './Results' folder.  
-
-[resFile, accuracyFile, evalQAFile, evalQuesTypeFile, evalAnsTypeFile] = ['%s/Results/%s%s_%s_%s_%s_%s.json'%(dataDir, versionType, taskType, dataType, dataSubType, \
-resultType, fileType) for fileType in fileTypes]  
-
-# create vqa object and vqaRes object
-vqa = VQA(annFile, quesFile)
-vqaRes = vqa.loadRes(resFile, quesFile)
-
-# create vqaEval object by taking vqa and vqaRes
-vqaEval = VQAEval(vqa, vqaRes, n=2)   #n is precision of accuracy (number of places after decimal), default is 2
-
-# evaluate results
-"""
-If you have a list of question ids on which you would like to evaluate your results, pass it as a list to below function
-By default it uses all the question ids in annotation file
-"""
-vqaEval.evaluate() 
-
-# print accuracies
-print "\n"
-print "Overall Accuracy is: %.02f\n" %(vqaEval.accuracy['overall'])
-print "Per Question Type Accuracy is the following:"
-for quesType in vqaEval.accuracy['perQuestionType']:
-	print "%s : %.02f" %(quesType, vqaEval.accuracy['perQuestionType'][quesType])
-print "\n"
-print "Per Answer Type Accuracy is the following:"
-for ansType in vqaEval.accuracy['perAnswerType']:
-	print "%s : %.02f" %(ansType, vqaEval.accuracy['perAnswerType'][ansType])
-print "\n"
-# demo how to use evalQA to retrieve low score result
-evals = [quesId for quesId in vqaEval.evalQA if vqaEval.evalQA[quesId]<35]   #35 is per question percentage accuracy
-if len(evals) > 0:
-	print 'ground truth answers'
-	randomEval = random.choice(evals)
-	randomAnn = vqa.loadQA(randomEval)
-	vqa.showQA(randomAnn)
-
-	print '\n'
-	print 'generated answer (accuracy %.02f)'%(vqaEval.evalQA[randomEval])
-	ann = vqaRes.loadQA(randomEval)[0]
-	print "Answer:   %s\n" %(ann['answer'])
-
-	imgId = randomAnn[0]['image_id']
-	imgFilename = 'COCO_' + dataSubType + '_'+ str(imgId).zfill(12) + '.jpg'
-	if os.path.isfile(imgDir + imgFilename):
-		I = io.imread(imgDir + imgFilename)
-		plt.imshow(I)
-		plt.axis('off')
-		plt.show()
-
-# plot accuracy for various question types
-plt.bar(range(len(vqaEval.accuracy['perQuestionType'])), vqaEval.accuracy['perQuestionType'].values(), align='center')
-plt.xticks(range(len(vqaEval.accuracy['perQuestionType'])), vqaEval.accuracy['perQuestionType'].keys(), rotation='0',fontsize=10)
-plt.title('Per Question Type Accuracy', fontsize=10)
-plt.xlabel('Question Types', fontsize=10)
-plt.ylabel('Accuracy', fontsize=10)
-plt.show()
-
-# save evaluation results to ./Results folder
-json.dump(vqaEval.accuracy,     open(accuracyFile,     'w'))
-json.dump(vqaEval.evalQA,       open(evalQAFile,       'w'))
-json.dump(vqaEval.evalQuesType, open(evalQuesTypeFile, 'w'))
-json.dump(vqaEval.evalAnsType,  open(evalAnsTypeFile,  'w'))
-

minigpt4/common/vqa_tools/VQA/PythonEvaluationTools/vqaEvaluation/__init__.py

@@ -1 +0,0 @@
-author='aagrawal'

minigpt4/common/vqa_tools/VQA/PythonEvaluationTools/vqaEvaluation/vqaEval.py

@@ -1,192 +0,0 @@
-# coding=utf-8
-
-__author__='aagrawal'
-
-import re
-# This code is based on the code written by Tsung-Yi Lin for MSCOCO Python API available at the following link:
-# (https://github.com/tylin/coco-caption/blob/master/pycocoevalcap/eval.py).
-import sys
-
-
-class VQAEval:
-	def __init__(self, vqa, vqaRes, n=2):
-		self.n 			  = n
-		self.accuracy     = {}
-		self.evalQA       = {}
-		self.evalQuesType = {}
-		self.evalAnsType  = {}
-		self.vqa 		  = vqa
-		self.vqaRes       = vqaRes
-		self.params		  = {'question_id': vqa.getQuesIds()}
-		self.contractions = {"aint": "ain't", "arent": "aren't", "cant": "can't", "couldve": "could've", "couldnt": "couldn't", \
-							 "couldn'tve": "couldn't've", "couldnt've": "couldn't've", "didnt": "didn't", "doesnt": "doesn't", "dont": "don't", "hadnt": "hadn't", \
-							 "hadnt've": "hadn't've", "hadn'tve": "hadn't've", "hasnt": "hasn't", "havent": "haven't", "hed": "he'd", "hed've": "he'd've", \
-							 "he'dve": "he'd've", "hes": "he's", "howd": "how'd", "howll": "how'll", "hows": "how's", "Id've": "I'd've", "I'dve": "I'd've", \
-							 "Im": "I'm", "Ive": "I've", "isnt": "isn't", "itd": "it'd", "itd've": "it'd've", "it'dve": "it'd've", "itll": "it'll", "let's": "let's", \
-							 "maam": "ma'am", "mightnt": "mightn't", "mightnt've": "mightn't've", "mightn'tve": "mightn't've", "mightve": "might've", \
-							 "mustnt": "mustn't", "mustve": "must've", "neednt": "needn't", "notve": "not've", "oclock": "o'clock", "oughtnt": "oughtn't", \
-							 "ow's'at": "'ow's'at", "'ows'at": "'ow's'at", "'ow'sat": "'ow's'at", "shant": "shan't", "shed've": "she'd've", "she'dve": "she'd've", \
-							 "she's": "she's", "shouldve": "should've", "shouldnt": "shouldn't", "shouldnt've": "shouldn't've", "shouldn'tve": "shouldn't've", \
-							 "somebody'd": "somebodyd", "somebodyd've": "somebody'd've", "somebody'dve": "somebody'd've", "somebodyll": "somebody'll", \
-							 "somebodys": "somebody's", "someoned": "someone'd", "someoned've": "someone'd've", "someone'dve": "someone'd've", \
-							 "someonell": "someone'll", "someones": "someone's", "somethingd": "something'd", "somethingd've": "something'd've", \
-							 "something'dve": "something'd've", "somethingll": "something'll", "thats": "that's", "thered": "there'd", "thered've": "there'd've", \
-							 "there'dve": "there'd've", "therere": "there're", "theres": "there's", "theyd": "they'd", "theyd've": "they'd've", \
-							 "they'dve": "they'd've", "theyll": "they'll", "theyre": "they're", "theyve": "they've", "twas": "'twas", "wasnt": "wasn't", \
-							 "wed've": "we'd've", "we'dve": "we'd've", "weve": "we've", "werent": "weren't", "whatll": "what'll", "whatre": "what're", \
-							 "whats": "what's", "whatve": "what've", "whens": "when's", "whered": "where'd", "wheres": "where's", "whereve": "where've", \
-							 "whod": "who'd", "whod've": "who'd've", "who'dve": "who'd've", "wholl": "who'll", "whos": "who's", "whove": "who've", "whyll": "why'll", \
-							 "whyre": "why're", "whys": "why's", "wont": "won't", "wouldve": "would've", "wouldnt": "wouldn't", "wouldnt've": "wouldn't've", \
-							 "wouldn'tve": "wouldn't've", "yall": "y'all", "yall'll": "y'all'll", "y'allll": "y'all'll", "yall'd've": "y'all'd've", \
-							 "y'alld've": "y'all'd've", "y'all'dve": "y'all'd've", "youd": "you'd", "youd've": "you'd've", "you'dve": "you'd've", \
-							 "youll": "you'll", "youre": "you're", "youve": "you've"}
-		self.manualMap    = { 'none': '0',
-							  'zero': '0',
-							  'one': '1',
-							  'two': '2',
-							  'three': '3',
-							  'four': '4',
-							  'five': '5',
-							  'six': '6',
-							  'seven': '7',
-							  'eight': '8',
-							  'nine': '9',
-							  'ten': '10'
-							}
-		self.articles     = ['a',
-							 'an',
-							 'the'
-							]
-
-
-		self.periodStrip  = re.compile("(?!<=\d)(\.)(?!\d)")
-		self.commaStrip   = re.compile("(\d)(\,)(\d)")
-		self.punct        = [';', r"/", '[', ']', '"', '{', '}',
-							 '(', ')', '=', '+', '\\', '_', '-',
-							 '>', '<', '@', '`', ',', '?', '!']
-
-
-	def evaluate(self, quesIds=None):
-		if quesIds == None:
-			quesIds = [quesId for quesId in self.params['question_id']]
-		gts = {}
-		res = {}
-		for quesId in quesIds:
-			gts[quesId] = self.vqa.qa[quesId]
-			res[quesId] = self.vqaRes.qa[quesId]
-
-		# =================================================
-		# Compute accuracy
-		# =================================================
-		accQA       = []
-		accQuesType = {}
-		accAnsType  = {}
-		# print "computing accuracy"
-		step = 0
-		for quesId in quesIds:
-			for ansDic in gts[quesId]['answers']:
-				ansDic['answer'] = ansDic['answer'].replace('\n', ' ')
-				ansDic['answer'] = ansDic['answer'].replace('\t', ' ')
-				ansDic['answer'] = ansDic['answer'].strip()
-			resAns = res[quesId]['answer']
-			resAns = resAns.replace('\n', ' ')
-			resAns = resAns.replace('\t', ' ')
-			resAns = resAns.strip()
-			gtAcc = []
-			gtAnswers = [ans['answer'] for ans in gts[quesId]['answers']]
-
-			if len(set(gtAnswers)) > 1:
-				for ansDic in gts[quesId]['answers']:
-					ansDic['answer'] = self.processPunctuation(ansDic['answer'])
-					ansDic['answer'] = self.processDigitArticle(ansDic['answer'])
-				resAns = self.processPunctuation(resAns)
-				resAns = self.processDigitArticle(resAns)
-
-			for gtAnsDatum in gts[quesId]['answers']:
-				otherGTAns = [item for item in gts[quesId]['answers'] if item!=gtAnsDatum]
-				matchingAns = [item for item in otherGTAns if item['answer'].lower()==resAns.lower()]
-				acc = min(1, float(len(matchingAns))/3)
-				gtAcc.append(acc)
-			quesType    = gts[quesId]['question_type']
-			ansType     = gts[quesId]['answer_type']
-			avgGTAcc = float(sum(gtAcc))/len(gtAcc)
-			accQA.append(avgGTAcc)
-			if quesType not in accQuesType:
-				accQuesType[quesType] = []
-			accQuesType[quesType].append(avgGTAcc)
-			if ansType not in accAnsType:
-				accAnsType[ansType] = []
-			accAnsType[ansType].append(avgGTAcc)
-			self.setEvalQA(quesId, avgGTAcc)
-			self.setEvalQuesType(quesId, quesType, avgGTAcc)
-			self.setEvalAnsType(quesId, ansType, avgGTAcc)
-			if step%100 == 0:
-				self.updateProgress(step/float(len(quesIds)))
-			step = step + 1
-
-		self.setAccuracy(accQA, accQuesType, accAnsType)
-		# print "Done computing accuracy"
-
-	def processPunctuation(self, inText):
-		outText = inText
-		for p in self.punct:
-			if (p + ' ' in inText or ' ' + p in inText) or (re.search(self.commaStrip, inText) != None):
-				outText = outText.replace(p, '')
-			else:
-				outText = outText.replace(p, ' ')
-		outText = self.periodStrip.sub("",
-									  outText,
-									  re.UNICODE)
-		return outText
-
-	def processDigitArticle(self, inText):
-		outText = []
-		tempText = inText.lower().split()
-		for word in tempText:
-			word = self.manualMap.setdefault(word, word)
-			if word not in self.articles:
-				outText.append(word)
-			else:
-				pass
-		for wordId, word in enumerate(outText):
-			if word in self.contractions:
-				outText[wordId] = self.contractions[word]
-		outText = ' '.join(outText)
-		return outText
-
-	def setAccuracy(self, accQA, accQuesType, accAnsType):
-		self.accuracy['overall']         = round(100*float(sum(accQA))/len(accQA), self.n)
-		self.accuracy['perQuestionType'] = {quesType: round(100*float(sum(accQuesType[quesType]))/len(accQuesType[quesType]), self.n) for quesType in accQuesType}
-		self.accuracy['perAnswerType']   = {ansType:  round(100*float(sum(accAnsType[ansType]))/len(accAnsType[ansType]), self.n) for ansType in accAnsType}
-
-	def setEvalQA(self, quesId, acc):
-		self.evalQA[quesId] = round(100*acc, self.n)
-
-	def setEvalQuesType(self, quesId, quesType, acc):
-		if quesType not in self.evalQuesType:
-			self.evalQuesType[quesType] = {}
-		self.evalQuesType[quesType][quesId] = round(100*acc, self.n)
-
-	def setEvalAnsType(self, quesId, ansType, acc):
-		if ansType not in self.evalAnsType:
-			self.evalAnsType[ansType] = {}
-		self.evalAnsType[ansType][quesId] = round(100*acc, self.n)
-
-	def updateProgress(self, progress):
-		barLength = 20
-		status = ""
-		if isinstance(progress, int):
-			progress = float(progress)
-		if not isinstance(progress, float):
-			progress = 0
-			status = "error: progress var must be float\r\n"
-		if progress < 0:
-			progress = 0
-			status = "Halt...\r\n"
-		if progress >= 1:
-			progress = 1
-			status = "Done...\r\n"
-		block = int(round(barLength*progress))
-		text = "\rFinshed Percent: [{0}] {1}% {2}".format( "#"*block + "-"*(barLength-block), int(progress*100), status)
-		sys.stdout.write(text)
-		sys.stdout.flush()

minigpt4/common/vqa_tools/VQA/PythonHelperTools/vqaDemo.py

@@ -1,73 +0,0 @@
-# coding: utf-8
-
-from vqaTools.vqa import VQA
-import random
-import skimage.io as io
-import matplotlib.pyplot as plt
-import os
-
-dataDir		='../../VQA'
-versionType ='v2_' # this should be '' when using VQA v2.0 dataset
-taskType    ='OpenEnded' # 'OpenEnded' only for v2.0. 'OpenEnded' or 'MultipleChoice' for v1.0
-dataType    ='mscoco'  # 'mscoco' only for v1.0. 'mscoco' for real and 'abstract_v002' for abstract for v1.0.
-dataSubType ='train2014'
-annFile     ='%s/Annotations/%s%s_%s_annotations.json'%(dataDir, versionType, dataType, dataSubType)
-quesFile    ='%s/Questions/%s%s_%s_%s_questions.json'%(dataDir, versionType, taskType, dataType, dataSubType)
-imgDir 		= '%s/Images/%s/%s/' %(dataDir, dataType, dataSubType)
-
-# initialize VQA api for QA annotations
-vqa=VQA(annFile, quesFile)
-
-# load and display QA annotations for given question types
-"""
-All possible quesTypes for abstract and mscoco has been provided in respective text files in ../QuestionTypes/ folder.
-"""
-annIds = vqa.getQuesIds(quesTypes='how many');   
-anns = vqa.loadQA(annIds)
-randomAnn = random.choice(anns)
-vqa.showQA([randomAnn])
-imgId = randomAnn['image_id']
-imgFilename = 'COCO_' + dataSubType + '_'+ str(imgId).zfill(12) + '.jpg'
-if os.path.isfile(imgDir + imgFilename):
-	I = io.imread(imgDir + imgFilename)
-	plt.imshow(I)
-	plt.axis('off')
-	plt.show()
-
-# load and display QA annotations for given answer types
-"""
-ansTypes can be one of the following
-yes/no
-number
-other
-"""
-annIds = vqa.getQuesIds(ansTypes='yes/no');   
-anns = vqa.loadQA(annIds)
-randomAnn = random.choice(anns)
-vqa.showQA([randomAnn])
-imgId = randomAnn['image_id']
-imgFilename = 'COCO_' + dataSubType + '_'+ str(imgId).zfill(12) + '.jpg'
-if os.path.isfile(imgDir + imgFilename):
-	I = io.imread(imgDir + imgFilename)
-	plt.imshow(I)
-	plt.axis('off')
-	plt.show()
-
-# load and display QA annotations for given images
-"""
-Usage: vqa.getImgIds(quesIds=[], quesTypes=[], ansTypes=[])
-Above method can be used to retrieve imageIds for given question Ids or given question types or given answer types.
-"""
-ids = vqa.getImgIds()
-annIds = vqa.getQuesIds(imgIds=random.sample(ids,5));  
-anns = vqa.loadQA(annIds)
-randomAnn = random.choice(anns)
-vqa.showQA([randomAnn])  
-imgId = randomAnn['image_id']
-imgFilename = 'COCO_' + dataSubType + '_'+ str(imgId).zfill(12) + '.jpg'
-if os.path.isfile(imgDir + imgFilename):
-	I = io.imread(imgDir + imgFilename)
-	plt.imshow(I)
-	plt.axis('off')
-	plt.show()
-

minigpt4/common/vqa_tools/VQA/PythonHelperTools/vqaTools/__init__.py

@@ -1 +0,0 @@
-__author__ = 'aagrawal'

minigpt4/common/vqa_tools/VQA/PythonHelperTools/vqaTools/vqa.py

@@ -1,179 +0,0 @@
-__author__ = 'aagrawal'
-__version__ = '0.9'
-
-# Interface for accessing the VQA dataset.
-
-# This code is based on the code written by Tsung-Yi Lin for MSCOCO Python API available at the following link: 
-# (https://github.com/pdollar/coco/blob/master/PythonAPI/pycocotools/coco.py).
-
-# The following functions are defined:
-#  VQA        - VQA class that loads VQA annotation file and prepares data structures.
-#  getQuesIds - Get question ids that satisfy given filter conditions.
-#  getImgIds  - Get image ids that satisfy given filter conditions.
-#  loadQA     - Load questions and answers with the specified question ids.
-#  showQA     - Display the specified questions and answers.
-#  loadRes    - Load result file and create result object.
-
-# Help on each function can be accessed by: "help(COCO.function)"
-
-import json
-import datetime
-import copy
-
-
-class VQA:
-    def __init__(self, annotation_file=None, question_file=None):
-        """
-           Constructor of VQA helper class for reading and visualizing questions and answers.
-        :param annotation_file (str): location of VQA annotation file
-        :return:
-        """
-        # load dataset
-        self.dataset = {}
-        self.questions = {}
-        self.qa = {}
-        self.qqa = {}
-        self.imgToQA = {}
-        if not annotation_file == None and not question_file == None:
-            # print 'loading VQA annotations and questions into memory...'
-            time_t = datetime.datetime.utcnow()
-            dataset = json.load(open(annotation_file, 'r'))
-            questions = json.load(open(question_file, 'r'))
-            # print datetime.datetime.utcnow() - time_t
-            self.dataset = dataset
-            self.questions = questions
-            self.createIndex()
-
-    def createIndex(self):
-        imgToQA = {ann['image_id']: [] for ann in self.dataset['annotations']}
-        qa = {ann['question_id']: [] for ann in self.dataset['annotations']}
-        qqa = {ann['question_id']: [] for ann in self.dataset['annotations']}
-        for ann in self.dataset['annotations']:
-            imgToQA[ann['image_id']] += [ann]
-            qa[ann['question_id']] = ann
-        for ques in self.questions['questions']:
-            qqa[ques['question_id']] = ques
-        # print 'index created!'
-
-        # create class members
-        self.qa = qa
-        self.qqa = qqa
-        self.imgToQA = imgToQA
-
-    def info(self):
-        """
-        Print information about the VQA annotation file.
-        :return:
-        """
-
-    # for key, value in self.datset['info'].items():
-    # 	print '%s: %s'%(key, value)
-
-    def getQuesIds(self, imgIds=[], quesTypes=[], ansTypes=[]):
-        """
-        Get question ids that satisfy given filter conditions. default skips that filter
-        :param 	imgIds    (int array)   : get question ids for given imgs
-                quesTypes (str array)   : get question ids for given question types
-                ansTypes  (str array)   : get question ids for given answer types
-        :return:    ids   (int array)   : integer array of question ids
-        """
-        imgIds = imgIds if type(imgIds) == list else [imgIds]
-        quesTypes = quesTypes if type(quesTypes) == list else [quesTypes]
-        ansTypes = ansTypes if type(ansTypes) == list else [ansTypes]
-
-        if len(imgIds) == len(quesTypes) == len(ansTypes) == 0:
-            anns = self.dataset['annotations']
-        else:
-            if not len(imgIds) == 0:
-                anns = sum([self.imgToQA[imgId] for imgId in imgIds if imgId in self.imgToQA], [])
-            else:
-                anns = self.dataset['annotations']
-            anns = anns if len(quesTypes) == 0 else [ann for ann in anns if ann['question_type'] in quesTypes]
-            anns = anns if len(ansTypes) == 0 else [ann for ann in anns if ann['answer_type'] in ansTypes]
-        ids = [ann['question_id'] for ann in anns]
-        return ids
-
-    def getImgIds(self, quesIds=[], quesTypes=[], ansTypes=[]):
-        """
-        Get image ids that satisfy given filter conditions. default skips that filter
-        :param quesIds   (int array)   : get image ids for given question ids
-               quesTypes (str array)   : get image ids for given question types
-               ansTypes  (str array)   : get image ids for given answer types
-        :return: ids     (int array)   : integer array of image ids
-        """
-        quesIds = quesIds if type(quesIds) == list else [quesIds]
-        quesTypes = quesTypes if type(quesTypes) == list else [quesTypes]
-        ansTypes = ansTypes if type(ansTypes) == list else [ansTypes]
-
-        if len(quesIds) == len(quesTypes) == len(ansTypes) == 0:
-            anns = self.dataset['annotations']
-        else:
-            if not len(quesIds) == 0:
-                anns = sum([self.qa[quesId] for quesId in quesIds if quesId in self.qa], [])
-            else:
-                anns = self.dataset['annotations']
-            anns = anns if len(quesTypes) == 0 else [ann for ann in anns if ann['question_type'] in quesTypes]
-            anns = anns if len(ansTypes) == 0 else [ann for ann in anns if ann['answer_type'] in ansTypes]
-        ids = [ann['image_id'] for ann in anns]
-        return ids
-
-    def loadQA(self, ids=[]):
-        """
-        Load questions and answers with the specified question ids.
-        :param ids (int array)       : integer ids specifying question ids
-        :return: qa (object array)   : loaded qa objects
-        """
-        if type(ids) == list:
-            return [self.qa[id] for id in ids]
-        elif type(ids) == int:
-            return [self.qa[ids]]
-
-    def showQA(self, anns):
-        """
-        Display the specified annotations.
-        :param anns (array of object): annotations to display
-        :return: None
-        """
-        if len(anns) == 0:
-            return 0
-        for ann in anns:
-            quesId = ann['question_id']
-            print("Question: %s" % (self.qqa[quesId]['question']))
-            for ans in ann['answers']:
-                print("Answer %d: %s" % (ans['answer_id'], ans['answer']))
-
-    def loadRes(self, resFile, quesFile):
-        """
-        Load result file and return a result object.
-        :param   resFile (str)     : file name of result file
-        :return: res (obj)         : result api object
-        """
-        res = VQA()
-        res.questions = json.load(open(quesFile))
-        res.dataset['info'] = copy.deepcopy(self.questions['info'])
-        res.dataset['task_type'] = copy.deepcopy(self.questions['task_type'])
-        res.dataset['data_type'] = copy.deepcopy(self.questions['data_type'])
-        res.dataset['data_subtype'] = copy.deepcopy(self.questions['data_subtype'])
-        res.dataset['license'] = copy.deepcopy(self.questions['license'])
-
-        # print 'Loading and preparing results...     '
-        time_t = datetime.datetime.utcnow()
-        anns = json.load(open(resFile))
-        assert type(anns) == list, 'results is not an array of objects'
-        annsQuesIds = [ann['question_id'] for ann in anns]
-        assert set(annsQuesIds) == set(self.getQuesIds()), \
-            'Results do not correspond to current VQA set. Either the results do not have predictions for all question ids in annotation file or there is atleast one question id that does not belong to the question ids in the annotation file.'
-        for ann in anns:
-            quesId = ann['question_id']
-            if res.dataset['task_type'] == 'Multiple Choice':
-                assert ann['answer'] in self.qqa[quesId][
-                    'multiple_choices'], 'predicted answer is not one of the multiple choices'
-            qaAnn = self.qa[quesId]
-            ann['image_id'] = qaAnn['image_id']
-            ann['question_type'] = qaAnn['question_type']
-            ann['answer_type'] = qaAnn['answer_type']
-        # print 'DONE (t=%0.2fs)'%((datetime.datetime.utcnow() - time_t).total_seconds())
-
-        res.dataset['annotations'] = anns
-        res.createIndex()
-        return res

minigpt4/common/vqa_tools/VQA/QuestionTypes/abstract_v002_question_types.txt

@@ -1,81 +0,0 @@
-how many
-what color is the
-is the
-where is the
-what
-what is
-are the
-what is the
-is there a
-does the
-is the woman
-is the man
-what is on the
-is it
-is the girl
-is the boy
-is the dog
-are they
-who is
-what kind of
-what color are the
-what is in the
-what is the man
-is there
-what is the woman
-what are the
-what is the boy
-are there
-what is the girl
-is this
-how
-which
-how many people are
-is the cat
-why is the
-are
-will the
-what type of
-what is the dog
-do
-is she
-does
-do the
-is
-is the baby
-are there any
-is the lady
-can
-what animal is
-where are the
-is the sun
-what are they
-did the
-what is the cat
-what is the lady
-how many clouds are
-is that
-is the little girl
-is he
-are these
-how many trees are
-how many pillows
-are the people
-why
-is the young
-how many windows are
-is this a
-what is the little
-is the tv
-how many animals are
-who
-how many pictures
-how many plants are
-how many birds are
-what color is
-what is the baby
-is anyone
-what color
-how many bushes
-is the old man
-none of the above

minigpt4/common/vqa_tools/VQA/QuestionTypes/mscoco_question_types.txt

@@ -1,65 +0,0 @@
-how many
-is the
-what
-what color is the
-what is the
-is this
-is this a
-what is
-are the
-what kind of
-is there a
-what type of
-is it
-what are the
-where is the
-is there
-does the
-what color are the
-are these
-are there
-which
-is
-what is the man
-is the man
-are
-how
-does this
-what is on the
-what does the
-how many people are
-what is in the
-what is this
-do
-what are
-are they
-what time
-what sport is
-are there any
-is he
-what color is
-why
-where are the
-what color
-who is
-what animal is
-is the woman
-is this an
-do you
-how many people are in
-what room is
-has
-is this person
-what is the woman
-can you
-why is the
-is the person
-what is the color of the
-what is the person
-could
-was
-is that a
-what number is
-what is the name
-what brand
-none of the above

minigpt4/common/vqa_tools/VQA/README.md

@@ -1,80 +0,0 @@
-Python API and Evaluation Code for v2.0 and v1.0 releases of the VQA dataset.
-===================
-## VQA v2.0 release ##
-This release consists of
-- Real 
-	- 82,783 MS COCO training images, 40,504 MS COCO validation images and 81,434 MS COCO testing images (images are obtained from [MS COCO website] (http://mscoco.org/dataset/#download))
-	- 443,757 questions for training, 214,354 questions for validation and 447,793 questions for testing
-	- 4,437,570 answers for training and 2,143,540 answers for validation (10 per question)
-
-There is only one type of task
-- Open-ended task
-
-## VQA v1.0 release ##
-This release consists of
-- Real 
-	- 82,783 MS COCO training images, 40,504 MS COCO validation images and 81,434 MS COCO testing images (images are obtained from [MS COCO website] (http://mscoco.org/dataset/#download))
-	- 248,349 questions for training, 121,512 questions for validation and 244,302 questions for testing (3 per image)
-	- 2,483,490 answers for training and 1,215,120 answers for validation (10 per question)
-- Abstract
-	- 20,000 training images, 10,000 validation images and 20,000 MS COCO testing images
-	- 60,000 questions for training, 30,000 questions for validation and 60,000 questions for testing (3 per image)
-	- 600,000 answers for training and 300,000 answers for validation (10 per question)
-
-There are two types of tasks
-- Open-ended task
-- Multiple-choice task (18 choices per question)
-
-## Requirements ##
-- python 2.7
-- scikit-image (visit [this page](http://scikit-image.org/docs/dev/install.html) for installation)
-- matplotlib (visit [this page](http://matplotlib.org/users/installing.html) for installation)
-
-## Files ##
-./Questions
-- For v2.0, download the question files from the [VQA download page](http://www.visualqa.org/download.html), extract them and place in this folder.
-- For v1.0, both real and abstract, question files can be found on the [VQA v1 download page](http://www.visualqa.org/vqa_v1_download.html).
-- Question files from Beta v0.9 release (123,287 MSCOCO train and val images, 369,861 questions, 3,698,610 answers) can be found below
-	- [training question files](http://visualqa.org/data/mscoco/prev_rel/Beta_v0.9/Questions_Train_mscoco.zip)
-	- [validation question files](http://visualqa.org/data/mscoco/prev_rel/Beta_v0.9/Questions_Val_mscoco.zip)
-- Question files from Beta v0.1 release (10k MSCOCO images, 30k questions, 300k answers) can be found [here](http://visualqa.org/data/mscoco/prev_rel/Beta_v0.1/Questions_Train_mscoco.zip).
-
-./Annotations
-- For v2.0, download the annotations files from the [VQA download page](http://www.visualqa.org/download.html), extract them and place in this folder.
-- For v1.0, for both real and abstract, annotation files can be found on the [VQA v1 download page](http://www.visualqa.org/vqa_v1_download.html).
-- Annotation files from Beta v0.9 release (123,287 MSCOCO train and val images, 369,861 questions, 3,698,610 answers) can be found below
-	- [training annotation files](http://visualqa.org/data/mscoco/prev_rel/Beta_v0.9/Annotations_Train_mscoco.zip)
-	- [validation annotation files](http://visualqa.org/data/mscoco/prev_rel/Beta_v0.9/Annotations_Val_mscoco.zip)
-- Annotation files from Beta v0.1 release (10k MSCOCO images, 30k questions, 300k answers) can be found [here](http://visualqa.org/data/mscoco/prev_rel/Beta_v0.1/Annotations_Train_mscoco.zip).
-
-./Images
-- For real, create a directory with name mscoco inside this directory. For each of train, val and test, create directories with names train2014, val2014 and test2015 respectively inside mscoco directory, download respective images from [MS COCO website](http://mscoco.org/dataset/#download) and place them in respective folders.
-- For abstract, create a directory with name abstract_v002 inside this directory. For each of train, val and test, create directories with names train2015, val2015 and test2015 respectively inside abstract_v002 directory, download respective images from [VQA download page](http://www.visualqa.org/download.html) and place them in respective folders.
-
-./PythonHelperTools
-- This directory contains the Python API to read and visualize the VQA dataset
-- vqaDemo.py (demo script)
-- vqaTools (API to read and visualize data)
-
-./PythonEvaluationTools
-- This directory contains the Python evaluation code
-- vqaEvalDemo.py (evaluation demo script)
-- vqaEvaluation (evaluation code)
-
-./Results
-- OpenEnded_mscoco_train2014_fake_results.json (an example of a fake results file for v1.0 to run the demo)
-- Visit [VQA evaluation page] (http://visualqa.org/evaluation) for more details.
-
-./QuestionTypes
-- This directory contains the following lists of question types for both real and abstract questions (question types are unchanged from v1.0 to v2.0). In a list, if there are question types of length n+k and length n with the same first n words, then the question type of length n does not include questions that belong to the question type of length n+k.
-- mscoco_question_types.txt
-- abstract_v002_question_types.txt
-
-## References ##
-- [VQA: Visual Question Answering](http://visualqa.org/)
-- [Microsoft COCO](http://mscoco.org/)
-
-## Developers ##
-- Aishwarya Agrawal (Virginia Tech)
-- Code for API is based on [MSCOCO API code](https://github.com/pdollar/coco).
-- The format of the code for evaluation is based on [MSCOCO evaluation code](https://github.com/tylin/coco-caption).

minigpt4/common/vqa_tools/VQA/license.txt

@@ -1,30 +0,0 @@
-Copyright (c) 2014, Aishwarya Agrawal
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met: 
-
-1. Redistributions of source code must retain the above copyright notice, this
-   list of conditions and the following disclaimer. 
-2. Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution. 
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
-FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-The views and conclusions contained in the software and documentation are
-those
-of the authors and should not be interpreted as representing official
-policies, 
-either expressed or implied, of the FreeBSD Project.

minigpt4/common/vqa_tools/__init__.py

@@ -1,8 +0,0 @@
-"""
- 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
-"""
-
-__author__ = "aagrawal"

minigpt4/common/vqa_tools/vqa.py

@@ -1,211 +0,0 @@
-"""
- 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
-"""
-
-__author__ = "aagrawal"
-__version__ = "0.9"
-
-# Interface for accessing the VQA dataset.
-
-# This code is based on the code written by Tsung-Yi Lin for MSCOCO Python API available at the following link:
-# (https://github.com/pdollar/coco/blob/master/PythonAPI/pycocotools/coco.py).
-
-# The following functions are defined:
-#  VQA        - VQA class that loads VQA annotation file and prepares data structures.
-#  getQuesIds - Get question ids that satisfy given filter conditions.
-#  getImgIds  - Get image ids that satisfy given filter conditions.
-#  loadQA     - Load questions and answers with the specified question ids.
-#  showQA     - Display the specified questions and answers.
-#  loadRes    - Load result file and create result object.
-
-# Help on each function can be accessed by: "help(COCO.function)"
-
-import json
-import datetime
-import copy
-
-
-class VQA:
-    def __init__(self, annotation_file=None, question_file=None):
-        """
-        Constructor of VQA helper class for reading and visualizing questions and answers.
-        :param annotation_file (str): location of VQA annotation file
-        :return:
-        """
-        # load dataset
-        self.dataset = {}
-        self.questions = {}
-        self.qa = {}
-        self.qqa = {}
-        self.imgToQA = {}
-        if not annotation_file == None and not question_file == None:
-            print("loading VQA annotations and questions into memory...")
-            time_t = datetime.datetime.utcnow()
-            dataset = json.load(open(annotation_file, "r"))
-            questions = json.load(open(question_file, "r"))
-            self.dataset = dataset
-            self.questions = questions
-            self.createIndex()
-
-    def createIndex(self):
-        # create index
-        print("creating index...")
-        imgToQA = {ann["image_id"]: [] for ann in self.dataset["annotations"]}
-        qa = {ann["question_id"]: [] for ann in self.dataset["annotations"]}
-        qqa = {ann["question_id"]: [] for ann in self.dataset["annotations"]}
-        for ann in self.dataset["annotations"]:
-            imgToQA[ann["image_id"]] += [ann]
-            qa[ann["question_id"]] = ann
-        for ques in self.questions["questions"]:
-            qqa[ques["question_id"]] = ques
-        print("index created!")
-
-        # create class members
-        self.qa = qa
-        self.qqa = qqa
-        self.imgToQA = imgToQA
-
-    def info(self):
-        """
-        Print information about the VQA annotation file.
-        :return:
-        """
-        for key, value in self.datset["info"].items():
-            print("%s: %s" % (key, value))
-
-    def getQuesIds(self, imgIds=[], quesTypes=[], ansTypes=[]):
-        """
-        Get question ids that satisfy given filter conditions. default skips that filter
-        :param 	imgIds    (int array)   : get question ids for given imgs
-                        quesTypes (str array)   : get question ids for given question types
-                        ansTypes  (str array)   : get question ids for given answer types
-        :return:    ids   (int array)   : integer array of question ids
-        """
-        imgIds = imgIds if type(imgIds) == list else [imgIds]
-        quesTypes = quesTypes if type(quesTypes) == list else [quesTypes]
-        ansTypes = ansTypes if type(ansTypes) == list else [ansTypes]
-
-        if len(imgIds) == len(quesTypes) == len(ansTypes) == 0:
-            anns = self.dataset["annotations"]
-        else:
-            if not len(imgIds) == 0:
-                anns = sum(
-                    [self.imgToQA[imgId] for imgId in imgIds if imgId in self.imgToQA],
-                    [],
-                )
-            else:
-                anns = self.dataset["annotations"]
-            anns = (
-                anns
-                if len(quesTypes) == 0
-                else [ann for ann in anns if ann["question_type"] in quesTypes]
-            )
-            anns = (
-                anns
-                if len(ansTypes) == 0
-                else [ann for ann in anns if ann["answer_type"] in ansTypes]
-            )
-        ids = [ann["question_id"] for ann in anns]
-        return ids
-
-    def getImgIds(self, quesIds=[], quesTypes=[], ansTypes=[]):
-        """
-         Get image ids that satisfy given filter conditions. default skips that filter
-         :param quesIds   (int array)   : get image ids for given question ids
-        quesTypes (str array)   : get image ids for given question types
-        ansTypes  (str array)   : get image ids for given answer types
-         :return: ids     (int array)   : integer array of image ids
-        """
-        quesIds = quesIds if type(quesIds) == list else [quesIds]
-        quesTypes = quesTypes if type(quesTypes) == list else [quesTypes]
-        ansTypes = ansTypes if type(ansTypes) == list else [ansTypes]
-
-        if len(quesIds) == len(quesTypes) == len(ansTypes) == 0:
-            anns = self.dataset["annotations"]
-        else:
-            if not len(quesIds) == 0:
-                anns = sum(
-                    [self.qa[quesId] for quesId in quesIds if quesId in self.qa], []
-                )
-            else:
-                anns = self.dataset["annotations"]
-            anns = (
-                anns
-                if len(quesTypes) == 0
-                else [ann for ann in anns if ann["question_type"] in quesTypes]
-            )
-            anns = (
-                anns
-                if len(ansTypes) == 0
-                else [ann for ann in anns if ann["answer_type"] in ansTypes]
-            )
-        ids = [ann["image_id"] for ann in anns]
-        return ids
-
-    def loadQA(self, ids=[]):
-        """
-        Load questions and answers with the specified question ids.
-        :param ids (int array)       : integer ids specifying question ids
-        :return: qa (object array)   : loaded qa objects
-        """
-        if type(ids) == list:
-            return [self.qa[id] for id in ids]
-        elif type(ids) == int:
-            return [self.qa[ids]]
-
-    def showQA(self, anns):
-        """
-        Display the specified annotations.
-        :param anns (array of object): annotations to display
-        :return: None
-        """
-        if len(anns) == 0:
-            return 0
-        for ann in anns:
-            quesId = ann["question_id"]
-            print("Question: %s" % (self.qqa[quesId]["question"]))
-            for ans in ann["answers"]:
-                print("Answer %d: %s" % (ans["answer_id"], ans["answer"]))
-
-    def loadRes(self, resFile, quesFile):
-        """
-        Load result file and return a result object.
-        :param   resFile (str)     : file name of result file
-        :return: res (obj)         : result api object
-        """
-        res = VQA()
-        res.questions = json.load(open(quesFile))
-        res.dataset["info"] = copy.deepcopy(self.questions["info"])
-        res.dataset["task_type"] = copy.deepcopy(self.questions["task_type"])
-        res.dataset["data_type"] = copy.deepcopy(self.questions["data_type"])
-        res.dataset["data_subtype"] = copy.deepcopy(self.questions["data_subtype"])
-        res.dataset["license"] = copy.deepcopy(self.questions["license"])
-
-        print("Loading and preparing results...     ")
-        time_t = datetime.datetime.utcnow()
-        anns = json.load(open(resFile))
-        assert type(anns) == list, "results is not an array of objects"
-        annsQuesIds = [ann["question_id"] for ann in anns]
-        assert set(annsQuesIds) == set(
-            self.getQuesIds()
-        ), "Results do not correspond to current VQA set. Either the results do not have predictions for all question ids in annotation file or there is atleast one question id that does not belong to the question ids in the annotation file."
-        for ann in anns:
-            quesId = ann["question_id"]
-            if res.dataset["task_type"] == "Multiple Choice":
-                assert (
-                    ann["answer"] in self.qqa[quesId]["multiple_choices"]
-                ), "predicted answer is not one of the multiple choices"
-            qaAnn = self.qa[quesId]
-            ann["image_id"] = qaAnn["image_id"]
-            ann["question_type"] = qaAnn["question_type"]
-            ann["answer_type"] = qaAnn["answer_type"]
-        print(
-            "DONE (t=%0.2fs)" % ((datetime.datetime.utcnow() - time_t).total_seconds())
-        )
-
-        res.dataset["annotations"] = anns
-        res.createIndex()
-        return res

minigpt4/common/vqa_tools/vqa_eval.py

@@ -1,324 +0,0 @@
-"""
- 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
-"""
-
-# coding=utf-8
-
-__author__ = "aagrawal"
-
-# This code is based on the code written by Tsung-Yi Lin for MSCOCO Python API available at the following link:
-# (https://github.com/tylin/coco-caption/blob/master/pycocoevalcap/eval.py).
-import sys
-import re
-
-
-class VQAEval:
-    def __init__(self, vqa=None, vqaRes=None, n=2):
-        self.n = n
-        self.accuracy = {}
-        self.evalQA = {}
-        self.evalQuesType = {}
-        self.evalAnsType = {}
-        self.vqa = vqa
-        self.vqaRes = vqaRes
-        if vqa is not None:
-            self.params = {"question_id": vqa.getQuesIds()}
-        self.contractions = {
-            "aint": "ain't",
-            "arent": "aren't",
-            "cant": "can't",
-            "couldve": "could've",
-            "couldnt": "couldn't",
-            "couldn'tve": "couldn't've",
-            "couldnt've": "couldn't've",
-            "didnt": "didn't",
-            "doesnt": "doesn't",
-            "dont": "don't",
-            "hadnt": "hadn't",
-            "hadnt've": "hadn't've",
-            "hadn'tve": "hadn't've",
-            "hasnt": "hasn't",
-            "havent": "haven't",
-            "hed": "he'd",
-            "hed've": "he'd've",
-            "he'dve": "he'd've",
-            "hes": "he's",
-            "howd": "how'd",
-            "howll": "how'll",
-            "hows": "how's",
-            "Id've": "I'd've",
-            "I'dve": "I'd've",
-            "Im": "I'm",
-            "Ive": "I've",
-            "isnt": "isn't",
-            "itd": "it'd",
-            "itd've": "it'd've",
-            "it'dve": "it'd've",
-            "itll": "it'll",
-            "let's": "let's",
-            "maam": "ma'am",
-            "mightnt": "mightn't",
-            "mightnt've": "mightn't've",
-            "mightn'tve": "mightn't've",
-            "mightve": "might've",
-            "mustnt": "mustn't",
-            "mustve": "must've",
-            "neednt": "needn't",
-            "notve": "not've",
-            "oclock": "o'clock",
-            "oughtnt": "oughtn't",
-            "ow's'at": "'ow's'at",
-            "'ows'at": "'ow's'at",
-            "'ow'sat": "'ow's'at",
-            "shant": "shan't",
-            "shed've": "she'd've",
-            "she'dve": "she'd've",
-            "she's": "she's",
-            "shouldve": "should've",
-            "shouldnt": "shouldn't",
-            "shouldnt've": "shouldn't've",
-            "shouldn'tve": "shouldn't've",
-            "somebody'd": "somebodyd",
-            "somebodyd've": "somebody'd've",
-            "somebody'dve": "somebody'd've",
-            "somebodyll": "somebody'll",
-            "somebodys": "somebody's",
-            "someoned": "someone'd",
-            "someoned've": "someone'd've",
-            "someone'dve": "someone'd've",
-            "someonell": "someone'll",
-            "someones": "someone's",
-            "somethingd": "something'd",
-            "somethingd've": "something'd've",
-            "something'dve": "something'd've",
-            "somethingll": "something'll",
-            "thats": "that's",
-            "thered": "there'd",
-            "thered've": "there'd've",
-            "there'dve": "there'd've",
-            "therere": "there're",
-            "theres": "there's",
-            "theyd": "they'd",
-            "theyd've": "they'd've",
-            "they'dve": "they'd've",
-            "theyll": "they'll",
-            "theyre": "they're",
-            "theyve": "they've",
-            "twas": "'twas",
-            "wasnt": "wasn't",
-            "wed've": "we'd've",
-            "we'dve": "we'd've",
-            "weve": "we've",
-            "werent": "weren't",
-            "whatll": "what'll",
-            "whatre": "what're",
-            "whats": "what's",
-            "whatve": "what've",
-            "whens": "when's",
-            "whered": "where'd",
-            "wheres": "where's",
-            "whereve": "where've",
-            "whod": "who'd",
-            "whod've": "who'd've",
-            "who'dve": "who'd've",
-            "wholl": "who'll",
-            "whos": "who's",
-            "whove": "who've",
-            "whyll": "why'll",
-            "whyre": "why're",
-            "whys": "why's",
-            "wont": "won't",
-            "wouldve": "would've",
-            "wouldnt": "wouldn't",
-            "wouldnt've": "wouldn't've",
-            "wouldn'tve": "wouldn't've",
-            "yall": "y'all",
-            "yall'll": "y'all'll",
-            "y'allll": "y'all'll",
-            "yall'd've": "y'all'd've",
-            "y'alld've": "y'all'd've",
-            "y'all'dve": "y'all'd've",
-            "youd": "you'd",
-            "youd've": "you'd've",
-            "you'dve": "you'd've",
-            "youll": "you'll",
-            "youre": "you're",
-            "youve": "you've",
-        }
-        self.manualMap = {
-            "none": "0",
-            "zero": "0",
-            "one": "1",
-            "two": "2",
-            "three": "3",
-            "four": "4",
-            "five": "5",
-            "six": "6",
-            "seven": "7",
-            "eight": "8",
-            "nine": "9",
-            "ten": "10",
-        }
-        self.articles = ["a", "an", "the"]
-
-        self.periodStrip = re.compile("(?!<=\d)(\.)(?!\d)")
-        self.commaStrip = re.compile("(\d)(,)(\d)")
-        self.punct = [
-            ";",
-            r"/",
-            "[",
-            "]",
-            '"',
-            "{",
-            "}",
-            "(",
-            ")",
-            "=",
-            "+",
-            "\\",
-            "_",
-            "-",
-            ">",
-            "<",
-            "@",
-            "`",
-            ",",
-            "?",
-            "!",
-        ]
-
-    def evaluate(self, quesIds=None):
-        if quesIds == None:
-            quesIds = [quesId for quesId in self.params["question_id"]]
-        gts = {}
-        res = {}
-        for quesId in quesIds:
-            gts[quesId] = self.vqa.qa[quesId]
-            res[quesId] = self.vqaRes.qa[quesId]
-
-        # =================================================
-        # Compute accuracy
-        # =================================================
-        accQA = []
-        accQuesType = {}
-        accAnsType = {}
-        print("computing accuracy")
-        step = 0
-        for quesId in quesIds:
-            resAns = res[quesId]["answer"]
-            resAns = resAns.replace("\n", " ")
-            resAns = resAns.replace("\t", " ")
-            resAns = resAns.strip()
-            resAns = self.processPunctuation(resAns)
-            resAns = self.processDigitArticle(resAns)
-            gtAcc = []
-            gtAnswers = [ans["answer"] for ans in gts[quesId]["answers"]]
-            if len(set(gtAnswers)) > 1:
-                for ansDic in gts[quesId]["answers"]:
-                    ansDic["answer"] = self.processPunctuation(ansDic["answer"])
-            for gtAnsDatum in gts[quesId]["answers"]:
-                otherGTAns = [
-                    item for item in gts[quesId]["answers"] if item != gtAnsDatum
-                ]
-                matchingAns = [item for item in otherGTAns if item["answer"] == resAns]
-                acc = min(1, float(len(matchingAns)) / 3)
-                gtAcc.append(acc)
-            quesType = gts[quesId]["question_type"]
-            ansType = gts[quesId]["answer_type"]
-            avgGTAcc = float(sum(gtAcc)) / len(gtAcc)
-            accQA.append(avgGTAcc)
-            if quesType not in accQuesType:
-                accQuesType[quesType] = []
-            accQuesType[quesType].append(avgGTAcc)
-            if ansType not in accAnsType:
-                accAnsType[ansType] = []
-            accAnsType[ansType].append(avgGTAcc)
-            self.setEvalQA(quesId, avgGTAcc)
-            self.setEvalQuesType(quesId, quesType, avgGTAcc)
-            self.setEvalAnsType(quesId, ansType, avgGTAcc)
-            if step % 100 == 0:
-                self.updateProgress(step / float(len(quesIds)))
-            step = step + 1
-
-        self.setAccuracy(accQA, accQuesType, accAnsType)
-        print("Done computing accuracy")
-
-    def processPunctuation(self, inText):
-        outText = inText
-        for p in self.punct:
-            if (p + " " in inText or " " + p in inText) or (
-                re.search(self.commaStrip, inText) != None
-            ):
-                outText = outText.replace(p, "")
-            else:
-                outText = outText.replace(p, " ")
-        outText = self.periodStrip.sub("", outText, re.UNICODE)
-        return outText
-
-    def processDigitArticle(self, inText):
-        outText = []
-        tempText = inText.lower().split()
-        for word in tempText:
-            word = self.manualMap.setdefault(word, word)
-            if word not in self.articles:
-                outText.append(word)
-            else:
-                pass
-        for wordId, word in enumerate(outText):
-            if word in self.contractions:
-                outText[wordId] = self.contractions[word]
-        outText = " ".join(outText)
-        return outText
-
-    def setAccuracy(self, accQA, accQuesType, accAnsType):
-        self.accuracy["overall"] = round(100 * float(sum(accQA)) / len(accQA), self.n)
-        self.accuracy["perQuestionType"] = {
-            quesType: round(
-                100 * float(sum(accQuesType[quesType])) / len(accQuesType[quesType]),
-                self.n,
-            )
-            for quesType in accQuesType
-        }
-        self.accuracy["perAnswerType"] = {
-            ansType: round(
-                100 * float(sum(accAnsType[ansType])) / len(accAnsType[ansType]), self.n
-            )
-            for ansType in accAnsType
-        }
-
-    def setEvalQA(self, quesId, acc):
-        self.evalQA[quesId] = round(100 * acc, self.n)
-
-    def setEvalQuesType(self, quesId, quesType, acc):
-        if quesType not in self.evalQuesType:
-            self.evalQuesType[quesType] = {}
-        self.evalQuesType[quesType][quesId] = round(100 * acc, self.n)
-
-    def setEvalAnsType(self, quesId, ansType, acc):
-        if ansType not in self.evalAnsType:
-            self.evalAnsType[ansType] = {}
-        self.evalAnsType[ansType][quesId] = round(100 * acc, self.n)
-
-    def updateProgress(self, progress):
-        barLength = 20
-        status = ""
-        if isinstance(progress, int):
-            progress = float(progress)
-        if not isinstance(progress, float):
-            progress = 0
-            status = "error: progress var must be float\r\n"
-        if progress < 0:
-            progress = 0
-            status = "Halt...\r\n"
-        if progress >= 1:
-            progress = 1
-            status = "Done...\r\n"
-        block = int(round(barLength * progress))
-        text = "\rFinshed Percent: [{0}] {1}% {2}".format(
-            "#" * block + "-" * (barLength - block), int(progress * 100), status
-        )
-        sys.stdout.write(text)
-        sys.stdout.flush()

minigpt4/configs/datasets/cc_combine/align.yaml

@@ -1,16 +0,0 @@
- # 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
-
-datasets:
-  cc_align:
-    data_type: images
-    build_info:
-      # Be careful not to append minus sign (-) before split to avoid itemizing
-      annotations:
-        train:
-          url: placeholder
-          storage: /ibex/project/c2133/blip_dataset/image_alignment_cc/filter_cap.json
-      images:
-        storage: /ibex/project/c2133/blip_dataset/image_alignment_cc/

minigpt4/configs/datasets/cc_combine/defaults.yaml

@@ -1,11 +0,0 @@
- # 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
-
-datasets:
-  cc_combine:
-    data_type: images
-    build_info:
-      # Be careful not to append minus sign (-) before split to avoid itemizing
-      storage: /ibex/project/c2133/blip_dataset/cc3m/cc3m_cc12m_sbu/{00000..01255}.tar

minigpt4/configs/datasets/laion/defaults.yaml

@@ -1,13 +0,0 @@
- # 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
-
-datasets:
-  laion:
-
-    data_type: images
-
-    build_info:
-      # Be careful not to append minus sign (-) before split to avoid itemizing
-      storage: /ibex/project/c2133/blip_dataset/laion_1b/laion_gpu/{00000..10488}.tar

minigpt4/configs/default.yaml

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

minigpt4/configs/models/minigpt4_vicuna0.yaml

@@ -1,32 +0,0 @@
-model:
-  arch: minigpt4
-
-  # 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: "wangrongsheng/MiniGPT-4-LLaMA-7B"
-
-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"

minigpt4/conversation/conversation.py

@@ -1,233 +0,0 @@
-import argparse
-import time
-from threading import Thread
-from PIL import Image
-
-import torch
-from transformers import AutoTokenizer, AutoModelForCausalLM, LlamaTokenizer
-from transformers import StoppingCriteria, StoppingCriteriaList, TextIteratorStreamer
-
-import dataclasses
-from enum import auto, Enum
-from typing import List, Tuple, Any
-
-from minigpt4.common.registry import registry
-
-
-class SeparatorStyle(Enum):
-    """Different separator style."""
-    SINGLE = auto()
-    TWO = auto()
-
-
-@dataclasses.dataclass
-class Conversation:
-    """A class that keeps all conversation history."""
-    system: str
-    roles: List[str]
-    messages: List[List[str]]
-    offset: int
-    # system_img: List[Image.Image] = []
-    sep_style: SeparatorStyle = SeparatorStyle.SINGLE
-    sep: str = "###"
-    sep2: str = None
-
-    skip_next: bool = False
-    conv_id: Any = None
-
-    def get_prompt(self):
-        if self.sep_style == SeparatorStyle.SINGLE:
-            ret = self.system + self.sep
-            for role, message in self.messages:
-                if message:
-                    ret += role + message + self.sep
-                else:
-                    ret += role
-            return ret
-        elif self.sep_style == SeparatorStyle.TWO:
-            seps = [self.sep, self.sep2]
-            ret = self.system + seps[0]
-            for i, (role, message) in enumerate(self.messages):
-                if message:
-                    ret += role + message + seps[i % 2]
-                else:
-                    ret += role
-            return ret
-        else:
-            raise ValueError(f"Invalid style: {self.sep_style}")
-
-    def append_message(self, role, message):
-        self.messages.append([role, message])
-
-    def to_gradio_chatbot(self):
-        ret = []
-        for i, (role, msg) in enumerate(self.messages[self.offset:]):
-            if i % 2 == 0:
-                ret.append([msg, None])
-            else:
-                ret[-1][-1] = msg
-        return ret
-
-    def copy(self):
-        return Conversation(
-            system=self.system,
-            # system_img=self.system_img,
-            roles=self.roles,
-            messages=[[x, y] for x, y in self.messages],
-            offset=self.offset,
-            sep_style=self.sep_style,
-            sep=self.sep,
-            sep2=self.sep2,
-            conv_id=self.conv_id)
-
-    def dict(self):
-        return {
-            "system": self.system,
-            # "system_img": self.system_img,
-            "roles": self.roles,
-            "messages": self.messages,
-            "offset": self.offset,
-            "sep": self.sep,
-            "sep2": self.sep2,
-            "conv_id": self.conv_id,
-        }
-
-
-class StoppingCriteriaSub(StoppingCriteria):
-
-    def __init__(self, stops=[], encounters=1):
-        super().__init__()
-        self.stops = stops
-
-    def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor):
-        for stop in self.stops:
-            if torch.all(input_ids[:, -len(stop):] == stop).item():
-                return True
-
-        return False
-
-
-CONV_VISION_Vicuna0 = Conversation(
-    system="Give the following image: <Img>ImageContent</Img>. "
-           "You will be able to see the image once I provide it to you. Please answer my questions.",
-    roles=("Human: ", "Assistant: "),
-    messages=[],
-    offset=2,
-    sep_style=SeparatorStyle.SINGLE,
-    sep="###",
-)
-
-CONV_VISION_LLama2 = Conversation(
-    system="Give the following image: <Img>ImageContent</Img>. "
-           "You will be able to see the image once I provide it to you. Please answer my questions.",
-    roles=("<s>[INST] ", " [/INST] "),
-    messages=[],
-    offset=2,
-    sep_style=SeparatorStyle.SINGLE,
-    sep="",
-)
-
-CONV_VISION_minigptv2 = Conversation(
-    system="",
-    roles=("<s>[INST] ", " [/INST]"),
-    messages=[],
-    offset=2,
-    sep_style=SeparatorStyle.SINGLE,
-    sep="",
-)
-
-class Chat:
-    def __init__(self, model, vis_processor, device='cuda:0', stopping_criteria=None):
-        self.device = device
-        self.model = model
-        self.vis_processor = vis_processor
-
-        if stopping_criteria is not None:
-            self.stopping_criteria = stopping_criteria
-        else:
-            stop_words_ids = [torch.tensor([2]).to(self.device)]
-            self.stopping_criteria = StoppingCriteriaList([StoppingCriteriaSub(stops=stop_words_ids)])
-
-    def ask(self, text, conv):
-        if len(conv.messages) > 0 and conv.messages[-1][0] == conv.roles[0] \
-                and conv.messages[-1][1][-6:] == '</Img>':  # last message is image.
-            conv.messages[-1][1] = ' '.join([conv.messages[-1][1], text])
-        else:
-            conv.append_message(conv.roles[0], text)
-
-    def answer_prepare(self, conv, img_list, max_new_tokens=300, num_beams=1, min_length=1, top_p=0.9,
-                       repetition_penalty=1.05, length_penalty=1, temperature=1.0, max_length=2000):
-        conv.append_message(conv.roles[1], None)
-        prompt = conv.get_prompt()
-        embs = self.model.get_context_emb(prompt, img_list)
-
-        current_max_len = embs.shape[1] + max_new_tokens
-        if current_max_len - max_length > 0:
-            print('Warning: The number of tokens in current conversation exceeds the max length. '
-                  'The model will not see the contexts outside the range.')
-        begin_idx = max(0, current_max_len - max_length)
-        embs = embs[:, begin_idx:]
-
-        generation_kwargs = dict(
-            inputs_embeds=embs,
-            max_new_tokens=max_new_tokens,
-            stopping_criteria=self.stopping_criteria,
-            num_beams=num_beams,
-            do_sample=True,
-            min_length=min_length,
-            top_p=top_p,
-            repetition_penalty=repetition_penalty,
-            length_penalty=length_penalty,
-            temperature=float(temperature),
-        )
-        return generation_kwargs
-
-    def answer(self, conv, img_list, **kargs):
-        generation_dict = self.answer_prepare(conv, img_list, **kargs)
-        output_token = self.model_generate(**generation_dict)[0]
-        output_text = self.model.llama_tokenizer.decode(output_token, skip_special_tokens=True)
-
-        output_text = output_text.split('###')[0]  # remove the stop sign '###'
-        output_text = output_text.split('Assistant:')[-1].strip()
-
-        conv.messages[-1][1] = output_text
-        return output_text, output_token.cpu().numpy()
-
-    def stream_answer(self, conv, img_list, **kargs):
-        generation_kwargs = self.answer_prepare(conv, img_list, **kargs)
-        streamer = TextIteratorStreamer(self.model.llama_tokenizer, skip_special_tokens=True)
-        generation_kwargs['streamer'] = streamer
-        thread = Thread(target=self.model_generate, kwargs=generation_kwargs)
-        thread.start()
-        return streamer
-
-    def model_generate(self, *args, **kwargs):
-        # for 8 bit and 16 bit compatibility
-        with self.model.maybe_autocast():
-            output = self.model.llama_model.generate(*args, **kwargs)
-        return output
-
-    def encode_img(self, img_list):
-        image = img_list[0]
-        img_list.pop(0)
-        if isinstance(image, str):  # is a image path
-            raw_image = Image.open(image).convert('RGB')
-            image = self.vis_processor(raw_image).unsqueeze(0).to(self.device)
-        elif isinstance(image, Image.Image):
-            raw_image = image
-            image = self.vis_processor(raw_image).unsqueeze(0).to(self.device)
-        elif isinstance(image, torch.Tensor):
-            if len(image.shape) == 3:
-                image = image.unsqueeze(0)
-            image = image.to(self.device)
-
-        image_emb, _ = self.model.encode_img(image)
-        img_list.append(image_emb)
-
-    def upload_img(self, image, conv, img_list):
-        conv.append_message(conv.roles[0], "<Img><ImageHere></Img>")
-        img_list.append(image)
-        msg = "Received."
-
-        return msg
-

minigpt4/datasets/builders/__init__.py

@@ -1,72 +0,0 @@
-"""
- 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
-"""
-
-from minigpt4.datasets.builders.base_dataset_builder import load_dataset_config
-from minigpt4.datasets.builders.image_text_pair_builder import (
-    CCSBUBuilder,
-    LaionBuilder,
-    CCSBUAlignBuilder
-)
-from minigpt4.common.registry import registry
-
-__all__ = [
-    "CCSBUBuilder",
-    "LaionBuilder",
-    "CCSBUAlignBuilder"
-]
-
-
-def load_dataset(name, cfg_path=None, vis_path=None, data_type=None):
-    """
-    Example
-
-    >>> dataset = load_dataset("coco_caption", cfg=None)
-    >>> splits = dataset.keys()
-    >>> print([len(dataset[split]) for split in splits])
-
-    """
-    if cfg_path is None:
-        cfg = None
-    else:
-        cfg = load_dataset_config(cfg_path)
-
-    try:
-        builder = registry.get_builder_class(name)(cfg)
-    except TypeError:
-        print(
-            f"Dataset {name} not found. Available datasets:\n"
-            + ", ".join([str(k) for k in dataset_zoo.get_names()])
-        )
-        exit(1)
-
-    if vis_path is not None:
-        if data_type is None:
-            # use default data type in the config
-            data_type = builder.config.data_type
-
-        assert (
-            data_type in builder.config.build_info
-        ), f"Invalid data_type {data_type} for {name}."
-
-        builder.config.build_info.get(data_type).storage = vis_path
-
-    dataset = builder.build_datasets()
-    return dataset
-
-
-class DatasetZoo:
-    def __init__(self) -> None:
-        self.dataset_zoo = {
-            k: list(v.DATASET_CONFIG_DICT.keys())
-            for k, v in sorted(registry.mapping["builder_name_mapping"].items())
-        }
-
-    def get_names(self):
-        return list(self.dataset_zoo.keys())
-
-
-dataset_zoo = DatasetZoo()

minigpt4/datasets/builders/base_dataset_builder.py

@@ -1,236 +0,0 @@
-"""
- This file is from
- 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 os
-import shutil
-import warnings
-
-from omegaconf import OmegaConf
-import torch.distributed as dist
-from torchvision.datasets.utils import download_url
-
-import minigpt4.common.utils as utils
-from minigpt4.common.dist_utils import is_dist_avail_and_initialized, is_main_process
-from minigpt4.common.registry import registry
-from minigpt4.processors.base_processor import BaseProcessor
-
-
-
-class BaseDatasetBuilder:
-    train_dataset_cls, eval_dataset_cls = None, None
-
-    def __init__(self, cfg=None):
-        super().__init__()
-
-        if cfg is None:
-            # help to create datasets from default config.
-            self.config = load_dataset_config(self.default_config_path())
-        elif isinstance(cfg, str):
-            self.config = load_dataset_config(cfg)
-        else:
-            # when called from task.build_dataset()
-            self.config = cfg
-
-        self.data_type = self.config.data_type
-
-        self.vis_processors = {"train": BaseProcessor(), "eval": BaseProcessor()}
-        self.text_processors = {"train": BaseProcessor(), "eval": BaseProcessor()}
-
-    def build_datasets(self):
-        # download, split, etc...
-        # only called on 1 GPU/TPU in distributed
-
-        if is_main_process():
-            self._download_data()
-
-        if is_dist_avail_and_initialized():
-            dist.barrier()
-
-        # at this point, all the annotations and image/videos should be all downloaded to the specified locations.
-        logging.info("Building datasets...")
-        datasets = self.build()  # dataset['train'/'val'/'test']
-
-        return datasets
-
-    def build_processors(self):
-        vis_proc_cfg = self.config.get("vis_processor")
-        txt_proc_cfg = self.config.get("text_processor")
-
-        if vis_proc_cfg is not None:
-            vis_train_cfg = vis_proc_cfg.get("train")
-            vis_eval_cfg = vis_proc_cfg.get("eval")
-
-            self.vis_processors["train"] = self._build_proc_from_cfg(vis_train_cfg)
-            self.vis_processors["eval"] = self._build_proc_from_cfg(vis_eval_cfg)
-
-        if txt_proc_cfg is not None:
-            txt_train_cfg = txt_proc_cfg.get("train")
-            txt_eval_cfg = txt_proc_cfg.get("eval")
-
-            self.text_processors["train"] = self._build_proc_from_cfg(txt_train_cfg)
-            self.text_processors["eval"] = self._build_proc_from_cfg(txt_eval_cfg)
-
-    @staticmethod
-    def _build_proc_from_cfg(cfg):
-        return (
-            registry.get_processor_class(cfg.name).from_config(cfg)
-            if cfg is not None
-            else None
-        )
-
-    @classmethod
-    def default_config_path(cls, type="default"):
-        return utils.get_abs_path(cls.DATASET_CONFIG_DICT[type])
-
-    def _download_data(self):
-        self._download_ann()
-        self._download_vis()
-
-    def _download_ann(self):
-        """
-        Download annotation files if necessary.
-        All the vision-language datasets should have annotations of unified format.
-
-        storage_path can be:
-          (1) relative/absolute: will be prefixed with env.cache_root to make full path if relative.
-          (2) basename/dirname: will be suffixed with base name of URL if dirname is provided.
-
-        Local annotation paths should be relative.
-        """
-        anns = self.config.build_info.annotations
-
-        splits = anns.keys()
-
-        cache_root = registry.get_path("cache_root")
-
-        for split in splits:
-            info = anns[split]
-
-            urls, storage_paths = info.get("url", None), info.storage
-
-            if isinstance(urls, str):
-                urls = [urls]
-            if isinstance(storage_paths, str):
-                storage_paths = [storage_paths]
-
-            assert len(urls) == len(storage_paths)
-
-            for url_or_filename, storage_path in zip(urls, storage_paths):
-                # if storage_path is relative, make it full by prefixing with cache_root.
-                if not os.path.isabs(storage_path):
-                    storage_path = os.path.join(cache_root, storage_path)
-
-                dirname = os.path.dirname(storage_path)
-                if not os.path.exists(dirname):
-                    os.makedirs(dirname)
-
-                if os.path.isfile(url_or_filename):
-                    src, dst = url_or_filename, storage_path
-                    if not os.path.exists(dst):
-                        shutil.copyfile(src=src, dst=dst)
-                    else:
-                        logging.info("Using existing file {}.".format(dst))
-                else:
-                    if os.path.isdir(storage_path):
-                        # if only dirname is provided, suffix with basename of URL.
-                        raise ValueError(
-                            "Expecting storage_path to be a file path, got directory {}".format(
-                                storage_path
-                            )
-                        )
-                    else:
-                        filename = os.path.basename(storage_path)
-
-                    download_url(url=url_or_filename, root=dirname, filename=filename)
-
-    def _download_vis(self):
-
-        storage_path = self.config.build_info.get(self.data_type).storage
-        storage_path = utils.get_cache_path(storage_path)
-
-        if not os.path.exists(storage_path):
-            warnings.warn(
-                f"""
-                The specified path {storage_path} for visual inputs does not exist.
-                Please provide a correct path to the visual inputs or
-                refer to datasets/download_scripts/README.md for downloading instructions.
-                """
-            )
-
-    def build(self):
-        """
-        Create by split datasets inheriting torch.utils.data.Datasets.
-
-        # build() can be dataset-specific. Overwrite to customize.
-        """
-        self.build_processors()
-
-        build_info = self.config.build_info
-
-        ann_info = build_info.annotations
-        vis_info = build_info.get(self.data_type)
-
-        datasets = dict()
-        for split in ann_info.keys():
-            if split not in ["train", "val", "test"]:
-                continue
-
-            is_train = split == "train"
-
-            # processors
-            vis_processor = (
-                self.vis_processors["train"]
-                if is_train
-                else self.vis_processors["eval"]
-            )
-            text_processor = (
-                self.text_processors["train"]
-                if is_train
-                else self.text_processors["eval"]
-            )
-
-            # annotation path
-            ann_paths = ann_info.get(split).storage
-            if isinstance(ann_paths, str):
-                ann_paths = [ann_paths]
-
-            abs_ann_paths = []
-            for ann_path in ann_paths:
-                if not os.path.isabs(ann_path):
-                    ann_path = utils.get_cache_path(ann_path)
-                abs_ann_paths.append(ann_path)
-            ann_paths = abs_ann_paths
-
-            # visual data storage path
-            vis_path = os.path.join(vis_info.storage, split)
-
-            if not os.path.isabs(vis_path):
-                # vis_path = os.path.join(utils.get_cache_path(), vis_path)
-                vis_path = utils.get_cache_path(vis_path)
-
-            if not os.path.exists(vis_path):
-                warnings.warn("storage path {} does not exist.".format(vis_path))
-
-            # create datasets
-            dataset_cls = self.train_dataset_cls if is_train else self.eval_dataset_cls
-            datasets[split] = dataset_cls(
-                vis_processor=vis_processor,
-                text_processor=text_processor,
-                ann_paths=ann_paths,
-                vis_root=vis_path,
-            )
-
-        return datasets
-
-
-def load_dataset_config(cfg_path):
-    cfg = OmegaConf.load(cfg_path).datasets
-    cfg = cfg[list(cfg.keys())[0]]
-
-    return cfg

minigpt4/datasets/builders/image_text_pair_builder.py

@@ -1,535 +0,0 @@
-import os
-import logging
-import warnings
-
-from minigpt4.common.registry import registry
-from minigpt4.datasets.builders.base_dataset_builder import BaseDatasetBuilder
-from minigpt4.datasets.datasets.laion_dataset import LaionDataset
-from minigpt4.datasets.datasets.cc_sbu_dataset import CCSBUDataset, CCSBUAlignDataset
-from minigpt4.datasets.datasets.text_caps import TextCapDataset
-from minigpt4.datasets.datasets.llava_dataset import LlavaDetailDataset, LlavaReasonDataset, LlavaConversationDataset
-from minigpt4.datasets.datasets.unnatural_instruction import UnnaturalDataset
-from minigpt4.datasets.datasets.multitask_conversation import MultiTaskConversationDataset
-from minigpt4.datasets.datasets.flickr import GroundedDetailDataset,CaptionToObjectDataset,PhraseToObjectDataset
-from minigpt4.datasets.datasets.vg_dataset import ReferVisualGenomeDataset
-from minigpt4.datasets.datasets.coco_dataset import ReferCOCODataset, InvReferCOCODataset
-from minigpt4.datasets.datasets.gqa_datasets import GQADataset
-from minigpt4.datasets.datasets.aok_vqa_datasets import AOKVQADataset
-from minigpt4.datasets.datasets.coco_vqa_datasets import COCOVQADataset
-from minigpt4.datasets.datasets.ocrvqa_dataset import OCRVQADataset
-from minigpt4.datasets.datasets.coco_caption import COCOCapDataset
-
-
-@registry.register_builder("multitask_conversation")
-class MultitaskConversationBuilder(BaseDatasetBuilder):
-    train_dataset_cls = MultiTaskConversationDataset
-    DATASET_CONFIG_DICT = {
-        "default": "configs/datasets/multitask_conversation/default.yaml",
-    }
-
-    def build_datasets(self):
-        # at this point, all the annotations and image/videos should be all downloaded to the specified locations.
-        logging.info("Building datasets...")
-        self.build_processors()
-        build_info = self.config.build_info
-        datasets = dict()
-
-        # create datasets
-        dataset_cls = self.train_dataset_cls
-        datasets['train'] = dataset_cls(
-            vis_processor=self.vis_processors["train"],
-            text_processor=self.text_processors["train"],
-            ann_path=build_info.ann_path,
-            vis_root=build_info.image_path,
-        )
-
-        return datasets
-
-
-@registry.register_builder("unnatural_instruction")
-class UnnaturalInstructionBuilder(BaseDatasetBuilder):
-    train_dataset_cls = UnnaturalDataset
-    DATASET_CONFIG_DICT = {
-        "default": "configs/datasets/nlp/unnatural_instruction.yaml",
-    }
-
-    def build_datasets(self):
-        # at this point, all the annotations and image/videos should be all downloaded to the specified locations.
-        logging.info("Building datasets...")
-        self.build_processors()
-        build_info = self.config.build_info
-        datasets = dict()
-
-        # create datasets
-        dataset_cls = self.train_dataset_cls
-        datasets['train'] = dataset_cls(
-            text_processor=self.text_processors["train"],
-            ann_path=build_info.ann_path,
-        )
-
-        return datasets
-
-
-
-@registry.register_builder("llava_detail")
-class LlavaDetailBuilder(BaseDatasetBuilder):
-    train_dataset_cls = LlavaDetailDataset
-    DATASET_CONFIG_DICT = {
-        "default": "configs/datasets/llava/detail.yaml",
-    }
-
-    def build_datasets(self):
-        # at this point, all the annotations and image/videos should be all downloaded to the specified locations.
-        logging.info("Building datasets...")
-        self.build_processors()
-        build_info = self.config.build_info
-        datasets = dict()
-
-        # create datasets
-        dataset_cls = self.train_dataset_cls
-        datasets['train'] = dataset_cls(
-            vis_processor=self.vis_processors["train"],
-            text_processor=self.text_processors["train"],
-            ann_path=build_info.ann_path,
-            vis_root=build_info.image_path,
-        )
-
-        return datasets
-    
-
-
-@registry.register_builder("llava_reason")
-class LlavaReasonBuilder(BaseDatasetBuilder):
-    train_dataset_cls = LlavaReasonDataset
-    DATASET_CONFIG_DICT = {
-        "default": "configs/datasets/llava/reason.yaml",
-    }
-
-    def build_datasets(self):
-        # at this point, all the annotations and image/videos should be all downloaded to the specified locations.
-        logging.info("Building datasets...")
-        self.build_processors()
-        build_info = self.config.build_info
-        datasets = dict()
-
-        # create datasets
-        dataset_cls = self.train_dataset_cls
-        datasets['train'] = dataset_cls(
-            vis_processor=self.vis_processors["train"],
-            text_processor=self.text_processors["train"],
-            ann_path=build_info.ann_path,
-            vis_root=build_info.image_path,
-        )
-
-        return datasets
-
-@registry.register_builder("llava_conversation")
-class LlavaReasonBuilder(BaseDatasetBuilder):
-    train_dataset_cls = LlavaConversationDataset
-    DATASET_CONFIG_DICT = {
-        "default": "configs/datasets/llava/conversation.yaml",
-    }
-
-    def build_datasets(self):
-        # at this point, all the annotations and image/videos should be all downloaded to the specified locations.
-        logging.info("Building datasets...")
-        self.build_processors()
-        build_info = self.config.build_info
-        datasets = dict()
-
-        # create datasets
-        dataset_cls = self.train_dataset_cls
-        datasets['train'] = dataset_cls(
-            vis_processor=self.vis_processors["train"],
-            text_processor=self.text_processors["train"],
-            ann_path=build_info.ann_path,
-            vis_root=build_info.image_path,
-        )
-
-        return datasets
-
-
-class AllRefCOCOBuilder(BaseDatasetBuilder):
-
-    def build_datasets(self):
-        # at this point, all the annotations and image/videos should be all downloaded to the specified locations.
-        logging.info("Building datasets...")
-        self.build_processors()
-
-        build_info = self.config.build_info
-        image_path = build_info.image_path
-        ann_path = build_info.ann_path
-
-        datasets = dict()
-
-        if not os.path.exists(image_path):
-            warnings.warn("image path {} does not exist.".format(image_path))
-        if not os.path.exists(ann_path):
-            warnings.warn("ann path {} does not exist.".format(ann_path))
-
-        # create datasets
-        dataset_cls = self.train_dataset_cls
-        datasets['train'] = dataset_cls(
-            vis_processor=self.vis_processors["train"],
-            text_processor=self.text_processors["train"],
-            ann_path=ann_path,
-            vis_root=image_path,
-            dataset=build_info.dataset,
-            splitBy=build_info.splitBy
-        )
-
-        return datasets
-    
-
-@registry.register_builder("refcoco")
-class RefCOCOBuilder(AllRefCOCOBuilder):
-    train_dataset_cls = ReferCOCODataset
-    DATASET_CONFIG_DICT = {
-        "default": "configs/datasets/coco_bbox/refcoco.yaml",
-    }
-
-@registry.register_builder("refcocop")
-class RefCOCOPBuilder(AllRefCOCOBuilder):
-    train_dataset_cls = ReferCOCODataset
-    DATASET_CONFIG_DICT = {
-        "default": "configs/datasets/coco_bbox/refcocop.yaml",
-    }
-
-
-@registry.register_builder("refcocog")
-class RefCOCOGBuilder(AllRefCOCOBuilder):
-    train_dataset_cls = ReferCOCODataset
-    DATASET_CONFIG_DICT = {
-        "default": "configs/datasets/coco_bbox/refcocog.yaml",
-    }
-
-@registry.register_builder("invrefcoco")
-class RefCOCOBuilder(AllRefCOCOBuilder):
-    train_dataset_cls = InvReferCOCODataset
-    DATASET_CONFIG_DICT = {
-        "default": "configs/datasets/coco_bbox/invrefcoco.yaml",
-    }
-
-
-@registry.register_builder("invrefcocop")
-class RefCOCOPBuilder(AllRefCOCOBuilder):
-    train_dataset_cls = InvReferCOCODataset
-    DATASET_CONFIG_DICT = {
-        "default": "configs/datasets/coco_bbox/invrefcocop.yaml",
-    }
-
-
-@registry.register_builder("invrefcocog")
-class RefCOCOGBuilder(AllRefCOCOBuilder):
-    train_dataset_cls = InvReferCOCODataset
-    DATASET_CONFIG_DICT = {
-        "default": "configs/datasets/coco_bbox/invrefcocog.yaml",
-    }
-
-@registry.register_builder("refvg")
-class RefVisualGenomeBuilder(BaseDatasetBuilder):
-    train_dataset_cls = ReferVisualGenomeDataset
-    DATASET_CONFIG_DICT = {
-        "default": "configs/datasets/vg/ref.yaml",
-    }
-
-    def build_datasets(self):
-        # at this point, all the annotations and image/videos should be all downloaded to the specified locations.
-        logging.info("Building datasets...")
-        self.build_processors()
-
-        build_info = self.config.build_info
-        data_dir = build_info.data_dir
-        datasets = dict()
-
-        # create datasets
-        dataset_cls = self.train_dataset_cls
-        datasets['train'] = dataset_cls(
-            vis_processor=self.vis_processors["train"],
-            text_processor=self.text_processors["train"],
-            data_dir=data_dir,
-        )
-
-        return datasets
-
-
-@registry.register_builder("textcaps_caption")
-class TextcapCaptionBuilder(BaseDatasetBuilder):
-    train_dataset_cls = TextCapDataset
-
-    DATASET_CONFIG_DICT = {"default": "configs/datasets/textcaps/caption.yaml"}
-
-    def _download_ann(self):
-        pass
-
-    def _download_vis(self):
-        pass
-
-    def build(self):
-        self.build_processors()
-
-        build_info = self.config.build_info
-
-        datasets = dict()
-        split = "train"
-
-        # create datasets
-        # [NOTE] return inner_datasets (wds.DataPipeline)
-        dataset_cls = self.train_dataset_cls
-        datasets[split] = dataset_cls(
-            vis_processor=self.vis_processors[split],
-            text_processor=self.text_processors[split],
-            ann_path=build_info.ann_path,
-            vis_root=build_info.image_path,
-        )
-
-        return datasets
-    
-@registry.register_builder("coco_vqa")
-class COCOVQABuilder(BaseDatasetBuilder):
-    train_dataset_cls = COCOVQADataset
-
-    DATASET_CONFIG_DICT = {
-        "default": "configs/datasets/coco/defaults_vqa.yaml",
-    }
-
-@registry.register_builder("ok_vqa")
-class OKVQABuilder(COCOVQABuilder):
-    DATASET_CONFIG_DICT = {
-        "default": "configs/datasets/okvqa/defaults.yaml",
-    }
-
-
-@registry.register_builder("aok_vqa")
-class AOKVQABuilder(BaseDatasetBuilder):
-    train_dataset_cls = AOKVQADataset
-
-    DATASET_CONFIG_DICT = {"default": "configs/datasets/aokvqa/defaults.yaml"}
-
-
-@registry.register_builder("gqa")
-class GQABuilder(BaseDatasetBuilder):
-    train_dataset_cls = GQADataset
-    DATASET_CONFIG_DICT = {
-        "default": "configs/datasets/gqa/balanced_val.yaml",
-    }
-
-
-
-
-@registry.register_builder("flickr_grounded_caption")
-class GroundedCaptionBuilder(BaseDatasetBuilder):
-    train_dataset_cls = GroundedDetailDataset
-    DATASET_CONFIG_DICT = {
-        "default": "configs/datasets/flickr/default.yaml",
-    }
-
-    def build_datasets(self):
-        # at this point, all the annotations and image/videos should be all downloaded to the specified locations.
-        logging.info("Building datasets...")
-        self.build_processors()
-        build_info = self.config.build_info
-        datasets = dict()
-
-        # create datasets
-        dataset_cls = self.train_dataset_cls
-        datasets['train'] = dataset_cls(
-            vis_processor=self.vis_processors["train"],
-            text_processor=self.text_processors["train"],
-            ann_path=build_info.ann_path,
-            vis_root=build_info.image_path,
-        )
-
-        return datasets
-
-
-@registry.register_builder("flickr_CaptionToPhrase")
-class CaptionToPhraseBuilder(BaseDatasetBuilder):
-    train_dataset_cls = CaptionToObjectDataset
-    DATASET_CONFIG_DICT = {
-        "default": "configs/datasets/flickr/caption_to_phrase.yaml",
-    }
-
-    def build_datasets(self):
-        # at this point, all the annotations and image/videos should be all downloaded to the specified locations.
-        logging.info("Building datasets...")
-        self.build_processors()
-        build_info = self.config.build_info
-        datasets = dict()
-
-        # create datasets
-        dataset_cls = self.train_dataset_cls
-        datasets['train'] = dataset_cls(
-            vis_processor=self.vis_processors["train"],
-            text_processor=self.text_processors["train"],
-            ann_path=build_info.ann_path,
-            vis_root=build_info.image_path,
-        )
-
-        return datasets
-
-@registry.register_builder("flickr_ObjectToPhrase")
-class CaptionToPhraseBuilder(BaseDatasetBuilder):
-    train_dataset_cls = PhraseToObjectDataset
-    DATASET_CONFIG_DICT = {
-        "default": "configs/datasets/flickr/object_to_phrase.yaml",
-    }
-
-    def build_datasets(self):
-        # at this point, all the annotations and image/videos should be all downloaded to the specified locations.
-        logging.info("Building datasets...")
-        self.build_processors()
-        build_info = self.config.build_info
-        datasets = dict()
-
-        # create datasets
-        dataset_cls = self.train_dataset_cls
-        datasets['train'] = dataset_cls(
-            vis_processor=self.vis_processors["train"],
-            text_processor=self.text_processors["train"],
-            ann_path=build_info.ann_path,
-            vis_root=build_info.image_path,
-        )
-
-        return datasets
-
-
-
-
-class DocumentVQABuilder(BaseDatasetBuilder):
-    def _download_ann(self):
-        pass
-
-    def _download_vis(self):
-        pass
-
-    def build(self):
-        self.build_processors()
-        build_info = self.config.build_info
-
-        datasets = dict()
-        split = "train"
-
-        dataset_cls = self.train_dataset_cls
-        datasets[split] = dataset_cls(
-            vis_processor=self.vis_processors[split],
-            text_processor=self.text_processors[split],
-            vis_root=build_info.image_path,
-            ann_path=build_info.ann_path
-        )
-
-        return datasets
-    
-
-@registry.register_builder("ocrvqa")
-class OCRVQABuilder(DocumentVQABuilder):
-    train_dataset_cls = OCRVQADataset
-    DATASET_CONFIG_DICT = {"default": "configs/datasets/ocrvqa/ocrvqa.yaml"}
-
-
-@registry.register_builder("cc_sbu")
-class CCSBUBuilder(BaseDatasetBuilder):
-    train_dataset_cls = CCSBUDataset
-
-    DATASET_CONFIG_DICT = {"default": "configs/datasets/cc_sbu/defaults.yaml"}
-
-    def _download_ann(self):
-        pass
-
-    def _download_vis(self):
-        pass
-
-    def build(self):
-        self.build_processors()
-
-        build_info = self.config.build_info
-
-        datasets = dict()
-        split = "train"
-
-        # create datasets
-        # [NOTE] return inner_datasets (wds.DataPipeline)
-        dataset_cls = self.train_dataset_cls
-        datasets[split] = dataset_cls(
-            vis_processor=self.vis_processors[split],
-            text_processor=self.text_processors[split],
-            location=build_info.storage,
-        ).inner_dataset
-
-        return datasets
-
-
-@registry.register_builder("laion")
-class LaionBuilder(BaseDatasetBuilder):
-    train_dataset_cls = LaionDataset
-
-    DATASET_CONFIG_DICT = {"default": "configs/datasets/laion/defaults.yaml"}
-
-    def _download_ann(self):
-        pass
-
-    def _download_vis(self):
-        pass
-
-    def build(self):
-        self.build_processors()
-
-        build_info = self.config.build_info
-
-        datasets = dict()
-        split = "train"
-
-        # create datasets
-        # [NOTE] return inner_datasets (wds.DataPipeline)
-        dataset_cls = self.train_dataset_cls
-        datasets[split] = dataset_cls(
-            vis_processor=self.vis_processors[split],
-            text_processor=self.text_processors[split],
-            location=build_info.storage,
-        ).inner_dataset
-
-        return datasets
-
-
-
-@registry.register_builder("coco_caption")
-class COCOCapBuilder(BaseDatasetBuilder):
-    train_dataset_cls = COCOCapDataset
-
-    DATASET_CONFIG_DICT = {
-        "default": "configs/datasets/coco/caption.yaml",
-    }
-
-
-
-@registry.register_builder("cc_sbu_align")
-class CCSBUAlignBuilder(BaseDatasetBuilder):
-    train_dataset_cls = CCSBUAlignDataset
-
-    DATASET_CONFIG_DICT = {
-        "default": "configs/datasets/cc_sbu/align.yaml",
-    }
-
-    def build_datasets(self):
-        # at this point, all the annotations and image/videos should be all downloaded to the specified locations.
-        logging.info("Building datasets...")
-        self.build_processors()
-
-        build_info = self.config.build_info
-        storage_path = build_info.storage
-
-        datasets = dict()
-
-        if not os.path.exists(storage_path):
-            warnings.warn("storage path {} does not exist.".format(storage_path))
-
-        # create datasets
-        dataset_cls = self.train_dataset_cls
-        datasets['train'] = dataset_cls(
-            vis_processor=self.vis_processors["train"],
-            text_processor=self.text_processors["train"],
-            ann_paths=[os.path.join(storage_path, 'filter_cap.json')],
-            vis_root=os.path.join(storage_path, 'image'),
-        )
-
-        return datasets

minigpt4/datasets/data_utils.py

@@ -1,199 +0,0 @@
-"""
- 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 gzip
-import logging
-import os
-import random as rnd
-import tarfile
-import zipfile
-import random
-from typing import List
-from tqdm import tqdm
-
-import decord
-from decord import VideoReader
-import webdataset as wds
-import numpy as np
-import torch
-from torch.utils.data.dataset import IterableDataset
-
-from minigpt4.common.registry import registry
-from minigpt4.datasets.datasets.base_dataset import ConcatDataset
-
-
-decord.bridge.set_bridge("torch")
-MAX_INT = registry.get("MAX_INT")
-
-
-class ChainDataset(wds.DataPipeline):
-    r"""Dataset for chaining multiple :class:`DataPipeline` s.
-
-    This class is useful to assemble different existing dataset streams. The
-    chaining operation is done on-the-fly, so concatenating large-scale
-    datasets with this class will be efficient.
-
-    Args:
-        datasets (iterable of IterableDataset): datasets to be chained together
-    """
-    def __init__(self, datasets: List[wds.DataPipeline]) -> None:
-        super().__init__()
-        self.datasets = datasets
-        self.prob = []
-        self.names = []
-        for dataset in self.datasets:
-            if hasattr(dataset, 'name'):
-                self.names.append(dataset.name)
-            else:
-                self.names.append('Unknown')
-            if hasattr(dataset, 'sample_ratio'):
-                self.prob.append(dataset.sample_ratio)
-            else:
-                self.prob.append(1)
-                logging.info("One of the datapipeline doesn't define ratio and set to 1 automatically.")
-
-    def __iter__(self):
-        datastreams = [iter(dataset) for dataset in self.datasets]
-        while True:
-            select_datastream = random.choices(datastreams, weights=self.prob, k=1)[0]
-            yield next(select_datastream)
-
-
-def apply_to_sample(f, sample):
-    if len(sample) == 0:
-        return {}
-
-    def _apply(x):
-        if torch.is_tensor(x):
-            return f(x)
-        elif isinstance(x, dict):
-            return {key: _apply(value) for key, value in x.items()}
-        elif isinstance(x, list):
-            return [_apply(x) for x in x]
-        else:
-            return x
-
-    return _apply(sample)
-
-
-def move_to_cuda(sample):
-    def _move_to_cuda(tensor):
-        return tensor.cuda()
-
-    return apply_to_sample(_move_to_cuda, sample)
-
-
-def prepare_sample(samples, cuda_enabled=True):
-    if cuda_enabled:
-        samples = move_to_cuda(samples)
-
-    # TODO fp16 support
-
-    return samples
-
-
-def reorg_datasets_by_split(datasets, batch_sizes):
-    """
-    Organizes datasets by split.
-
-    Args:
-        datasets: dict of torch.utils.data.Dataset objects by name.
-
-    Returns:
-        Dict of datasets by split {split_name: List[Datasets]}.
-    """
-    # if len(datasets) == 1:
-    #     return datasets[list(datasets.keys())[0]]
-    # else:
-    reorg_datasets = dict()
-    reorg_batch_sizes = dict()
-
-    # reorganize by split
-    for dataset_name, dataset in datasets.items():
-        for split_name, dataset_split in dataset.items():
-            if split_name not in reorg_datasets:
-                reorg_datasets[split_name] = [dataset_split]
-                reorg_batch_sizes[split_name] = [batch_sizes[dataset_name]]
-            else:
-                reorg_datasets[split_name].append(dataset_split)
-                reorg_batch_sizes[split_name].append(batch_sizes[dataset_name])
-
-    return reorg_datasets, reorg_batch_sizes
-
-
-def concat_datasets(datasets):
-    """
-    Concatenates multiple datasets into a single dataset.
-
-    It supports may-style datasets and DataPipeline from WebDataset. Currently, does not support
-    generic IterableDataset because it requires creating separate samplers.
-
-    Now only supports conctenating training datasets and assuming validation and testing
-    have only a single dataset. This is because metrics should not be computed on the concatenated
-    datasets.
-
-    Args:
-        datasets: dict of torch.utils.data.Dataset objects by split.
-
-    Returns:
-        Dict of concatenated datasets by split, "train" is the concatenation of multiple datasets,
-        "val" and "test" remain the same.
-
-        If the input training datasets contain both map-style and DataPipeline datasets, returns
-        a tuple, where the first element is a concatenated map-style dataset and the second
-        element is a chained DataPipeline dataset.
-
-    """
-    # concatenate datasets in the same split
-    for split_name in datasets:
-        if split_name != "train":
-            assert (
-                len(datasets[split_name]) == 1
-            ), "Do not support multiple {} datasets.".format(split_name)
-            datasets[split_name] = datasets[split_name][0]
-        else:
-            iterable_datasets, map_datasets = [], []
-            for dataset in datasets[split_name]:
-                if isinstance(dataset, wds.DataPipeline):
-                    logging.info(
-                        "Dataset {} is IterableDataset, can't be concatenated.".format(
-                            dataset
-                        )
-                    )
-                    iterable_datasets.append(dataset)
-                elif isinstance(dataset, IterableDataset):
-                    raise NotImplementedError(
-                        "Do not support concatenation of generic IterableDataset."
-                    )
-                else:
-                    map_datasets.append(dataset)
-
-            # if len(iterable_datasets) > 0:
-            # concatenate map-style datasets and iterable-style datasets separately
-            if len(iterable_datasets) > 1:
-                chained_datasets = (
-                    ChainDataset(iterable_datasets)
-                )
-            elif len(iterable_datasets) == 1:
-                chained_datasets = iterable_datasets[0]
-            else:
-                chained_datasets = None
-
-            concat_datasets = (
-                ConcatDataset(map_datasets) if len(map_datasets) > 0 else None
-            )
-
-            train_datasets = concat_datasets, chained_datasets
-            train_datasets = tuple([x for x in train_datasets if x is not None])
-            train_datasets = (
-                train_datasets[0] if len(train_datasets) == 1 else train_datasets
-            )
-
-            datasets[split_name] = train_datasets
-
-    return datasets
-

minigpt4/datasets/datasets/aok_vqa_datasets.py

@@ -1,116 +0,0 @@
-"""
- 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
-"""
-
-from collections import OrderedDict
-import json
-import os
-import random
-import torch
-
-from PIL import Image
-
-from minigpt4.datasets.datasets.vqa_datasets import VQADataset  #, VQAEvalDataset
-
-
-class __DisplMixin:
-    def displ_item(self, index):
-        sample, ann = self.__getitem__(index), self.annotation[index]
-        return OrderedDict(
-            {
-                "file": ann["image"],
-                "question": ann["question"],
-                "question_id": ann["question_id"],
-                "direct_answers": "; ".join(ann["direct_answers"]),
-                "choices": "; ".join(ann["choices"]),
-                "correct_choice": ann["choices"][ann["correct_choice_idx"]],
-                "image": sample["image"],
-            }
-        )
-
-
-class AOKVQADataset(VQADataset, __DisplMixin):
-    def __init__(self, vis_processor, text_processor, vis_root, ann_paths):
-        super().__init__(vis_processor, text_processor, vis_root, ann_paths)
-
-        self.instruction_pool =[
-            "[vqa] {}",
-            "[vqa] Based on the image, respond to this question with a short answer: {}"
-        ]
-
-        exist_annotation = []
-        for ann in self.annotation:
-            image_path = os.path.join(self.vis_root, ann["image"].split('/')[-1])
-            if os.path.exists(image_path):
-                exist_annotation.append(ann)
-        self.annotation = exist_annotation
-
-    def get_data(self, index):
-        ann = self.annotation[index]
-
-        image_path = os.path.join(self.vis_root, ann["image"].split('/')[-1])
-        image = Image.open(image_path).convert("RGB")
-
-        image = self.vis_processor(image)
-        question = self.text_processor(ann["question"])
-
-        answer_key = "direct_answers"
-
-        answer_weight = {}
-        for answer in ann[answer_key]:
-            if answer in answer_weight.keys():
-                answer_weight[answer] += 1 / len(ann[answer_key])
-            else:
-                answer_weight[answer] = 1 / len(ann[answer_key])
-
-        answers = list(answer_weight.keys())
-        weights = list(answer_weight.values())
-
-        answer = random.choices(answers, weights=weights, k=1)[0]  # random sample an answer according to weights
-
-        return {
-            "image": image,
-            "question": question,
-            "answer": answer,
-        }
-
-    def __getitem__(self, index):
-        data = self.get_data(index)
-        question = self.text_processor(data["question"])
-        instruction = random.choice(self.instruction_pool).format(question)
-
-        instruction = "<Img><ImageHere></Img> {} ".format(instruction)
-        answer = self.text_processor(data['answer'])
-
-        return {
-            "image": data['image'],
-            "instruction_input": instruction,
-            "answer": answer,
-        }
-
-
-class AOKVQGDataset(AOKVQADataset):
-
-    def __init__(self, vis_processor, text_processor, vis_root, ann_paths):
-        super().__init__(vis_processor, text_processor, vis_root, ann_paths)
-        self.instruction_pool = [
-            'Given the image, generate a question whose answer is: {}',
-            'Based on the image, provide a question with the answer: {}',
-            'Given the visual representation, create a question for which the answer is "{}"',
-            'From the image provided, craft a question that leads to the reply: {}',
-            'Considering the picture, come up with a question where the answer is: {}',
-            'Taking the image into account, generate an question that has the answer: {}'
-        ]
-
-    def __getitem__(self, index):
-        data = self.get_data(index)
-        instruction = random.choice(self.instruction_pool).format(data['answer'])
-
-        return {
-            "image": data['image'],
-            "instruction_input": instruction,
-            "answer": data['question'],
-        }

minigpt4/datasets/datasets/base_dataset.py

@@ -1,78 +0,0 @@
-"""
- 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 json
-from typing import Iterable
-
-from torch.utils.data import Dataset, ConcatDataset
-from torch.utils.data.dataloader import default_collate
-
-
-
-
-class BaseDataset(Dataset):
-    def __init__(
-        self, vis_processor=None, text_processor=None, vis_root=None, ann_paths=[]
-    ):
-        """
-        vis_root (string): Root directory of images (e.g. coco/images/)
-        ann_root (string): directory to store the annotation file
-        """
-        self.vis_root = vis_root
-
-        self.annotation = []
-        # print("ann paths", ann_paths)
-        for ann_path in ann_paths:
-            # print("ann_path", ann_path)
-            ann = json.load(open(ann_path, "r"))
-            if isinstance(ann, dict):
-                self.annotation.extend(json.load(open(ann_path, "r"))['annotations'])
-                # self.annotation.extend(json.load(open(ann_path, "r")))
-            else:
-                self.annotation.extend(json.load(open(ann_path, "r")))
-    
-        self.vis_processor = vis_processor
-        self.text_processor = text_processor
-
-        self._add_instance_ids()
-
-    def __len__(self):
-        return len(self.annotation)
-
-    def collater(self, samples):
-        return default_collate(samples)
-
-    def set_processors(self, vis_processor, text_processor):
-        self.vis_processor = vis_processor
-        self.text_processor = text_processor
-
-    def _add_instance_ids(self, key="instance_id"):
-        for idx, ann in enumerate(self.annotation):
-            ann[key] = str(idx)
-
-
-
-class ConcatDataset(ConcatDataset):
-    def __init__(self, datasets: Iterable[Dataset]) -> None:
-        super().__init__(datasets)
-
-    def collater(self, samples):
-        # TODO For now only supports datasets with same underlying collater implementations
-
-        all_keys = set()
-        for s in samples:
-            all_keys.update(s)
-
-        shared_keys = all_keys
-        for s in samples:
-            shared_keys = shared_keys & set(s.keys())
-
-        samples_shared_keys = []
-        for s in samples:
-            samples_shared_keys.append({k: s[k] for k in s.keys() if k in shared_keys})
-
-        return self.datasets[0].collater(samples_shared_keys)

minigpt4/datasets/datasets/caption_datasets.py

@@ -1,151 +0,0 @@
-"""
- 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
-from collections import OrderedDict
-
-from minigpt4.datasets.datasets.base_dataset import BaseDataset
-from PIL import Image
-import random
-
-
-class __DisplMixin:
-    def displ_item(self, index):
-        sample, ann = self.__getitem__(index), self.annotation[index]
-
-        return OrderedDict(
-            {
-                "file": ann["image"],
-                "caption": ann["caption"],
-                "image": sample["image"],
-            }
-        )
-
-
-class CaptionDataset(BaseDataset, __DisplMixin):
-    def __init__(self, vis_processor, text_processor, vis_root, ann_paths):
-        """
-        vis_root (string): Root directory of images (e.g. coco/images/)
-        ann_root (string): directory to store the annotation file
-        """
-        super().__init__(vis_processor, text_processor, vis_root, ann_paths)
-
-        self.img_ids = {}
-        n = 0
-        for ann in self.annotation:
-            img_id = ann["image_id"]
-            if img_id not in self.img_ids.keys():
-                self.img_ids[img_id] = n
-                n += 1
-
-    def __getitem__(self, index):
-
-        # TODO this assumes image input, not general enough
-        ann = self.annotation[index]
-
-        img_file = '{:0>12}.jpg'.format(ann["image_id"])
-        image_path = os.path.join(self.vis_root, img_file)
-        image = Image.open(image_path).convert("RGB")
-
-        image = self.vis_processor(image)
-        caption = self.text_processor(ann["caption"])
-
-        return {
-            "image": image,
-            "text_input": caption,
-            "image_id": self.img_ids[ann["image_id"]],
-        }
-
-
-
-class COCOCaptionDataset(BaseDataset, __DisplMixin):
-    def __init__(self, vis_processor, text_processor, vis_root, ann_paths):
-        """
-        vis_root (string): Root directory of images (e.g. coco/images/)
-        ann_root (string): directory to store the annotation file
-        """
-        super().__init__(vis_processor, text_processor, vis_root, ann_paths)
-
-        self.img_ids = {}
-        n = 0
-
-        self.filter_anntation = []
-        
-        for ann in self.annotation:
-            if "train" in ann["image"]:
-                self.filter_anntation.append(ann)
-        self.annotation = self.filter_anntation
-
-        for ann in self.annotation:
-            img_id = ann["image_id"]
-            if img_id not in self.img_ids.keys():
-                self.img_ids[img_id] = n
-                n += 1
-
-        self.instruction_pool = [
-            'Briefly describe this image.',
-            'Provide a concise depiction of this image.',
-            'Present a short description of this image.',
-            'Summarize this image in a few words.',
-            'A short image caption:',
-            'A short image description:',
-            'A photo of ',
-            'An image that shows ',
-            'Write a short description for the image. ',
-            'Write a description for the photo.',
-            'Provide a description of what is presented in the photo.',
-            'Briefly describe the content of the image.',
-            'Can you briefly explain what you see in the image?',
-            'Could you use a few words to describe what you perceive in the photo?',
-            'Please provide a short depiction of the picture.',
-            'Using language, provide a short account of the image.',
-            'Use a few words to illustrate what is happening in the picture.',
-        ]
-    def __getitem__(self, index):
-
-        # TODO this assumes image input, not general enough
-        ann = self.annotation[index]
-
-        img_file = ann["image"].split("/")[-1]
-        image_path = os.path.join(self.vis_root, img_file)
-        image = Image.open(image_path).convert("RGB")
-
-        image = self.vis_processor(image)
-        caption = self.text_processor(ann["caption"])
-
-        instruction = random.choice(self.instruction_pool)
-        instruction = "<Img><ImageHere></Img> [caption] {} ".format(instruction)
-
-        return {
-            "image": image,
-            "answer": caption,
-            "instruction_input": instruction,
-        }
-
-class CaptionEvalDataset(BaseDataset, __DisplMixin):
-    def __init__(self, vis_processor, text_processor, vis_root, ann_paths):
-        """
-        vis_root (string): Root directory of images (e.g. coco/images/)
-        ann_root (string): directory to store the annotation file
-        split (string): val or test
-        """
-        super().__init__(vis_processor, text_processor, vis_root, ann_paths)
-
-    def __getitem__(self, index):
-
-        ann = self.annotation[index]
-
-        image_path = os.path.join(self.vis_root, ann["image"])
-        image = Image.open(image_path).convert("RGB")
-
-        image = self.vis_processor(image)
-
-        return {
-            "image": image,
-            "image_id": ann["image_id"],
-            "instance_id": ann["instance_id"],
-        }

minigpt4/datasets/datasets/cc_sbu_dataset.py

@@ -1,47 +0,0 @@
-import os
-from PIL import Image
-import webdataset as wds
-from minigpt4.datasets.datasets.base_dataset import BaseDataset
-from minigpt4.datasets.datasets.caption_datasets import CaptionDataset
-
-
-class CCSBUDataset(BaseDataset):
-    def __init__(self, vis_processor, text_processor, location):
-        super().__init__(vis_processor=vis_processor, text_processor=text_processor)
-
-        self.inner_dataset = wds.DataPipeline(
-            wds.ResampledShards(location),
-            wds.tarfile_to_samples(handler=wds.warn_and_continue),
-            wds.shuffle(1000, handler=wds.warn_and_continue),
-            wds.decode("pilrgb", handler=wds.warn_and_continue),
-            wds.to_tuple("jpg", "json", handler=wds.warn_and_continue),
-            wds.map_tuple(self.vis_processor, handler=wds.warn_and_continue),
-            wds.map(self.to_dict, handler=wds.warn_and_continue),
-        )
-
-    def to_dict(self, sample):
-        return {
-            "image": sample[0],
-            "answer": self.text_processor(sample[1]["caption"]),
-        }
-
-
-class CCSBUAlignDataset(CaptionDataset):
-
-    def __getitem__(self, index):
-
-        # TODO this assumes image input, not general enough
-        ann = self.annotation[index]
-
-        img_file = '{}.jpg'.format(ann["image_id"])
-        image_path = os.path.join(self.vis_root, img_file)
-        image = Image.open(image_path).convert("RGB")
-
-        image = self.vis_processor(image)
-        caption = ann["caption"]
-
-        return {
-            "image": image,
-            "answer": caption,
-            "image_id": self.img_ids[ann["image_id"]],
-        }

minigpt4/datasets/datasets/coco_caption.py

@@ -1,120 +0,0 @@
-"""
- 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
-"""
-
-import os
-import json
-import torch
-import numpy as np
-
-from PIL import Image
-from PIL import ImageFile
-
-ImageFile.LOAD_TRUNCATED_IMAGES = True
-
-from minigpt4.datasets.datasets.caption_datasets import COCOCaptionDataset, CaptionEvalDataset
-
-COCOCapDataset = COCOCaptionDataset
-
-
-
-
-
-class COCOCapEvalDataset(CaptionEvalDataset):
-    def __init__(self, vis_processor, text_processor, vis_root, ann_paths):
-        """
-        vis_root (string): Root directory of images (e.g. coco/images/)
-        ann_root (string): directory to store the annotation file
-        split (string): val or test
-        """
-        super().__init__(vis_processor, text_processor, vis_root, ann_paths)
-
-    def __getitem__(self, index):
-        ann = self.annotation[index]
-
-        image_path = os.path.join(self.vis_root, ann["image"])
-        image = Image.open(image_path).convert("RGB")
-
-        image = self.vis_processor(image)
-
-        img_id = ann["image"].split("/")[-1].strip(".jpg").split("_")[-1]
-
-        return {
-            "image": image,
-            "image_id": img_id,
-            "instance_id": ann["instance_id"],
-        }
-
-
-class NoCapsEvalDataset(CaptionEvalDataset):
-    def __init__(self, vis_processor, text_processor, vis_root, ann_paths):
-        """
-        vis_root (string): Root directory of images (e.g. coco/images/)
-        ann_root (string): directory to store the annotation file
-        split (string): val or test
-        """
-        super().__init__(vis_processor, text_processor, vis_root, ann_paths)
-
-    def __getitem__(self, index):
-        ann = self.annotation[index]
-
-        image_path = os.path.join(self.vis_root, ann["image"])
-        image = Image.open(image_path).convert("RGB")
-
-        image = self.vis_processor(image)
-
-        img_id = ann["img_id"]
-
-        return {
-            "image": image,
-            "image_id": img_id,
-            "instance_id": ann["instance_id"],
-        }
-
-
-class RefCOCOEvalData(torch.utils.data.Dataset):
-    def __init__(self, loaded_data, vis_processor, root_path):
-        self.loaded_data = loaded_data
-        self.root_path = root_path
-        self.vis_processor = vis_processor
-
-    def __len__(self):
-        return len(self.loaded_data)
-    
-    def __getitem__(self, idx):
-        data = self.loaded_data[idx]
-        img_id = data['img_id']
-        sent = data['sents']
-        image_path = os.path.join(self.root_path, f'{img_id[:27]}.jpg')
-        image = Image.open(image_path).convert('RGB')
-        image = self.vis_processor(image)
-        question = f"[refer] give me the location of {sent}"
-        return image, question, img_id
-
-class EvalCaptionData(torch.utils.data.Dataset):
-    def __init__(self, loaded_data, vis_processor, root_path):
-        self.loaded_data = loaded_data
-        self.root_path = root_path
-        self.vis_processor = vis_processor
-        ann = dict()
-        for item in self.loaded_data:
-            image_id = item['image_id']
-            ann[image_id] = item['image']
-        self.ann = [{'image_id':image_id, 'image': ann[image_id]} for image_id in ann]
-
-    def __len__(self):
-        return len(self.ann)
-    
-    def __getitem__(self, idx):
-        data = self.ann[idx]
-        image_id = data['image_id']
-        img_file = data['image'].split('/')[-1]
-        image_path = os.path.join(self.root_path, img_file)
-        image = Image.open(image_path).convert('RGB')
-            
-        image = self.vis_processor(image)
-        question = f"[caption] please describe this image?"
-        return image, question, image_id

minigpt4/datasets/datasets/coco_dataset.py

@@ -1,348 +0,0 @@
-import os
-import json
-import pickle
-import random
-import time
-import itertools
-
-import numpy as np
-from PIL import Image
-import skimage.io as io
-import matplotlib.pyplot as plt
-from matplotlib.collections import PatchCollection
-from matplotlib.patches import Polygon, Rectangle
-from torch.utils.data import Dataset
-import webdataset as wds
-
-from minigpt4.datasets.datasets.base_dataset import BaseDataset
-from minigpt4.datasets.datasets.caption_datasets import CaptionDataset
-
-
-class ReferCOCODataset(Dataset):
-    def __init__(self, vis_processor, text_processor, vis_root, ann_path, dataset='refcoco', splitBy='unc'):
-        """
-        vis_root (string): Root directory of images (e.g. coco/images/)
-        ann_root (string): directory to store the annotation file
-        """
-        self.vis_root = vis_root
-
-        self.vis_processor = vis_processor
-        self.text_processor = text_processor
-
-        self.refer = REFER(ann_path, vis_root, dataset, splitBy)
-        self.ref_ids = self.refer.getRefIds(split="train")
-
-        self.instruction_pool = [
-            "[refer] {}",
-            "[refer] give me the location of {}",
-            "[refer] where is {} ?",
-            "[refer] from this image, tell me the location of {}",
-            "[refer] the location of {} is",
-            "[refer] could you tell me the location for {} ?",
-            "[refer] where can I locate the {} ?",
-        ]
-
-
-    def __len__(self):
-        return len(self.ref_ids)
-
-    def preprocess(self, index):
-        ref_id = self.ref_ids[index]
-        ref = self.refer.loadRefs(ref_id)[0]
-
-        image_file = 'COCO_train2014_{:0>12}.jpg'.format(ref["image_id"])
-        image_path = os.path.join(self.vis_root, image_file)
-        image = Image.open(image_path).convert("RGB")
-        image_orig_size = image.size
-        image = self.vis_processor(image)
-        image_new_size = [image.shape[1], image.shape[2]]
-
-        image_new_size = [100,100]
-
-        sample_sentence = random.choice(ref['sentences'])['raw']
-        refer_sentence = self.text_processor(sample_sentence)
-
-
-        bbox = self.refer.getRefBox(ref['ref_id'])
-        bbox = [
-            bbox[0] / image_orig_size[0] * image_new_size[0],
-            bbox[1] / image_orig_size[1] * image_new_size[1],
-            (bbox[0] + bbox[2]) / image_orig_size[0] * image_new_size[0],
-            (bbox[1] + bbox[3]) / image_orig_size[1] * image_new_size[1]
-        ]
-        bbox = [int(x) for x in bbox]
-        bbox = "{{<{}><{}><{}><{}>}}".format(*bbox)
-        return {
-            "image": image,
-            "refer_sentence": refer_sentence,
-            "bbox": bbox,
-            "image_id": ref['image_id'],
-        }
-
-    def __getitem__(self, index):
-        data = self.preprocess(index)
-        instruction = random.choice(self.instruction_pool).format(data['refer_sentence'])
-
-        instruction = "<Img><ImageHere></Img> {} ".format(instruction)
-
-        return {
-            "image": data['image'],
-            "instruction_input": instruction,
-            "answer": data['bbox'],
-            "image_id": data['image_id'],
-        }
-
-
-class InvReferCOCODataset(ReferCOCODataset):
-    def __init__(self, *args, **kwargs):
-        super(InvReferCOCODataset, self).__init__(*args, **kwargs)
-
-        self.instruction_pool = [
-            "[identify] {}",
-            "[identify] what object is in this location {}",
-            "[identify] identify the object present at this location {}",
-            "[identify] what is it in {}",
-            "[identify] describe this object in {}",
-            "[identify] this {} is",
-            "[identify] the object in {} is",
-            ]
-
-    def __getitem__(self, index):
-        data = self.preprocess(index)
-
-        instruction = random.choice(self.instruction_pool).format(data['bbox'])
-
-        instruction = "<Img><ImageHere></Img> {} ".format(instruction)
-        
-        return {
-            "image": data['image'],
-            "instruction_input": instruction,
-            "answer": self.text_processor(data['refer_sentence']),
-            "image_id": data['image_id'],
-        }
-
-
-class REFER:
-    def __init__(self, data_root, vis_root, dataset='refcoco', splitBy='unc'):
-        # provide data_root folder which contains refclef, refcoco, refcoco+ and refcocog
-        # also provide dataset name and splitBy information
-        # e.g., dataset = 'refcoco', splitBy = 'unc'
-        dataset = dataset.split('inv')[-1]  # inv dataset is stored in the same path as normal dataset
-        print('loading dataset %s into memory...' % dataset)
-        self.ann_dir = os.path.join(data_root, dataset)
-        if dataset in ['refcoco', 'refcoco+', 'refcocog']:
-            self.vis_root = vis_root
-        elif dataset == 'refclef':
-            raise 'No RefClef image data'
-        else:
-            raise 'No refer dataset is called [%s]' % dataset
-
-        # load refs from data/dataset/refs(dataset).json
-        tic = time.time()
-        ref_file = os.path.join(self.ann_dir, 'refs(' + splitBy + ').p')
-        self.data = {}
-        self.data['dataset'] = dataset
-        self.data['refs'] = pickle.load(open(ref_file, 'rb'))
-
-        # load annotations from data/dataset/instances.json
-        instances_file = os.path.join(self.ann_dir, 'instances.json')
-        instances = json.load(open(instances_file, 'r'))
-        self.data['images'] = instances['images']
-        self.data['annotations'] = instances['annotations']
-        self.data['categories'] = instances['categories']
-
-        # create index
-        self.createIndex()
-        print('DONE (t=%.2fs)' % (time.time() - tic))
-
-    def createIndex(self):
-        # create sets of mapping
-        # 1)  Refs: 	 	{ref_id: ref}
-        # 2)  Anns: 	 	{ann_id: ann}
-        # 3)  Imgs:		 	{image_id: image}
-        # 4)  Cats: 	 	{category_id: category_name}
-        # 5)  Sents:     	{sent_id: sent}
-        # 6)  imgToRefs: 	{image_id: refs}
-        # 7)  imgToAnns: 	{image_id: anns}
-        # 8)  refToAnn:  	{ref_id: ann}
-        # 9)  annToRef:  	{ann_id: ref}
-        # 10) catToRefs: 	{category_id: refs}
-        # 11) sentToRef: 	{sent_id: ref}
-        # 12) sentToTokens: {sent_id: tokens}
-        print('creating index...')
-        # fetch info from instances
-        Anns, Imgs, Cats, imgToAnns = {}, {}, {}, {}
-        for ann in self.data['annotations']:
-            Anns[ann['id']] = ann
-            imgToAnns[ann['image_id']] = imgToAnns.get(ann['image_id'], []) + [ann]
-        for img in self.data['images']:
-            Imgs[img['id']] = img
-        for cat in self.data['categories']:
-            Cats[cat['id']] = cat['name']
-
-        # fetch info from refs
-        Refs, imgToRefs, refToAnn, annToRef, catToRefs = {}, {}, {}, {}, {}
-        Sents, sentToRef, sentToTokens = {}, {}, {}
-        for ref in self.data['refs']:
-            # ids
-            ref_id = ref['ref_id']
-            ann_id = ref['ann_id']
-            category_id = ref['category_id']
-            image_id = ref['image_id']
-
-            # add mapping related to ref
-            Refs[ref_id] = ref
-            imgToRefs[image_id] = imgToRefs.get(image_id, []) + [ref]
-            catToRefs[category_id] = catToRefs.get(category_id, []) + [ref]
-            refToAnn[ref_id] = Anns[ann_id]
-            annToRef[ann_id] = ref
-
-            # add mapping of sent
-            for sent in ref['sentences']:
-                Sents[sent['sent_id']] = sent
-                sentToRef[sent['sent_id']] = ref
-                sentToTokens[sent['sent_id']] = sent['tokens']
-
-        # create class members
-        self.Refs = Refs
-        self.Anns = Anns
-        self.Imgs = Imgs
-        self.Cats = Cats
-        self.Sents = Sents
-        self.imgToRefs = imgToRefs
-        self.imgToAnns = imgToAnns
-        self.refToAnn = refToAnn
-        self.annToRef = annToRef
-        self.catToRefs = catToRefs
-        self.sentToRef = sentToRef
-        self.sentToTokens = sentToTokens
-        print('index created.')
-
-    def getRefIds(self, image_ids=[], cat_ids=[], ref_ids=[], split=''):
-        image_ids = image_ids if type(image_ids) == list else [image_ids]
-        cat_ids = cat_ids if type(cat_ids) == list else [cat_ids]
-        ref_ids = ref_ids if type(ref_ids) == list else [ref_ids]
-
-        if len(image_ids) == len(cat_ids) == len(ref_ids) == len(split) == 0:
-            refs = self.data['refs']
-        else:
-            if not len(image_ids) == 0:
-                refs = [self.imgToRefs[image_id] for image_id in image_ids]
-            else:
-                refs = self.data['refs']
-            if not len(cat_ids) == 0:
-                refs = [ref for ref in refs if ref['category_id'] in cat_ids]
-            if not len(ref_ids) == 0:
-                refs = [ref for ref in refs if ref['ref_id'] in ref_ids]
-            if not len(split) == 0:
-                if split in ['testA', 'testB', 'testC']:
-                    refs = [ref for ref in refs if
-                            split[-1] in ref['split']]  # we also consider testAB, testBC, ...
-                elif split in ['testAB', 'testBC', 'testAC']:
-                    refs = [ref for ref in refs if ref['split'] == split]  # rarely used I guess...
-                elif split == 'test':
-                    refs = [ref for ref in refs if 'test' in ref['split']]
-                elif split == 'train' or split == 'val':
-                    refs = [ref for ref in refs if ref['split'] == split]
-                else:
-                    raise 'No such split [%s]' % split
-        ref_ids = [ref['ref_id'] for ref in refs]
-        return ref_ids
-
-    def getAnnIds(self, image_ids=[], cat_ids=[], ref_ids=[]):
-        image_ids = image_ids if type(image_ids) == list else [image_ids]
-        cat_ids = cat_ids if type(cat_ids) == list else [cat_ids]
-        ref_ids = ref_ids if type(ref_ids) == list else [ref_ids]
-
-        if len(image_ids) == len(cat_ids) == len(ref_ids) == 0:
-            ann_ids = [ann['id'] for ann in self.data['annotations']]
-        else:
-            if not len(image_ids) == 0:
-                lists = [self.imgToAnns[image_id] for image_id in image_ids if image_id in self.imgToAnns]  # list of [anns]
-                anns = list(itertools.chain.from_iterable(lists))
-            else:
-                anns = self.data['annotations']
-            if not len(cat_ids) == 0:
-                anns = [ann for ann in anns if ann['category_id'] in cat_ids]
-            ann_ids = [ann['id'] for ann in anns]
-            if not len(ref_ids) == 0:
-                ids = set(ann_ids).intersection(set([self.Refs[ref_id]['ann_id'] for ref_id in ref_ids]))
-        return ann_ids
-
-    def getImgIds(self, ref_ids=[]):
-        ref_ids = ref_ids if type(ref_ids) == list else [ref_ids]
-
-        if not len(ref_ids) == 0:
-            image_ids = list(set([self.Refs[ref_id]['image_id'] for ref_id in ref_ids]))
-        else:
-            image_ids = self.Imgs.keys()
-        return image_ids
-
-    def getCatIds(self):
-        return self.Cats.keys()
-
-    def loadRefs(self, ref_ids=[]):
-        if type(ref_ids) == list:
-            return [self.Refs[ref_id] for ref_id in ref_ids]
-        elif type(ref_ids) == int:
-            return [self.Refs[ref_ids]]
-
-    def loadAnns(self, ann_ids=[]):
-        if type(ann_ids) == list:
-            return [self.Anns[ann_id] for ann_id in ann_ids]
-        elif type(ann_ids) == int:
-            return [self.Anns[ann_ids]]
-
-    def loadImgs(self, image_ids=[]):
-        if type(image_ids) == list:
-            return [self.Imgs[image_id] for image_id in image_ids]
-        elif type(image_ids) == int:
-            return [self.Imgs[image_ids]]
-
-    def loadCats(self, cat_ids=[]):
-        if type(cat_ids) == list:
-            return [self.Cats[cat_id] for cat_id in cat_ids]
-        elif type(cat_ids) == int:
-            return [self.Cats[cat_ids]]
-
-    def getRefBox(self, ref_id):
-        ref = self.Refs[ref_id]
-        ann = self.refToAnn[ref_id]
-        return ann['bbox']  # [x, y, w, h]
-
-    def showRef(self, ref, seg_box='box'):
-        ax = plt.gca()
-        # show image
-        image = self.Imgs[ref['image_id']]
-        I = io.imread(os.path.join(self.vis_root, image['file_name']))
-        ax.imshow(I)
-        # show refer expression
-        for sid, sent in enumerate(ref['sentences']):
-            print('%s. %s' % (sid + 1, sent['sent']))
-        # show segmentations
-        if seg_box == 'seg':
-            ann_id = ref['ann_id']
-            ann = self.Anns[ann_id]
-            polygons = []
-            color = []
-            c = 'none'
-            if type(ann['segmentation'][0]) == list:
-                # polygon used for refcoco*
-                for seg in ann['segmentation']:
-                    poly = np.array(seg).reshape((len(seg) / 2, 2))
-                    polygons.append(Polygon(poly, True, alpha=0.4))
-                    color.append(c)
-                p = PatchCollection(polygons, facecolors=color, edgecolors=(1, 1, 0, 0), linewidths=3, alpha=1)
-                ax.add_collection(p)  # thick yellow polygon
-                p = PatchCollection(polygons, facecolors=color, edgecolors=(1, 0, 0, 0), linewidths=1, alpha=1)
-                ax.add_collection(p)  # thin red polygon
-            else:
-                # mask used for refclef
-                raise NotImplementedError('RefClef is not downloaded')
-        # show bounding-box
-        elif seg_box == 'box':
-            ann_id = ref['ann_id']
-            ann = self.Anns[ann_id]
-            bbox = self.getRefBox(ref['ref_id'])
-            box_plot = Rectangle((bbox[0], bbox[1]), bbox[2], bbox[3], fill=False, edgecolor='green', linewidth=3)
-            ax.add_patch(box_plot)

minigpt4/datasets/datasets/coco_vqa_datasets.py

@@ -1,145 +0,0 @@
-"""
- 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
-"""
-
-import os
-import json
-import random
-
-from PIL import Image
-
-from minigpt4.datasets.datasets.vqa_datasets import VQADataset, VQAEvalDataset
-
-from collections import OrderedDict
-
-
-class __DisplMixin:
-    def displ_item(self, index):
-        sample, ann = self.__getitem__(index), self.annotation[index]
-
-        return OrderedDict(
-            {
-                "file": ann["image"],
-                "question": ann["question"],
-                "question_id": ann["question_id"],
-                "answers": "; ".join(ann["answer"]),
-                "image": sample["image"],
-            }
-        )
-
-
-class COCOVQADataset(VQADataset, __DisplMixin):
-    def __init__(self, vis_processor, text_processor, vis_root, ann_paths):
-        super().__init__(vis_processor, text_processor, vis_root, ann_paths)
-
-        self.instruction_pool =[
-            "[vqa] {}",
-            "[vqa] Based on the image, respond to this question with a short answer: {}"
-        ]
-
-        exist_annotation = []
-        for ann in self.annotation:
-            image_path = os.path.join(self.vis_root, ann["image"].split('/')[-1])
-            if os.path.exists(image_path):
-                exist_annotation.append(ann)
-        self.annotation = exist_annotation
-
-
-    def get_data(self, index):
-        ann = self.annotation[index]
-
-        image_path = os.path.join(self.vis_root, ann["image"].split('/')[-1])
-        image = Image.open(image_path).convert("RGB")
-
-        image = self.vis_processor(image)
-        question = self.text_processor(ann["question"])
-        question_id = ann["question_id"]
-
-        answer_weight = {}
-        for answer in ann["answer"]:
-            if answer in answer_weight.keys():
-                answer_weight[answer] += 1 / len(ann["answer"])
-            else:
-                answer_weight[answer] = 1 / len(ann["answer"])
-
-        answers = list(answer_weight.keys())
-        weights = list(answer_weight.values())
-
-        answer = random.choices(answers, weights=weights, k=1)[0]  # random sample an answer according to weights
-
-
-        return {
-            "image": image,
-            "question": question,
-            "question_id": question_id,
-            "answer": answer,
-        }
-
-    def __getitem__(self, index):
-        data = self.get_data(index)
-        instruction = random.choice(self.instruction_pool).format(data['question'])
-        instruction = "<Img><ImageHere></Img> {} ".format(instruction)
-
-        return {
-            "image": data['image'],
-            "question_id": data["question_id"],
-            "instruction_input": instruction,
-            "answer": self.text_processor(data['answer']),
-        }
-
-
-class COCOVQAEvalDataset(VQAEvalDataset, __DisplMixin):
-    def __init__(self, vis_processor, text_processor, vis_root, ann_paths):
-        """
-        vis_root (string): Root directory of images (e.g. coco/images/)
-        ann_root (string): directory to store the annotation file
-        """
-        
-        self.instruction_pool = [
-            'Question: {} Short answer:',
-        ]
-        self.vis_root = vis_root
-
-        self.annotation = json.load(open(ann_paths[0]))
-
-        answer_list_path = ann_paths[1]
-        if os.path.exists(answer_list_path):
-            self.answer_list = json.load(open(answer_list_path))
-        else:
-            self.answer_list = None
-
-        try:
-            self.coco_fmt_qust_file = ann_paths[2]
-            self.coco_fmt_anno_file = ann_paths[3]
-        except IndexError:
-            self.coco_fmt_qust_file = None
-            self.coco_fmt_anno_file = None
-
-        self.vis_processor = vis_processor
-        self.text_processor = text_processor
-
-        self._add_instance_ids()
-
-    def __getitem__(self, index):
-        ann = self.annotation[index]
-
-        image_path = os.path.join(self.vis_root, ann["image"])
-        image = Image.open(image_path).convert("RGB")
-
-        image = self.vis_processor(image)
-        question = self.text_processor(ann["question"])
-        
-        instruction = random.choice(self.instruction_pool).format(question)
-        instruction = "<Img><ImageHere></Img> {} ".format(instruction)
-        
-        return {
-            "image": image,
-            'image_path': image_path,
-            "question": question,
-            "question_id": ann["question_id"],
-            "instruction_input": instruction,
-            "instance_id": ann["instance_id"],
-        }

minigpt4/datasets/datasets/dataloader_utils.py

@@ -1,162 +0,0 @@
-"""
- 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 time
-import random
-import torch
-from minigpt4.datasets.data_utils import move_to_cuda
-from torch.utils.data import DataLoader
-
-
-class MultiIterLoader:
-    """
-    A simple wrapper for iterating over multiple iterators.
-
-    Args:
-        loaders (List[Loader]): List of Iterator loaders.
-        ratios (List[float]): List of ratios to sample from each loader. If None, all loaders are sampled uniformly.
-    """
-
-    def __init__(self, loaders, ratios=None):
-        # assert all loaders has __next__ method
-        for loader in loaders:
-            assert hasattr(
-                loader, "__next__"
-            ), "Loader {} has no __next__ method.".format(loader)
-
-        if ratios is None:
-            ratios = [1.0] * len(loaders)
-        else:
-            assert len(ratios) == len(loaders)
-            ratios = [float(ratio) / sum(ratios) for ratio in ratios]
-
-        self.loaders = loaders
-        self.ratios = ratios
-
-    def __next__(self):
-        # random sample from each loader by ratio
-        loader_idx = random.choices(range(len(self.loaders)), self.ratios, k=1)[0]
-        return next(self.loaders[loader_idx])
-
-
-class PrefetchLoader(object):
-    """
-    Modified from https://github.com/ChenRocks/UNITER.
-
-    overlap compute and cuda data transfer
-    (copied and then modified from nvidia apex)
-    """
-
-    def __init__(self, loader):
-        self.loader = loader
-        self.stream = torch.cuda.Stream()
-
-    def __iter__(self):
-        loader_it = iter(self.loader)
-        self.preload(loader_it)
-        batch = self.next(loader_it)
-        while batch is not None:
-            is_tuple = isinstance(batch, tuple)
-            if is_tuple:
-                task, batch = batch
-
-            if is_tuple:
-                yield task, batch
-            else:
-                yield batch
-            batch = self.next(loader_it)
-
-    def __len__(self):
-        return len(self.loader)
-
-    def preload(self, it):
-        try:
-            self.batch = next(it)
-        except StopIteration:
-            self.batch = None
-            return
-        # if record_stream() doesn't work, another option is to make sure
-        # device inputs are created on the main stream.
-        # self.next_input_gpu = torch.empty_like(self.next_input,
-        #                                        device='cuda')
-        # self.next_target_gpu = torch.empty_like(self.next_target,
-        #                                         device='cuda')
-        # Need to make sure the memory allocated for next_* is not still in use
-        # by the main stream at the time we start copying to next_*:
-        # self.stream.wait_stream(torch.cuda.current_stream())
-        with torch.cuda.stream(self.stream):
-            self.batch = move_to_cuda(self.batch)
-            # more code for the alternative if record_stream() doesn't work:
-            # copy_ will record the use of the pinned source tensor in this
-            # side stream.
-            # self.next_input_gpu.copy_(self.next_input, non_blocking=True)
-            # self.next_target_gpu.copy_(self.next_target, non_blocking=True)
-            # self.next_input = self.next_input_gpu
-            # self.next_target = self.next_target_gpu
-
-    def next(self, it):
-        torch.cuda.current_stream().wait_stream(self.stream)
-        batch = self.batch
-        if batch is not None:
-            record_cuda_stream(batch)
-        self.preload(it)
-        return batch
-
-    def __getattr__(self, name):
-        method = self.loader.__getattribute__(name)
-        return method
-
-
-def record_cuda_stream(batch):
-    if isinstance(batch, torch.Tensor):
-        batch.record_stream(torch.cuda.current_stream())
-    elif isinstance(batch, list) or isinstance(batch, tuple):
-        for t in batch:
-            record_cuda_stream(t)
-    elif isinstance(batch, dict):
-        for t in batch.values():
-            record_cuda_stream(t)
-    else:
-        pass
-
-
-class IterLoader:
-    """
-    A wrapper to convert DataLoader as an infinite iterator.
-
-    Modified from:
-        https://github.com/open-mmlab/mmcv/blob/master/mmcv/runner/iter_based_runner.py
-    """
-
-    def __init__(self, dataloader: DataLoader, use_distributed: bool = False):
-        self._dataloader = dataloader
-        self.iter_loader = iter(self._dataloader)
-        self._use_distributed = use_distributed
-        self._epoch = 0
-
-    @property
-    def epoch(self) -> int:
-        return self._epoch
-
-    def __next__(self):
-        try:
-            data = next(self.iter_loader)
-        except StopIteration:
-            self._epoch += 1
-            if hasattr(self._dataloader.sampler, "set_epoch") and self._use_distributed:
-                self._dataloader.sampler.set_epoch(self._epoch)
-            time.sleep(2)  # Prevent possible deadlock during epoch transition
-            self.iter_loader = iter(self._dataloader)
-            data = next(self.iter_loader)
-
-        return data
-
-    def __iter__(self):
-        return self
-
-    def __len__(self):
-        return len(self._dataloader)

minigpt4/datasets/datasets/flickr.py

@@ -1,159 +0,0 @@
-import os
-import json
-import pickle
-import random
-import time
-import itertools
-
-import numpy as np
-from PIL import Image
-import skimage.io as io
-import matplotlib.pyplot as plt
-from matplotlib.collections import PatchCollection
-from matplotlib.patches import Polygon, Rectangle
-from torch.utils.data import Dataset
-import webdataset as wds
-
-from minigpt4.datasets.datasets.base_dataset import BaseDataset
-from minigpt4.datasets.datasets.caption_datasets import CaptionDataset
-
-
-class GroundedDetailDataset(Dataset):
-    def __init__(self, vis_processor, text_processor, vis_root, ann_path):
-        """
-        vis_root (string): Root directory of images (e.g. coco/images/)
-        ann_root (string): directory to store the annotation file
-        """
-        self.vis_root = vis_root
-
-        self.vis_processor = vis_processor
-        self.text_processor = text_processor
-
-        self.instruction_pool = [
-            '[grounding] please describe this image in details',
-            '[grounding] describe this image as detailed as possible',
-            '[grounding] summarize this image in details',
-            '[grounding] give a thorough description of what you see in this image',
-        ]
-
-        with open(ann_path, 'r') as f:
-            self.ann = json.load(f)
-
-    def __len__(self):
-        return len(self.ann)
-
-    def __getitem__(self, index):
-        info = self.ann[index]
-
-        # image_file = 'COCO_train2014_{}.jpg'.format(info['image_id'])
-        image_file = '{}.jpg'.format(info['image_id'])
-        image_path = os.path.join(self.vis_root, image_file)
-        image = Image.open(image_path).convert("RGB")
-        image = self.vis_processor(image)
-
-        answer = info['grounded_caption']
-        instruction = random.choice(self.instruction_pool)
-        instruction = "<Img><ImageHere></Img> {} ".format(instruction)
-
-        return {
-            "image": image,
-            "instruction_input": instruction,
-            "answer": answer,
-            "image_id": info['image_id'],
-        }
-
-
-
-
-class CaptionToObjectDataset(Dataset):
-    def __init__(self, vis_processor, text_processor, vis_root, ann_path):
-        """
-        vis_root (string): Root directory of images (e.g. coco/images/)
-        ann_root (string): directory to store the annotation file
-        """
-        self.vis_root = vis_root
-
-        self.vis_processor = vis_processor
-        self.text_processor = text_processor
-
-        self.instruction_pool = [
-            '[detection] {}',
-        ]
-
-        with open(ann_path, 'r') as f:
-            self.ann = json.load(f)
-
-    def __len__(self):
-        return len(self.ann)
-
-    def __getitem__(self, index):
-        info = self.ann[index]
-
-        image_file = '{}.jpg'.format(info['image_id'])
-        image_path = os.path.join(self.vis_root, image_file)
-        image = Image.open(image_path).convert("RGB")
-        image = self.vis_processor(image)
-
-        input = info["caption"]
-        answer = info["output"]
-
-        instruction = random.choice(self.instruction_pool).format(input)
-
-        instruction = "<Img><ImageHere></Img> {} ".format(instruction)
-
-        print("CaptionToObject instruction", instruction)
-        print("CaptionToObject answer", answer)
-
-        return {
-            "image": image,
-            "instruction_input": instruction,
-            "answer": answer,
-            "image_id": info['image_id'],
-        }
-
-
-
-
-class PhraseToObjectDataset(Dataset):
-    def __init__(self, vis_processor, text_processor, vis_root, ann_path):
-        """
-        vis_root (string): Root directory of images (e.g. coco/images/)
-        ann_root (string): directory to store the annotation file
-        """
-        self.vis_root = vis_root
-
-        self.vis_processor = vis_processor
-        self.text_processor = text_processor
-
-        self.instruction_pool = [
-            '[detection] {}',
-        ]
-
-        with open(ann_path, 'r') as f:
-            self.ann = json.load(f)
-
-    def __len__(self):
-        return len(self.ann)
-
-    def __getitem__(self, index):
-        info = self.ann[index]
-        image_file = '{}.jpg'.format(info['image_id'])
-        image_path = os.path.join(self.vis_root, image_file)
-        image = Image.open(image_path).convert("RGB")
-        image = self.vis_processor(image)
-
-        input = info["phrase"]
-        answer = "<p>"+input+"</p> "+info["bbox"]
-        instruction = random.choice(self.instruction_pool).format(input)
-
-        instruction = "<Img><ImageHere></Img> {} ".format(instruction)
-
-        print("PhraseToObject instruction", instruction)
-        print("PhraseToObject answer", answer)
-
-        return {
-            "image": image,
-            "instruction_input": instruction,
-            "answer": answer,
-            "image_id": info['image_id'],
-        }

minigpt4/datasets/datasets/gqa_datasets.py

@@ -1,60 +0,0 @@
-"""
- 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
-"""
-
-import os
-import json
-
-from PIL import Image
-
-from minigpt4.datasets.datasets.vqa_datasets import VQADataset
-
-from collections import OrderedDict
-import random
-
-class __DisplMixin:
-    def displ_item(self, index):
-        sample, ann = self.__getitem__(index), self.annotation[index]
-
-        return OrderedDict(
-            {
-                "file": ann["image"],
-                "question": ann["question"],
-                "question_id": ann["question_id"],
-                "answers": "; ".join(ann["answer"]),
-                "image": sample["image"],
-            }
-        )
-
-
-class GQADataset(VQADataset, __DisplMixin):
-    def __init__(self, vis_processor, text_processor, vis_root, ann_paths):
-        super().__init__(vis_processor, text_processor, vis_root, ann_paths)
-        self.instruction_pool =[
-            "[vqa] {}",
-            "[vqa] Based on the image, respond to this question with a short answer: {}"
-        ]
-
-    def __getitem__(self, index):
-        ann = self.annotation[index]
-
-        image_path = os.path.join(self.vis_root, ann["image"])
-        image = Image.open(image_path).convert("RGB")
-
-        image = self.vis_processor(image)
-        question = self.text_processor(ann["question"])
-
-        instruction = random.choice(self.instruction_pool).format(question)
-        instruction = "<Img><ImageHere></Img> {} ".format(instruction)
-
-        answers = self.text_processor(ann["answer"])
-
-        return {
-            "image": image,
-            "instruction_input": instruction,
-            "answer": answers,
-        }
-

minigpt4/datasets/datasets/laion_dataset.py

@@ -1,31 +0,0 @@
-"""
- 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 webdataset as wds
-from minigpt4.datasets.datasets.base_dataset import BaseDataset
-
-
-class LaionDataset(BaseDataset):
-    def __init__(self, vis_processor, text_processor, location):
-        super().__init__(vis_processor=vis_processor, text_processor=text_processor)
-
-        self.inner_dataset = wds.DataPipeline(
-            wds.ResampledShards(location),
-            wds.tarfile_to_samples(handler=wds.warn_and_continue),
-            wds.shuffle(1000, handler=wds.warn_and_continue),
-            wds.decode("pilrgb", handler=wds.warn_and_continue),
-            wds.to_tuple("jpg", "json", handler=wds.warn_and_continue),
-            wds.map_tuple(self.vis_processor, handler=wds.warn_and_continue),
-            wds.map(self.to_dict, handler=wds.warn_and_continue),
-        )
-
-    def to_dict(self, sample):
-        return {
-            "image": sample[0],
-            "answer": self.text_processor(sample[1]["caption"]),
-        }
-

minigpt4/datasets/datasets/llava_dataset.py

@@ -1,149 +0,0 @@
-import os
-import json
-import pickle
-import random
-import time
-import numpy as np
-from PIL import Image
-import skimage.io as io
-import matplotlib.pyplot as plt
-from matplotlib.collections import PatchCollection
-from matplotlib.patches import Polygon, Rectangle
-from torch.utils.data import Dataset
-import webdataset as wds
-
-from minigpt4.datasets.datasets.base_dataset import BaseDataset
-from minigpt4.datasets.datasets.caption_datasets import CaptionDataset
-
-class LlavaDetailDataset(Dataset):
-    def __init__(self, vis_processor, text_processor, vis_root, ann_path):
-        """
-        vis_root (string): Root directory of images (e.g. coco/images/)
-        ann_root (string): directory to store the annotation file
-        """
-        self.vis_root = vis_root
-
-        self.vis_processor = vis_processor
-        self.text_processor = text_processor
-
-        with open(ann_path, 'r') as f:
-            self.ann = json.load(f)
-
-    def __len__(self):
-        return len(self.ann)
-
-    def __getitem__(self, index):
-        info = self.ann[index]
-
-        image_file = 'COCO_train2014_{}.jpg'.format(info['id'])
-        image_path = os.path.join(self.vis_root, image_file)
-        image = Image.open(image_path).convert("RGB")
-        image = self.vis_processor(image)
-
-        answer = info['conversations'][1]['value']
-        instruction = info['conversations'][0]['value'].replace('<image>', '').replace('\n', '').strip()
-        
-        instruction = '<Img><ImageHere></Img> {} '.format(self.text_processor(instruction))
-
-        return {
-            "image": image,
-            "instruction_input": instruction,
-            "answer": answer,
-            "image_id": info['id'],
-        }
-
-class LlavaReasonDataset(Dataset):
-    def __init__(self, vis_processor, text_processor, vis_root, ann_path):
-        """
-        vis_root (string): Root directory of images (e.g. coco/images/)
-        ann_root (string): directory to store the annotation file
-        """
-        self.vis_root = vis_root
-
-        self.vis_processor = vis_processor
-        self.text_processor = text_processor
-
-        with open(ann_path, 'r') as f:
-            self.ann = json.load(f)
-
-    def __len__(self):
-        return len(self.ann)
-
-    def __getitem__(self, index):
-        info = self.ann[index]
-
-        image_file = 'COCO_train2014_{}.jpg'.format(info['id'])
-        image_path = os.path.join(self.vis_root, image_file)
-        image = Image.open(image_path).convert("RGB")
-        image = self.vis_processor(image)
-
-        answer = info['conversations'][1]['value']
-        instruction = info['conversations'][0]['value'].replace('<image>', '').replace('\n', '').strip()
-
-        instruction = '<Img><ImageHere></Img> {} '.format(self.text_processor(instruction))
-
-        return {
-            "image": image,
-            "instruction_input": instruction,
-            "answer": answer,
-            "image_id": info['id'],
-        }
-
-
-
-
-class LlavaConversationDataset(Dataset):
-    def __init__(self, vis_processor, text_processor, vis_root, ann_path):
-        """
-        vis_root (string): Root directory of images (e.g. coco/images/)
-        ann_root (string): directory to store the annotation file
-        """
-        self.vis_root = vis_root
-
-        self.vis_processor = vis_processor
-        self.text_processor = text_processor
-
-        self.ann=[]
-
-    
-        with open(ann_path, 'r') as f:
-            self.ann = json.load(f)
-
-        self.connect_sym = "!@#"
-
-    def __len__(self):
-        return len(self.ann)
-
-    def __getitem__(self, index):
-        info = self.ann[index]
-
-        image_file = 'COCO_train2014_{}.jpg'.format(info['id'])
-        image_path = os.path.join(self.vis_root, image_file)
-        image = Image.open(image_path).convert("RGB")
-        image = self.vis_processor(image)
-
-        first_instruction = info['conversations'][0]['value'].replace('<image>', '').replace('\n', '').strip()
-        first_instruction = '<Img><ImageHere></Img> {} '.format(first_instruction)
-
-        questions = [first_instruction]
-        answers = []
-
-        for i, item in enumerate(info["conversations"][1:]):
-            if i % 2 ==0:  # assistant
-                assistant_answer = item["value"]
-                answers.append(assistant_answer)
-            else:
-                human_instruction = item["value"]+" "
-                questions.append(human_instruction)
-
-        questions = self.connect_sym.join(questions)
-        answers = self.connect_sym.join(answers)
-
-
-        return {
-            "image": image,
-            "conv_q": questions,
-            'conv_a': answers,
-            "image_id": info['id'],
-            "connect_sym": self.connect_sym
-        }

minigpt4/datasets/datasets/multitask_conversation.py

@@ -1,75 +0,0 @@
-import os
-import json
-import pickle
-import random
-import time
-import itertools
-
-import numpy as np
-from PIL import Image
-import skimage.io as io
-import matplotlib.pyplot as plt
-from matplotlib.collections import PatchCollection
-from matplotlib.patches import Polygon, Rectangle
-from torch.utils.data import Dataset
-import webdataset as wds
-
-from minigpt4.datasets.datasets.base_dataset import BaseDataset
-from minigpt4.datasets.datasets.caption_datasets import CaptionDataset
-
-
-
-
-class MultiTaskConversationDataset(Dataset):
-    def __init__(self, vis_processor, text_processor, vis_root, ann_path):
-        """
-        vis_root (string): Root directory of images (e.g. coco/images/)
-        ann_root (string): directory to store the annotation file
-        """
-        self.vis_root = vis_root
-
-        self.vis_processor = vis_processor
-        self.text_processor = text_processor
-
-
-        with open(ann_path, 'r') as f:
-            self.ann = json.load(f)
-
-        self.connect_sym = "!@#"
-
-    def __len__(self):
-        return len(self.ann)
-
-    def __getitem__(self, index):
-        info = self.ann[index]
-
-        image_file = 'COCO_train2014_{}.jpg'.format(info['id'])
-        image_path = os.path.join(self.vis_root, image_file)
-        image = Image.open(image_path).convert("RGB")
-        image = self.vis_processor(image)
-
-        first_instruction = info['conversations'][0]['value'].replace('<image>', '').replace('\n', '').strip()
-        first_instruction = '<Img><ImageHere></Img> {} '.format(first_instruction)
-
-        questions = [first_instruction]
-        answers = []
-
-        for i, item in enumerate(info["conversations"][1:]):
-            if i % 2 ==0:  # assistant
-                assistant_answer = item["value"]
-                answers.append(assistant_answer)
-            else:
-                human_instruction = item["value"]+" "
-                questions.append(human_instruction)
-
-        questions = self.connect_sym.join(questions)
-        answers = self.connect_sym.join(answers)
-
-
-        return {
-            "image": image,
-            "conv_q": questions,
-            'conv_a': answers,
-            "image_id": info['id'],
-            "connect_sym": self.connect_sym
-        }

minigpt4/datasets/datasets/ocrvqa_dataset.py

@@ -1,77 +0,0 @@
-import os
-import json
-import pickle
-import random
-import time
-import itertools
-
-import numpy as np
-from PIL import Image
-import skimage.io as io
-import matplotlib.pyplot as plt
-from matplotlib.collections import PatchCollection
-from matplotlib.patches import Polygon, Rectangle
-from torch.utils.data import Dataset
-import webdataset as wds
-
-from minigpt4.datasets.datasets.base_dataset import BaseDataset
-from minigpt4.datasets.datasets.caption_datasets import CaptionDataset
-
-
-class OCRVQADataset(Dataset):
-    def __init__(self, vis_processor, text_processor, vis_root, ann_path):
-        """
-        vis_root (string): Root directory of images (e.g. coco/images/)
-        ann_root (string): directory to store the annotation file
-        """
-        self.vis_root = vis_root
-
-        self.vis_processor = vis_processor
-        self.text_processor = text_processor
-        self.data = self.create_data(ann_path)
-
-        self.instruction_pool =[
-            "[vqa] {}",
-            "[vqa] Based on the image, respond to this question with a short answer: {}"
-        ]
-
-    def create_data(self, ann_path):
-        processed_data = []
-        with open(ann_path, 'r') as f:
-            data = json.load(f)
-        for k in data.keys():
-            if data[k]['split'] != 1: continue  # 1 for training, 2 for validation, 3 for test
-            ext = os.path.splitext(data[k]['imageURL'])[1]
-            imageFile = k + ext
-            assert len(data[k]['questions']) == len(data[k]['answers'])
-            for q, a in zip(data[k]['questions'], data[k]['answers']):
-                processed_data.append(
-                    {'question': q,
-                     'answer': a,
-                     'image_path': imageFile,
-                     'image_id': k,
-                     'title': data[k]['title'],
-                     'genre': data[k]['genre'],
-                     }
-                )
-        return processed_data
-
-    def __len__(self):
-        return len(self.data)
-
-    def __getitem__(self, index):
-        sample = self.data[index]
-        image = Image.open(os.path.join(self.vis_root, sample['image_path'])).convert("RGB")
-        image = self.vis_processor(image)
-        question = self.text_processor(sample["question"])
-        answer = self.text_processor(sample["answer"])
-
-        instruction = random.choice(self.instruction_pool).format(question)
-        instruction = "<Img><ImageHere></Img> {} ".format(instruction)
-        return {
-            "image": image,
-            "instruction_input": instruction,
-            "answer": answer,
-            "image_id": sample['image_id']
-        }
-