Datasets:
Sub-tasks:
multi-label-image-classification
Languages:
English
Size:
10K<n<100K
ArXiv:
Tags:
domain-generalization
License:
| # Copyright 2022 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. | |
| # _preprocess_groups(), _parse_node_str(), _load_candidate_subsets() adapted from here : | |
| # https://github.com/Weixin-Liang/MetaShift/blob/main/dataset/generate_full_MetaShift.py | |
| # MIT License | |
| # Copyright (c) 2021 Weixin-Liang | |
| # Permission is hereby granted, free of charge, to any person obtaining a copy | |
| # of this software and associated documentation files (the "Software"), to deal | |
| # in the Software without restriction, including without limitation the rights | |
| # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
| # copies of the Software, and to permit persons to whom the Software is | |
| # furnished to do so, subject to the following conditions: | |
| # The above copyright notice and this permission notice shall be included in all | |
| # copies or substantial portions of the Software. | |
| # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
| # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
| # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
| # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
| # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
| # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | |
| # SOFTWARE. | |
| """MetaShift Dataset.""" | |
| import json | |
| import os | |
| import pickle | |
| from collections import Counter, defaultdict | |
| import datasets | |
| _CITATION = """\ | |
| @InProceedings{liang2022metashift, | |
| title={MetaShift: A Dataset of Datasets for Evaluating Contextual Distribution Shifts and Training Conflicts}, | |
| author={Weixin Liang and James Zou}, | |
| booktitle={International Conference on Learning Representations}, | |
| year={2022}, | |
| url={https://openreview.net/forum?id=MTex8qKavoS} | |
| } | |
| """ | |
| _DESCRIPTION = """\ | |
| The MetaShift is a dataset of datasets for evaluating distribution shifts and training conflicts. | |
| The MetaShift dataset is a collection of 12,868 sets of natural images across 410 classes. | |
| It was created for understanding the performance of a machine learning model across diverse data distributions. | |
| """ | |
| _HOMEPAGE = "https://metashift.readthedocs.io/" | |
| _LICENSE = "Creative Commons Attribution 4.0 International License" | |
| _URLS = { | |
| "image_files": "https://nlp.stanford.edu/data/gqa/images.zip", | |
| "scene_graph_annotations": "https://nlp.stanford.edu/data/gqa/sceneGraphs.zip", | |
| } | |
| _METADATA_URLS = { | |
| "full_candidate_subsets": "https://github.com/Weixin-Liang/MetaShift/raw/main/dataset/meta_data/full-candidate-subsets.pkl", | |
| } | |
| _ATTRIBUTES_URLS = { | |
| "attributes_candidate_subsets": "https://github.com/Weixin-Liang/MetaShift/raw/main/dataset/attributes_MetaShift/attributes-candidate-subsets.pkl", | |
| } | |
| # See https://github.com/Weixin-Liang/MetaShift/blob/main/dataset/meta_data/class_hierarchy.json | |
| # for the full object vocabulary and its hierarchy. | |
| # Since the total number of all subsets is very large, all of the following scripts only generate a subset of MetaShift. | |
| _CLASSES = [ | |
| "cat", | |
| "dog", | |
| "bus", | |
| "truck", | |
| "elephant", | |
| "horse", | |
| ] | |
| _ATTRIBUTES = [ | |
| "cat(orange)", | |
| "cat(white)", | |
| "dog(sitting)", | |
| "dog(jumping)", | |
| ] | |
| class MetashiftConfig(datasets.BuilderConfig): | |
| """BuilderConfig for MetaShift.""" | |
| def __init__( | |
| self, | |
| selected_classes=None, | |
| attributes_dataset=False, | |
| attributes=None, | |
| with_image_metadata=False, | |
| image_subset_size_threshold=25, | |
| min_local_groups=5, | |
| **kwargs, | |
| ): | |
| """BuilderConfig for MetaShift. | |
| Args: | |
| selected_classes: `list[string]`, optional, list of the classes to generate the MetaShift dataset for. | |
| If `None`, the list is equal to `['cat', 'dog', 'bus', 'truck', 'elephant', 'horse']`. | |
| attributes_dataset: `bool`, default `False`, if `True`, the script generates the MetaShift-Attributes dataset. | |
| attributes: `list[string]`, optional, list of attributes classes included in the Attributes dataset. | |
| If `None` and `attributes_dataset` is `True`, it's equal to `["cat(orange)", "cat(white)", "dog(sitting)", "dog(jumping)"]`. | |
| with_image_metadata: `bool`, default `False`, whether to include image metadata. | |
| If set to `True`, this will give additional metadata about each image. | |
| image_subset_size_threshold: `int`, default `25`, the number of images required to be considered a subset. | |
| If the number of images is less than this threshold, the subset is ignored. | |
| min_local_groups: `int`, default `5`, the minimum number of local groups required to be considered an object class. | |
| **kwargs: keyword arguments forwarded to super. | |
| """ | |
| super(MetashiftConfig, self).__init__(**kwargs) | |
| self.selected_classes = _CLASSES if selected_classes is None else selected_classes | |
| self.attributes_dataset = attributes_dataset | |
| if attributes_dataset: | |
| self.attributes = _ATTRIBUTES if attributes is None else attributes | |
| self.with_image_metadata = with_image_metadata | |
| self.IMAGE_SUBSET_SIZE_THRESHOLD = image_subset_size_threshold | |
| self.MIN_LOCAL_GROUPS = min_local_groups | |
| class Metashift(datasets.GeneratorBasedBuilder): | |
| BUILDER_CONFIGS = [ | |
| MetashiftConfig(name="metashift", version=datasets.Version("1.0.0")), | |
| ] | |
| BUILDER_CONFIG_CLASS = MetashiftConfig | |
| def _info(self): | |
| return datasets.DatasetInfo( | |
| description=_DESCRIPTION, | |
| features=datasets.Features(self._get_feature_types()), | |
| supervised_keys=("image", "label"), | |
| homepage=_HOMEPAGE, | |
| license=_LICENSE, | |
| citation=_CITATION, | |
| ) | |
| def _get_feature_types(self): | |
| features = { | |
| "image_id": datasets.Value("string"), | |
| "image": datasets.Image(), | |
| } | |
| if self.config.attributes_dataset: | |
| features.update({"label": datasets.ClassLabel(names=self.config.attributes)}) | |
| else: | |
| features.update( | |
| { | |
| "label": datasets.ClassLabel(names=self.config.selected_classes), | |
| "context": datasets.Value("string"), | |
| } | |
| ) | |
| if self.config.with_image_metadata: | |
| features.update( | |
| { | |
| "width": datasets.Value("int64"), | |
| "height": datasets.Value("int64"), | |
| "location": datasets.Value("string"), | |
| "weather": datasets.Value("string"), | |
| "objects": datasets.Sequence( | |
| { | |
| "object_id": datasets.Value("string"), | |
| "name": datasets.Value("string"), | |
| "x": datasets.Value("int64"), | |
| "y": datasets.Value("int64"), | |
| "w": datasets.Value("int64"), | |
| "h": datasets.Value("int64"), | |
| "attributes": datasets.Sequence(datasets.Value("string")), | |
| "relations": datasets.Sequence( | |
| { | |
| "name": datasets.Value("string"), | |
| "object": datasets.Value("string"), | |
| } | |
| ), | |
| } | |
| ), | |
| } | |
| ) | |
| return features | |
| def _parse_node_str(node_str): | |
| tag = node_str.split("(")[-1][:-1] | |
| subject_str = node_str.split("(")[0].strip() | |
| return subject_str, tag | |
| def _load_candidate_subsets(pkl_save_path): | |
| with open(pkl_save_path, "rb") as pkl_f: | |
| load_data = pickle.load(pkl_f) | |
| return load_data | |
| def _preprocess_groups(self, pkl_save_path, output_files_flag=False, subject_classes=_CLASSES): | |
| IMAGE_SUBSET_SIZE_THRESHOLD = self.config.IMAGE_SUBSET_SIZE_THRESHOLD | |
| trainsg_dupes = set() | |
| ################################## | |
| # Load cache data | |
| # Global data dict | |
| # Consult back to this dict for concrete image IDs. | |
| ################################## | |
| node_name_to_img_id = self._load_candidate_subsets(pkl_save_path) | |
| ################################## | |
| # Build a default counter first | |
| # Data Iteration | |
| ################################## | |
| group_name_counter = Counter() | |
| for node_name in node_name_to_img_id.keys(): | |
| ################################## | |
| # Apply a threshold: e.g., 100 | |
| ################################## | |
| imageID_set = node_name_to_img_id[node_name] | |
| imageID_set = imageID_set - trainsg_dupes | |
| node_name_to_img_id[node_name] = imageID_set | |
| if len(imageID_set) >= IMAGE_SUBSET_SIZE_THRESHOLD: | |
| group_name_counter[node_name] = len(imageID_set) | |
| else: | |
| pass | |
| most_common_list = group_name_counter.most_common() | |
| most_common_list = [(x, count) for x, count in group_name_counter.items()] | |
| ################################## | |
| # Build a subject dict | |
| ################################## | |
| subject_group_summary_dict = defaultdict(Counter) | |
| for node_name, imageID_set_len in most_common_list: | |
| subject_str, tag = self._parse_node_str(node_name) | |
| ################################## | |
| # TMP: inspect certain class | |
| ################################## | |
| if subject_str not in subject_classes: | |
| continue | |
| subject_group_summary_dict[subject_str][node_name] = imageID_set_len | |
| ################################## | |
| # Get the subject dict stats | |
| ################################## | |
| subject_group_summary_list = sorted( | |
| subject_group_summary_dict.items(), key=lambda x: sum(x[1].values()), reverse=True | |
| ) | |
| new_subject_group_summary_list = list() | |
| subjects_to_all_set = defaultdict(set) | |
| ################################## | |
| # Subject filtering for dataset generation | |
| ################################## | |
| for subject_str, subject_data in subject_group_summary_list: | |
| ################################## | |
| # Discard an object class if it has too few local groups | |
| ################################## | |
| if len(subject_data) <= self.config.MIN_LOCAL_GROUPS: | |
| # if len(subject_data) <= 10: | |
| continue | |
| else: | |
| new_subject_group_summary_list.append((subject_str, subject_data)) | |
| ################################## | |
| # Iterate all the subsets of the given subject | |
| ################################## | |
| for node_name in subject_data: | |
| subjects_to_all_set[node_name].update(node_name_to_img_id[node_name]) | |
| return subjects_to_all_set | |
| def _load_scene_graph(json_path): | |
| with open(json_path, "r", encoding="utf-8") as f: | |
| scene_graph = json.load(f) | |
| return scene_graph | |
| def _split_generators(self, dl_manager): | |
| data_path = dl_manager.download_and_extract(_URLS) | |
| metadata_path = None | |
| subjects_to_all_set = None | |
| attributes_path = None | |
| if not self.config.attributes_dataset: | |
| metadata_path = dl_manager.download_and_extract(_METADATA_URLS) | |
| subjects_to_all_set = self._preprocess_groups( | |
| metadata_path["full_candidate_subsets"], subject_classes=self.config.selected_classes | |
| ) | |
| else: | |
| attributes_path = dl_manager.download_and_extract(_ATTRIBUTES_URLS) | |
| return [ | |
| datasets.SplitGenerator( | |
| name=datasets.Split.TRAIN, | |
| gen_kwargs={ | |
| "images_path": os.path.join(data_path["image_files"], "images"), | |
| "subjects_to_all_set": subjects_to_all_set, | |
| "attributes_path": attributes_path, | |
| "image_metadata_path": data_path["scene_graph_annotations"], | |
| }, | |
| ), | |
| ] | |
| def _get_processed_image_metadata(image_id, scene_graph): | |
| image_metadata = scene_graph[image_id] | |
| objects = image_metadata["objects"] | |
| if isinstance(objects, list): | |
| return image_metadata | |
| processed_objects = [] | |
| for object_id, object_details in objects.items(): | |
| object_details["object_id"] = object_id | |
| processed_objects.append(object_details) | |
| image_metadata["objects"] = processed_objects | |
| if "location" not in image_metadata: | |
| image_metadata["location"] = None | |
| if "weather" not in image_metadata: | |
| image_metadata["weather"] = None | |
| return image_metadata | |
| def _generate_examples(self, images_path, subjects_to_all_set, attributes_path, image_metadata_path): | |
| idx = 0 | |
| if self.config.with_image_metadata: | |
| train_scene_graph = os.path.join(image_metadata_path, "train_sceneGraphs.json") | |
| test_scene_graph = os.path.join(image_metadata_path, "val_sceneGraphs.json") | |
| scene_graph = self._load_scene_graph(train_scene_graph) | |
| scene_graph.update(self._load_scene_graph(test_scene_graph)) | |
| if not self.config.attributes_dataset: | |
| for subset in subjects_to_all_set: | |
| class_name, context = self._parse_node_str(subset) | |
| for image_id in subjects_to_all_set[subset]: | |
| image_filename = image_id + ".jpg" | |
| src_image_path = os.path.join(images_path, image_filename) | |
| features = { | |
| "image_id": image_id, | |
| "image": src_image_path, | |
| "label": class_name, | |
| "context": context, | |
| } | |
| if self.config.with_image_metadata: | |
| image_metadata = self._get_processed_image_metadata(image_id, scene_graph) | |
| features.update(image_metadata) | |
| yield idx, features | |
| idx += 1 | |
| else: | |
| attributes_candidate_subsets = self._load_candidate_subsets( | |
| attributes_path["attributes_candidate_subsets"] | |
| ) | |
| for attribute in self.config.attributes: | |
| image_IDs = attributes_candidate_subsets[attribute] | |
| for image_id in image_IDs: | |
| image_filename = image_id + ".jpg" | |
| src_image_path = os.path.join(images_path, image_filename) | |
| features = { | |
| "image_id": image_id, | |
| "image": src_image_path, | |
| "label": attribute, | |
| } | |
| if self.config.with_image_metadata: | |
| image_metadata = self._get_processed_image_metadata(image_id, scene_graph) | |
| features.update(image_metadata) | |
| yield idx, features | |
| idx += 1 | |