Datasets:
metashift

	# 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
	from datasets.tasks import ImageClassification


	_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,
	task_templates=[ImageClassification(image_column="image", label_column="label")],
	)

	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

	@staticmethod
	def _parse_node_str(node_str):
	tag = node_str.split("(")[-1][:-1]
	subject_str = node_str.split("(")[0].strip()
	return subject_str, tag

	@staticmethod
	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

	@staticmethod
	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"],
	},
	),
	]

	@staticmethod
	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