Create cifar-10-lt.py

cifar-10-lt.py

@@ -0,0 +1,231 @@
+# coding=utf-8
+# Copyright 2020 …
+# (license header unchanged)
+
+"""CIFAR-10-LT Dataset (HF Datasets 3.6 compatible)"""
+
+import os
+import pickle
+from typing import Dict, Iterator, List, Tuple
+
+import numpy as np
+import datasets
+
+_CITATION = """\
+@TECHREPORT{Krizhevsky09learningmultiple,
+    author = {Alex Krizhevsky},
+    title = {Learning multiple layers of features from tiny images},
+    institution = {},
+    year = {2009}
+}
+"""
+
+_DESCRIPTION = """\
+The CIFAR-10-LT imbalanced dataset is comprised of under 60,000 color images (32×32),
+across 10 classes. The test set has 10,000 images (1,000 per class).
+The training set is imbalanced with exponential factors of 10, 20, 50, 100, or 200.
+"""
+
+_DATA_URL = "https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz"
+
+_NAMES = [
+    "airplane",
+    "automobile",
+    "bird",
+    "cat",
+    "deer",
+    "dog",
+    "frog",
+    "horse",
+    "ship",
+    "truck",
+]
+
+
+class Cifar10LTConfig(datasets.BuilderConfig):
+    """BuilderConfig for CIFAR-10-LT."""
+
+    def __init__(
+        self,
+        imb_type: str,
+        imb_factor: float,
+        rand_number: int = 0,
+        cls_num: int = 10,
+        **kwargs
+    ):
+        # Keep version here so each config shares it
+        super().__init__(version=datasets.Version("1.0.1"), **kwargs)
+        self.imb_type = str(imb_type)
+        self.imb_factor = float(imb_factor)
+        self.rand_number = int(rand_number)
+        self.cls_num = int(cls_num)
+
+
+class Cifar10(datasets.GeneratorBasedBuilder):
+    """CIFAR-10-LT Dataset"""
+
+    DEFAULT_CONFIG_NAME = "r-100"
+
+    BUILDER_CONFIGS = [
+        Cifar10LTConfig(
+            name="r-10", description="CIFAR-10-LT r=10 (exp)", imb_type="exp", imb_factor=1 / 10
+        ),
+        Cifar10LTConfig(
+            name="r-20", description="CIFAR-10-LT r=20 (exp)", imb_type="exp", imb_factor=1 / 20
+        ),
+        Cifar10LTConfig(
+            name="r-50", description="CIFAR-10-LT r=50 (exp)", imb_type="exp", imb_factor=1 / 50
+        ),
+        Cifar10LTConfig(
+            name="r-100", description="CIFAR-10-LT r=100 (exp)", imb_type="exp", imb_factor=1 / 100
+        ),
+        Cifar10LTConfig(
+            name="r-200", description="CIFAR-10-LT r=200 (exp)", imb_type="exp", imb_factor=1 / 200
+        ),
+    ]
+
+    def _info(self) -> datasets.DatasetInfo:
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=datasets.Features(
+                {
+                    "img": datasets.Image(),  # uint8 HWC
+                    "label": datasets.ClassLabel(names=_NAMES),
+                }
+            ),
+            supervised_keys=("img", "label"),
+            homepage="https://www.cs.toronto.edu/~kriz/cifar.html",
+            citation=_CITATION,
+        )
+
+    # ---------- split planning / index generation ----------
+
+    def _split_generators(self, dl_manager: datasets.DownloadManager):
+        # Extract once to a directory; avoids relying on iter_archive inside generators.
+        extracted_path = dl_manager.download_and_extract(_DATA_URL)
+
+        # Handle both cases:
+        #  - returned path == ".../cifar-10-batches-py"
+        #  - returned path is parent, so we need to append "cifar-10-batches-py"
+        if os.path.isdir(os.path.join(extracted_path, "cifar-10-batches-py")):
+            data_root = os.path.join(extracted_path, "cifar-10-batches-py")
+        else:
+            # If the extractor already returned the inner dir
+            data_root = extracted_path
+
+        # Precompute LT indices for the train split deterministically
+        train_labels = self._collect_labels_from_dir(data_root, split="train")
+        img_num_per_cls = self._get_img_num_per_cls(len(train_labels))
+        rs = np.random.RandomState(self.config.rand_number)
+        train_indices, _ = self._gen_imbalanced_data(img_num_per_cls, train_labels, rs)
+
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs={
+                    "data_root": data_root,
+                    "split": "train",
+                    # Pass a JSON-serializable type; convert to set later for O(1) test.
+                    "selected_indices": sorted(int(i) for i in train_indices),
+                },
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.TEST,
+                gen_kwargs={"data_root": data_root, "split": "test", "selected_indices": None},
+            ),
+        ]
+
+    @staticmethod
+    def _batch_files_in_dir(data_root: str, split: str) -> List[str]:
+        if split == "train":
+            batches = ["data_batch_1", "data_batch_2", "data_batch_3", "data_batch_4", "data_batch_5"]
+        elif split == "test":
+            batches = ["test_batch"]
+        else:
+            raise ValueError(f"Unknown split: {split}")
+        return [os.path.join(data_root, b) for b in batches]
+
+    def _collect_labels_from_dir(self, data_root: str, split: str) -> List[int]:
+        """Read labels across all CIFAR batches for a split (from extracted files)."""
+        labels_all: List[int] = []
+        for path in self._batch_files_in_dir(data_root, split):
+            with open(path, "rb") as fo:
+                d = pickle.load(fo, encoding="latin1")
+            # Handle both bytes and str keys robustly
+            labels = d.get("labels", d.get(b"labels"))
+            if labels is None:
+                raise KeyError(f"'labels' not found in {path}")
+            labels_all.extend(labels)
+        return labels_all
+
+    def _get_img_num_per_cls(self, data_length: int) -> List[int]:
+        """Number of images per class given imbalance ratio and total length."""
+        img_max = data_length / self.config.cls_num  # e.g., 50000 / 10 = 5000
+        img_num_per_cls: List[int] = []
+        if self.config.imb_type == "exp":
+            for cls_idx in range(self.config.cls_num):
+                num = img_max * (self.config.imb_factor ** (cls_idx / (self.config.cls_num - 1.0)))
+                # Ensure at least one sample per class
+                img_num_per_cls.append(max(1, int(num)))
+        elif self.config.imb_type == "step":
+            for _ in range(self.config.cls_num // 2):
+                img_num_per_cls.append(int(img_max))
+            for _ in range(self.config.cls_num // 2):
+                img_num_per_cls.append(max(1, int(img_max * self.config.imb_factor)))
+        else:
+            img_num_per_cls.extend([int(img_max)] * self.config.cls_num)
+        return img_num_per_cls
+
+    def _gen_imbalanced_data(
+        self, img_num_per_cls: List[int], targets: List[int], rs: np.random.RandomState
+    ) -> Tuple[List[int], Dict[int, int]]:
+        """Return selected indices (global over concatenated train set) and per-class counts."""
+        new_indices: List[int] = []
+        targets_np = np.array(targets, dtype=np.int64)
+        classes = np.unique(targets_np)
+        num_per_cls_dict: Dict[int, int] = {}
+        for the_class, the_img_num in zip(classes, img_num_per_cls):
+            num_per_cls_dict[int(the_class)] = int(the_img_num)
+            idx = np.where(targets_np == the_class)[0]
+            rs.shuffle(idx)
+            selec_idx = idx[:the_img_num]
+            new_indices.extend(selec_idx.tolist())
+        return new_indices, num_per_cls_dict
+
+    # ---------- example generation ----------
+
+    def _generate_examples(self, data_root: str, split: str, selected_indices=None) -> Iterator[Tuple[str, dict]]:
+        """
+        Yields (key, example) pairs.
+        For train: only indices in `selected_indices` are yielded (LT subset).
+        For test: all examples are yielded.
+        """
+        batch_paths = self._batch_files_in_dir(data_root, split)
+
+        # For quick membership checks
+        selected_set = set(selected_indices) if selected_indices is not None else None
+
+        global_idx = 0  # global index across all batches in CIFAR order
+
+        for path in batch_paths:
+            with open(path, "rb") as fo:
+                d = pickle.load(fo, encoding="latin1")
+
+            labels = d.get("labels", d.get(b"labels"))
+            data = d.get("data", d.get(b"data"))
+            if labels is None or data is None:
+                raise KeyError(f"Missing 'labels' or 'data' in {path}")
+
+            # (N, 3072) CHW packed uint8
+            num_in_batch = len(labels)
+            for i in range(num_in_batch):
+                # Train split: only yield if selected
+                if selected_set is not None and (global_idx not in selected_set):
+                    global_idx += 1
+                    continue
+
+                # reshape to HWC uint8
+                img = np.reshape(data[i], (3, 32, 32)).transpose(1, 2, 0)
+
+                yield f"{os.path.basename(path)}_{i}", {"img": img, "label": int(labels[i])}
+                global_idx += 1