add loading script

refer.py

@@ -0,0 +1,345 @@
+__author__ = 'licheng'
+"""
+Modified to make it work with Python 3+.
+
+This interface provides access to four datasets:
+1) refclef
+2) refcoco
+3) refcoco+
+4) refcocog
+split by unc and google
+The following API functions are defined:
+REFER     - REFER api class
+getRefIds - get ref ids that satisfy given filter conditions.
+getAnnIds - get ann ids that satisfy given filter conditions.
+getImgIds - get image ids that satisfy given filter conditions.
+getCatIds - get category ids that satisfy given filter conditions.
+loadRefs  - load refs with the specified ref ids.
+loadAnns  - load anns with the specified ann ids.
+loadImgs  - load images with the specified image ids.
+loadCats  - load category names with the specified category ids.
+getRefBox - get ref's bounding box [x, y, w, h] given the ref_id
+showRef   - show image, segmentation or box of the referred object with the ref
+getMask   - get mask and area of the referred object given ref
+showMask  - show mask of the referred object given ref
+"""
+
+import itertools
+import json
+import os.path as osp
+import pickle
+import sys
+import time
+from pprint import pprint
+
+import matplotlib.pyplot as plt
+import numpy as np
+import skimage.io as io
+from matplotlib.collections import PatchCollection
+from matplotlib.patches import Polygon, Rectangle
+from pycocotools import mask
+
+
+class REFER:
+    def __init__(self, data_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'
+        print('loading dataset %s into memory...' % dataset)
+        self.ROOT_DIR = osp.abspath(osp.dirname(__file__))
+        self.DATA_DIR = osp.join(data_root, dataset)
+        if dataset in ['refcoco', 'refcoco+', 'refcocog']:
+            self.IMAGE_DIR = osp.join(data_root, 'images/train2014')
+        elif dataset == 'refclef':
+            self.IMAGE_DIR = osp.join(data_root, 'images/saiapr_tc-12')
+        else:
+            print('No refer dataset is called [%s]' % dataset)
+            sys.exit()
+
+        # load refs from data/dataset/refs(dataset).json
+        tic = time.time()
+        ref_file = osp.join(self.DATA_DIR, 'refs(' + splitBy + ').p')
+        self.data = {}
+        self.data['dataset'] = dataset
+
+        self.data['refs'] = pickle.load(open(ref_file, 'rb'), fix_imports=True)
+
+        # load annotations from data/dataset/instances.json
+        instances_file = osp.join(self.DATA_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 isinstance(image_ids, list) else [image_ids]
+        cat_ids = cat_ids if isinstance(cat_ids, list) else [cat_ids]
+        ref_ids = ref_ids if isinstance(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]
+                refs = list(itertools.chain.from_iterable(refs))
+            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:
+                    print('No such split [%s]' % split)
+                    sys.exit()
+        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 isinstance(image_ids, list) else [image_ids]
+        cat_ids = cat_ids if isinstance(cat_ids, list) else [cat_ids]
+        ref_ids = ref_ids if isinstance(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(  # noqa
+                    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 isinstance(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 isinstance(ref_ids, list):
+            return [self.Refs[ref_id] for ref_id in ref_ids]
+        elif isinstance(ref_ids, int):
+            return [self.Refs[ref_ids]]
+
+    def loadAnns(self, ann_ids=[]):
+        if isinstance(ann_ids, list):
+            return [self.Anns[ann_id] for ann_id in ann_ids]
+        elif isinstance(ann_ids, int) or isinstance(ann_ids, str):
+            return [self.Anns[ann_ids]]
+
+    def loadImgs(self, image_ids=[]):
+        if isinstance(image_ids, list):
+            return [self.Imgs[image_id] for image_id in image_ids]
+        elif isinstance(image_ids, int):
+            return [self.Imgs[image_ids]]
+
+    def loadCats(self, cat_ids=[]):
+        if isinstance(cat_ids, list):
+            return [self.Cats[cat_id] for cat_id in cat_ids]
+        elif isinstance(cat_ids, int):
+            return [self.Cats[cat_ids]]
+
+    def getRefBox(self, ref_id):
+        ref = self.Refs[ref_id]  # noqa
+        ann = self.refToAnn[ref_id]
+        return ann['bbox']  # [x, y, w, h]
+
+    def showRef(self, ref, seg_box='seg'):
+        ax = plt.gca()
+        # show image
+        image = self.Imgs[ref['image_id']]
+        _img = io.imread(osp.join(self.IMAGE_DIR, image['file_name']))
+        ax.imshow(_img)
+        # 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 isinstance(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
+                rle = ann['segmentation']
+                m = mask.decode(rle)
+                img = np.ones((m.shape[0], m.shape[1], 3))
+                color_mask = np.array([2.0, 166.0, 101.0]) / 255
+                for i in range(3):
+                    img[:, :, i] = color_mask[i]
+                ax.imshow(np.dstack((img, m * 0.5)))
+        # 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)
+
+    def getMask(self, ref):
+        # return mask, area and mask-center
+        ann = self.refToAnn[ref['ref_id']]
+        image = self.Imgs[ref['image_id']]
+        if isinstance(ann['segmentation'][0], list):  # polygon
+            rle = mask.frPyObjects(ann['segmentation'], image['height'],
+                                   image['width'])
+        else:
+            rle = ann['segmentation']
+
+        # for i in range(len(rle['counts'])):
+        # print(rle)
+        m = mask.decode(rle)
+        # sometimes there are multiple binary map (multiple segs)
+        m = np.sum(m, axis=2)
+        m = m.astype(np.uint8)  # convert to np.uint8
+        # compute area
+        area = sum(mask.area(rle))  # should be close to ann['area']
+        return {'mask': m, 'area': area}
+
+    def showMask(self, ref):
+        M = self.getMask(ref)
+        msk = M['mask']
+        ax = plt.gca()
+        ax.imshow(msk)
+
+
+if __name__ == '__main__':
+    refer = REFER(dataset='refcocog', splitBy='google')
+    ref_ids = refer.getRefIds()
+    print(len(ref_ids))
+
+    print(len(refer.Imgs))
+    print(len(refer.imgToRefs))
+
+    ref_ids = refer.getRefIds(split='train')
+    print('There are %s training referred objects.' % len(ref_ids))
+
+    for ref_id in ref_ids:
+        ref = refer.loadRefs(ref_id)[0]
+        if len(ref['sentences']) < 2:
+            continue
+
+        pprint(ref)
+        print('The label is %s.' % refer.Cats[ref['category_id']])
+        plt.figure()
+        refer.showRef(ref, seg_box='box')
+        plt.show()

referit.py

@@ -0,0 +1,203 @@
+# Copyright 2020 The HuggingFace Datasets Authors and the current dataset
+# script contributor.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# TODO: Address all TODOs and remove all explanatory comments
+"""TODO: Add a description here."""
+
+
+import os.path as osp
+
+import datasets
+from .refer import REFER
+
+
+# TODO: Add BibTeX citation
+# Find for instance the citation on arxiv or on the dataset repo/website
+_CITATION = """\
+@InProceedings{huggingface:dataset,
+title = {A great new dataset},
+author={huggingface, Inc.
+},
+year={2020}
+}
+"""
+
+# TODO: Add description of the dataset here
+# You can copy an official description
+_DESCRIPTION = """\
+This RefCOCO dataset is designed to load refcoco, refcoco+, and refcocog.
+"""
+
+# TODO: Add a link to an official homepage for the dataset here
+_HOMEPAGE = ""
+
+# TODO: Add the licence for the dataset here if you can find it
+_LICENSE = ""
+
+# TODO: Add link to the official dataset URLs here
+# The HuggingFace Datasets library doesn't host the datasets but only points
+# to the original files.
+# This can be an arbitrary nested dict/list of URLs
+# (see below in `_split_generators` method)
+_URLS = {}
+
+
+VALID_SPLIT_NAMES = ("train", "val", "testA", "testB")
+
+
+class ReferitBuilderConfig(datasets.BuilderConfig):
+
+    def __init__(self, name: str, split_by: str, **kwargs):
+        super().__init__(name, **kwargs)
+        self.split_by = split_by
+
+
+# TODO: Name of the dataset usually matches the script name with CamelCase
+# instead of snake_case
+class ReferitDataset(datasets.GeneratorBasedBuilder):
+    """TODO: Short description of my dataset."""
+
+    VERSION = datasets.Version("0.0.1")
+
+    # This is an example of a dataset with multiple configurations.
+    # If you don't want/need to define several sub-sets in your dataset,
+    # just remove the BUILDER_CONFIG_CLASS and the BUILDER_CONFIGS attributes.
+
+    # If you need to make complex sub-parts in the datasets with configurable
+    # options
+    # You can create your own builder configuration class to store attribute,
+    # inheriting from datasets.BuilderConfig
+    BUILDER_CONFIG_CLASS = ReferitBuilderConfig
+
+    # You will be able to load one or the other configurations
+    # in the following list with
+    # data = datasets.load_dataset('my_dataset', 'first_domain')
+    # data = datasets.load_dataset('my_dataset', 'second_domain')
+    BUILDER_CONFIGS = [
+        # refcoco
+        ReferitBuilderConfig(
+            name="refcoco", split_by="unc",
+            version=VERSION, description="refcoco."),
+        # refcoco+
+        ReferitBuilderConfig(
+            name="refcoco+", split_by="unc",
+            version=VERSION, description="refcoco+"),
+        # refcocog
+        ReferitBuilderConfig(
+            name="refcocog", split_by="umd",
+            version=VERSION, description="refcocog"),
+    ]
+
+    # It's not mandatory to have a default configuration.
+    # Just use one if it make sense.
+    DEFAULT_CONFIG_NAME = "refcoco"
+
+    def _info(self):
+        self.config: ReferitBuilderConfig
+        features = datasets.Features(
+            {
+                "ref_id": datasets.Value("int32"),
+                "img_id": datasets.Value("int32"),
+                "ann_id": datasets.Value("int32"),
+                "file_name": datasets.Value("string"),
+                "image_path": datasets.Value("string"),
+                "height": datasets.Value("int32"),
+                "width": datasets.Value("int32"),
+                "coco_url": datasets.Value("string"),
+                "sentences": [datasets.Value("string")],
+                "segmentation": [[[datasets.Value("float")]]],
+                "bbox": [[datasets.Value("float")]],
+                "area": datasets.Value("float"),
+                "iscrowd": datasets.Value("int32"),
+                "category_id": datasets.Value("int32"),
+            }
+        )
+        return datasets.DatasetInfo(
+            # This is the description that will appear on the datasets page.
+            description=_DESCRIPTION,
+            # This defines the different columns of the dataset and their types
+            features=features,
+            # If there's a common (input, target) tuple from the features,
+            # uncomment supervised_keys line below and specify them.
+            # They'll be used if as_supervised=True in builder.as_dataset.
+            # supervised_keys=("sentence", "label"),
+            # Homepage of the dataset for documentation
+            homepage=_HOMEPAGE,
+            # License for the dataset if available
+            license=_LICENSE,
+            # Citation for the dataset
+            citation=_CITATION,
+        )
+
+    def _split_generators(self, dl_manager):
+        # TODO: This method is tasked with downloading/extracting the data and
+        # defining the splits depending on the configuration
+        # If several configurations are possible (listed in BUILDER_CONFIGS),
+        # the configuration selected by the user is in self.config.name
+
+        # dl_manager is a datasets.download.DownloadManager that can be used
+        # to download and extract URLS. It can accept any type
+        # or nested list/dict and will give back the same structure with
+        # the url replaced with path to local files.
+        # By default the archives will be extracted and a path to a cached
+        # folder where they are extracted is returned instead of the archive
+        # urls = _URLS[self.config.name]
+        # data_dir = dl_manager.download_and_extract(urls)
+        splits = []
+        for split in ("train", "val", "test", "testA", "testB"):
+            splits.append(datasets.SplitGenerator(
+                name=datasets.NamedSplit(split),
+                gen_kwargs={
+                    "split": split,
+                },
+            ))
+        return splits
+
+    # method parameters are unpacked from `gen_kwargs` as given in
+    # `_split_generators`
+    def _generate_examples(self, split: str):
+        # TODO: This method handles input defined in _split_generators to
+        # yield (key, example) tuples from the dataset.
+        # The `key` is for legacy reasons (tfds) and is not important
+        # in itself, but must be unique for each example.
+        refer = REFER(data_root=self.config.data_dir,
+                      dataset=self.config.name,
+                      splitBy=self.config.split_by)
+        ref_ids = refer.getRefIds(split=split)
+        for ref_id in ref_ids:
+            ref = refer.loadRefs(ref_id)[0]
+            ann_id = ref['ann_id']
+            ann = refer.loadAnns(ann_id)[0]
+            img_id = ann['image_id']
+            img = refer.loadImgs(img_id)[0]
+            file_name = img['file_name']
+            image_path = osp.join(
+                self.config.data_dir, "images", "train2014", file_name)
+            descriptions = [r['raw'] for r in ref['sentences']]
+            yield ref_id, {
+                "ref_id": ref_id,
+                "img_id": img_id,
+                "ann_id": ann_id,
+                "file_name": file_name,
+                "image_path": image_path,
+                "height": img['height'],
+                "width": img['width'],
+                "coco_url": img['coco_url'],
+                "sentences": descriptions,
+                "segmentation": [ann['segmentation']],
+                "bbox": [ann['bbox']],
+                "area": ann['area'],
+                "iscrowd": ann['iscrowd'],
+                "category_id": ann['category_id'],
+            }