Delete cifar10_lt.py

cifar10_lt.py

@@ -1,221 +0,0 @@
-# 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
-    ):
-        super().__init__(version=datasets.Version("1.0.1"), **kwargs)
-        self.imb_type = 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"""
-
-    BUILDER_CONFIGS = [
-        Cifar10LTConfig(
-            name="r-10", description="CIFAR-10-LT-r-10", imb_type="exp", imb_factor=1 / 10
-        ),
-        Cifar10LTConfig(
-            name="r-20", description="CIFAR-10-LT-r-20", imb_type="exp", imb_factor=1 / 20
-        ),
-        Cifar10LTConfig(
-            name="r-50", description="CIFAR-10-LT-r-50", imb_type="exp", imb_factor=1 / 50
-        ),
-        Cifar10LTConfig(
-            name="r-100", description="CIFAR-10-LT-r-100", imb_type="exp", imb_factor=1 / 100
-        ),
-        Cifar10LTConfig(
-            name="r-200", description="CIFAR-10-LT-r-200", imb_type="exp", imb_factor=1 / 200
-        ),
-    ]
-
-    def _info(self) -> datasets.DatasetInfo:
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=datasets.Features(
-                {
-                    "img": datasets.Image(),  # stores HWC uint8
-                    "label": datasets.ClassLabel(names=_NAMES),
-                }
-            ),
-            supervised_keys=None,
-            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_dir = dl_manager.download_and_extract(_DATA_URL)
-
-        # Inside the tar, CIFAR lives under "cifar-10-batches-py"
-        data_root = os.path.join(extracted_dir, "cifar-10-batches-py")
-
-        # 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; we'll cast to set later for speed.
-                    "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
-        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)))
-                img_num_per_cls.append(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(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):
-        """
-        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