dataeval 0.86.9__py3-none-any.whl → 0.88.0__py3-none-any.whl

dataeval/utils/datasets/_antiuav.py

@@ -1,189 +0,0 @@
-from __future__ import annotations
-
-__all__ = []
-
-from pathlib import Path
-from typing import TYPE_CHECKING, Any, Literal, Sequence
-
-from defusedxml.ElementTree import parse
-from numpy.typing import NDArray
-
-from dataeval.utils.datasets._base import BaseODDataset, DataLocation
-from dataeval.utils.datasets._mixin import BaseDatasetNumpyMixin
-
-if TYPE_CHECKING:
-    from dataeval.typing import Transform
-
-
-class AntiUAVDetection(BaseODDataset[NDArray[Any], list[str], str], BaseDatasetNumpyMixin):
-    """
-    A UAV detection dataset focused on detecting UAVs in natural images against large variation in backgrounds.
-
-    The dataset comes from the paper
-    `Vision-based Anti-UAV Detection and Tracking <https://ieeexplore.ieee.org/document/9785379>`_
-    by Jie Zhao et. al. (2022).
-
-    The dataset is approximately 1.3 GB and can be found `here <https://github.com/wangdongdut/DUT-Anti-UAV>`_.
-    Images are collected against a variety of different backgrounds with a variety in the number and type of UAV.
-    Ground truth labels are provided for the train, validation and test set.
-    There are 35 different types of drones along with a variety in lighting conditions and weather conditions.
-
-    There are 10,000 images: 5200 images in the training set, 2200 images in the validation set,
-    and 2600 images in the test set.
-    The dataset only has a single UAV class with the focus being on identifying object location in the image.
-    Ground-truth bounding boxes are provided in (x0, y0, x1, y1) format.
-    The images come in a variety of sizes from 3744 x 5616 to 160 x 240.
-
-    Parameters
-    ----------
-    root : str or pathlib.Path
-        Root directory where the data should be downloaded to or
-        the ``antiuavdetection`` folder of the already downloaded data.
-    image_set: "train", "val", "test", or "base", default "train"
-        If "base", then the full dataset is selected (train, val and test).
-    transforms : Transform, Sequence[Transform] or None, default None
-        Transform(s) to apply to the data.
-    download : bool, default False
-        If True, downloads the dataset from the internet and puts it in root directory.
-        Class checks to see if data is already downloaded to ensure it does not create a duplicate download.
-    verbose : bool, default False
-        If True, outputs print statements.
-
-    Attributes
-    ----------
-    path : pathlib.Path
-        Location of the folder containing the data.
-    image_set : "train", "val", "test", or "base"
-        The selected image set from the dataset.
-    index2label : dict[int, str]
-        Dictionary which translates from class integers to the associated class strings.
-    label2index : dict[str, int]
-        Dictionary which translates from class strings to the associated class integers.
-    metadata : DatasetMetadata
-        Typed dictionary containing dataset metadata, such as `id` which returns the dataset class name.
-    transforms : Sequence[Transform]
-        The transforms to be applied to the data.
-    size : int
-        The size of the dataset.
-
-    Note
-    ----
-    Data License: `Apache 2.0 <https://www.apache.org/licenses/LICENSE-2.0.txt>`_
-    """
-
-    # Need to run the sha256 on the files and then store that
-    _resources = [
-        DataLocation(
-            url="https://drive.usercontent.google.com/download?id=1RVsSGPUKTdmoyoPTBTWwroyulLek1eTj&export=download&authuser=0&confirm=t&uuid=6bca4f94-a242-4bc2-9663-fb03cd94ef2c&at=APcmpox0--NroQ_3bqeTFaJxP7Pw%3A1746552902927",
-            filename="train.zip",
-            md5=False,
-            checksum="14f927290556df60e23cedfa80dffc10dc21e4a3b6843e150cfc49644376eece",
-        ),
-        DataLocation(
-            url="https://drive.usercontent.google.com/download?id=1333uEQfGuqTKslRkkeLSCxylh6AQ0X6n&export=download&authuser=0&confirm=t&uuid=c2ad2f01-aca8-4a85-96bb-b8ef6e40feea&at=APcmpozY-8bhk3nZSFaYbE8rq1Fi%3A1746551543297",
-            filename="val.zip",
-            md5=False,
-            checksum="238be0ceb3e7c5be6711ee3247e49df2750d52f91f54f5366c68bebac112ebf8",
-        ),
-        DataLocation(
-            url="https://drive.usercontent.google.com/download?id=1L1zeW1EMDLlXHClSDcCjl3rs_A6sVai0&export=download&authuser=0&confirm=t&uuid=5a1d7650-d8cd-4461-8354-7daf7292f06c&at=APcmpozLQC1CuP-n5_UX2JnP53Zo%3A1746551676177",
-            filename="test.zip",
-            md5=False,
-            checksum="a671989a01cff98c684aeb084e59b86f4152c50499d86152eb970a9fc7fb1cbe",
-        ),
-    ]
-
-    index2label: dict[int, str] = {
-        0: "unknown",
-        1: "UAV",
-    }
-
-    def __init__(
-        self,
-        root: str | Path,
-        image_set: Literal["train", "val", "test", "base"] = "train",
-        transforms: Transform[NDArray[Any]] | Sequence[Transform[NDArray[Any]]] | None = None,
-        download: bool = False,
-        verbose: bool = False,
-    ) -> None:
-        super().__init__(
-            root,
-            image_set,
-            transforms,
-            download,
-            verbose,
-        )
-
-    def _load_data(self) -> tuple[list[str], list[str], dict[str, list[Any]]]:
-        filepaths: list[str] = []
-        targets: list[str] = []
-        datum_metadata: dict[str, list[Any]] = {}
-
-        # If base, load all resources
-        if self.image_set == "base":
-            metadata_list: list[dict[str, Any]] = []
-
-            for resource in self._resources:
-                self._resource = resource
-                resource_filepaths, resource_targets, resource_metadata = super()._load_data()
-                filepaths.extend(resource_filepaths)
-                targets.extend(resource_targets)
-                metadata_list.append(resource_metadata)
-
-            # Combine metadata
-            for data_dict in metadata_list:
-                for key, val in data_dict.items():
-                    str_key = str(key)  # Ensure key is string
-                    if str_key not in datum_metadata:
-                        datum_metadata[str_key] = []
-                    datum_metadata[str_key].extend(val)
-
-        else:
-            # Grab only the desired data
-            for resource in self._resources:
-                if self.image_set in resource.filename:
-                    self._resource = resource
-                    resource_filepaths, resource_targets, resource_metadata = super()._load_data()
-                    filepaths.extend(resource_filepaths)
-                    targets.extend(resource_targets)
-                    datum_metadata.update(resource_metadata)
-
-        return filepaths, targets, datum_metadata
-
-    def _load_data_inner(self) -> tuple[list[str], list[str], dict[str, Any]]:
-        resource_name = self._resource.filename[:-4]
-        base_dir = self.path / resource_name
-        data_folder = sorted((base_dir / "img").glob("*.jpg"))
-        if not data_folder:
-            raise FileNotFoundError
-
-        file_data = {"image_id": [f"{resource_name}_{entry.name}" for entry in data_folder]}
-        data = [str(entry) for entry in data_folder]
-        annotations = sorted(str(entry) for entry in (base_dir / "xml").glob("*.xml"))
-
-        return data, annotations, file_data
-
-    def _read_annotations(self, annotation: str) -> tuple[list[list[float]], list[int], dict[str, Any]]:
-        """Function for extracting the info for the label and boxes"""
-        boxes: list[list[float]] = []
-        labels = []
-        root = parse(annotation).getroot()
-        if root is None:
-            raise ValueError(f"Unable to parse {annotation}")
-        additional_meta: dict[str, Any] = {
-            "image_width": int(root.findtext("size/width", default="-1")),
-            "image_height": int(root.findtext("size/height", default="-1")),
-            "image_depth": int(root.findtext("size/depth", default="-1")),
-        }
-        for obj in root.findall("object"):
-            labels.append(1 if obj.findtext("name", default="") == "UAV" else 0)
-            boxes.append(
-                [
-                    float(obj.findtext("bndbox/xmin", default="0")),
-                    float(obj.findtext("bndbox/ymin", default="0")),
-                    float(obj.findtext("bndbox/xmax", default="0")),
-                    float(obj.findtext("bndbox/ymax", default="0")),
-                ]
-            )
-
-        return boxes, labels, additional_meta

dataeval/utils/datasets/_base.py

@@ -1,266 +0,0 @@
-from __future__ import annotations
-
-__all__ = []
-
-from abc import abstractmethod
-from pathlib import Path
-from typing import TYPE_CHECKING, Any, Generic, Iterator, Literal, NamedTuple, Sequence, TypeVar, cast
-
-import numpy as np
-
-from dataeval.utils.datasets._fileio import _ensure_exists
-from dataeval.utils.datasets._mixin import BaseDatasetMixin
-from dataeval.utils.datasets._types import (
-    AnnotatedDataset,
-    DatasetMetadata,
-    ImageClassificationDataset,
-    ObjectDetectionDataset,
-    ObjectDetectionTarget,
-    SegmentationDataset,
-    SegmentationTarget,
-)
-
-if TYPE_CHECKING:
-    from dataeval.typing import Array, Transform
-
-    _TArray = TypeVar("_TArray", bound=Array)
-else:
-    _TArray = TypeVar("_TArray")
-
-_TTarget = TypeVar("_TTarget")
-_TRawTarget = TypeVar("_TRawTarget", Sequence[int], Sequence[str], Sequence[tuple[list[int], list[list[float]]]])
-_TAnnotation = TypeVar("_TAnnotation", int, str, tuple[list[int], list[list[float]]])
-
-
-class DataLocation(NamedTuple):
-    url: str
-    filename: str
-    md5: bool
-    checksum: str
-
-
-class BaseDataset(
-    AnnotatedDataset[tuple[_TArray, _TTarget, dict[str, Any]]], Generic[_TArray, _TTarget, _TRawTarget, _TAnnotation]
-):
-    """
-    Base class for internet downloaded datasets.
-    """
-
-    # Each subclass should override the attributes below.
-    # Each resource tuple must contain:
-    #    'url': str, the URL to download from
-    #    'filename': str, the name of the file once downloaded
-    #    'md5': boolean, True if it's the checksum value is md5
-    #    'checksum': str, the associated checksum for the downloaded file
-    _resources: list[DataLocation]
-    _resource_index: int = 0
-    index2label: dict[int, str]
-
-    def __init__(
-        self,
-        root: str | Path,
-        image_set: Literal["train", "val", "test", "operational", "base"] = "train",
-        transforms: Transform[_TArray] | Sequence[Transform[_TArray]] | None = None,
-        download: bool = False,
-        verbose: bool = False,
-    ) -> None:
-        self._root: Path = root.absolute() if isinstance(root, Path) else Path(root).absolute()
-        transforms = transforms if transforms is not None else []
-        self.transforms: Sequence[Transform[_TArray]] = transforms if isinstance(transforms, Sequence) else [transforms]
-        self.image_set = image_set
-        self._verbose = verbose
-
-        # Internal Attributes
-        self._download = download
-        self._filepaths: list[str]
-        self._targets: _TRawTarget
-        self._datum_metadata: dict[str, list[Any]]
-        self._resource: DataLocation = self._resources[self._resource_index]
-        self._label2index = {v: k for k, v in self.index2label.items()}
-
-        self.metadata: DatasetMetadata = DatasetMetadata(
-            id=self._unique_id(),
-            index2label=self.index2label,
-            split=self.image_set,
-        )
-
-        # Load the data
-        self.path: Path = self._get_dataset_dir()
-        self._filepaths, self._targets, self._datum_metadata = self._load_data()
-        self.size: int = len(self._filepaths)
-
-    def __str__(self) -> str:
-        nt = "\n    "
-        title = f"{self.__class__.__name__} Dataset"
-        sep = "-" * len(title)
-        attrs = [f"{k.capitalize()}: {v}" for k, v in self.__dict__.items() if not k.startswith("_")]
-        return f"{title}\n{sep}{nt}{nt.join(attrs)}"
-
-    @property
-    def label2index(self) -> dict[str, int]:
-        return self._label2index
-
-    def __iter__(self) -> Iterator[tuple[_TArray, _TTarget, dict[str, Any]]]:
-        for i in range(len(self)):
-            yield self[i]
-
-    def _get_dataset_dir(self) -> Path:
-        # Create a designated folder for this dataset (named after the class)
-        if self._root.stem.lower() == self.__class__.__name__.lower():
-            dataset_dir: Path = self._root
-        else:
-            dataset_dir: Path = self._root / self.__class__.__name__.lower()
-        if not dataset_dir.exists():
-            dataset_dir.mkdir(parents=True, exist_ok=True)
-        return dataset_dir
-
-    def _unique_id(self) -> str:
-        return f"{self.__class__.__name__}_{self.image_set}"
-
-    def _load_data(self) -> tuple[list[str], _TRawTarget, dict[str, Any]]:
-        """
-        Function to determine if data can be accessed or if it needs to be downloaded and/or extracted.
-        """
-        if self._verbose:
-            print(f"Determining if {self._resource.filename} needs to be downloaded.")
-
-        try:
-            result = self._load_data_inner()
-            if self._verbose:
-                print("No download needed, loaded data successfully.")
-        except FileNotFoundError:
-            _ensure_exists(*self._resource, self.path, self._root, self._download, self._verbose)
-            result = self._load_data_inner()
-        return result
-
-    @abstractmethod
-    def _load_data_inner(self) -> tuple[list[str], _TRawTarget, dict[str, Any]]: ...
-
-    def _transform(self, image: _TArray) -> _TArray:
-        """Function to transform the image prior to returning based on parameters passed in."""
-        for transform in self.transforms:
-            image = transform(image)
-        return image
-
-    def __len__(self) -> int:
-        return self.size
-
-
-class BaseICDataset(
-    BaseDataset[_TArray, _TArray, list[int], int],
-    BaseDatasetMixin[_TArray],
-    ImageClassificationDataset[_TArray],
-):
-    """
-    Base class for image classification datasets.
-    """
-
-    def __getitem__(self, index: int) -> tuple[_TArray, _TArray, dict[str, Any]]:
-        """
-        Args
-        ----
-        index : int
-            Value of the desired data point
-
-        Returns
-        -------
-        tuple[TArray, TArray, dict[str, Any]]
-            Image, target, datum_metadata - where target is one-hot encoding of class.
-        """
-        # Get the associated label and score
-        label = self._targets[index]
-        score = self._one_hot_encode(label)
-        # Get the image
-        img = self._read_file(self._filepaths[index])
-        img = self._transform(img)
-
-        img_metadata = {key: val[index] for key, val in self._datum_metadata.items()}
-
-        return img, score, img_metadata
-
-
-class BaseODDataset(
-    BaseDataset[_TArray, ObjectDetectionTarget[_TArray], _TRawTarget, _TAnnotation],
-    BaseDatasetMixin[_TArray],
-    ObjectDetectionDataset[_TArray],
-):
-    """
-    Base class for object detection datasets.
-    """
-
-    _bboxes_per_size: bool = False
-
-    def __getitem__(self, index: int) -> tuple[_TArray, ObjectDetectionTarget[_TArray], dict[str, Any]]:
-        """
-        Args
-        ----
-        index : int
-            Value of the desired data point
-
-        Returns
-        -------
-        tuple[TArray, ObjectDetectionTarget[TArray], dict[str, Any]]
-            Image, target, datum_metadata - target.boxes returns boxes in x0, y0, x1, y1 format
-        """
-        # Grab the bounding boxes and labels from the annotations
-        annotation = cast(_TAnnotation, self._targets[index])
-        boxes, labels, additional_metadata = self._read_annotations(annotation)
-        # Get the image
-        img = self._read_file(self._filepaths[index])
-        img_size = img.shape
-        img = self._transform(img)
-        # Adjust labels if necessary
-        if self._bboxes_per_size and boxes:
-            boxes = boxes * np.array([[img_size[1], img_size[2], img_size[1], img_size[2]]])
-        # Create the Object Detection Target
-        target = ObjectDetectionTarget(self._as_array(boxes), self._as_array(labels), self._one_hot_encode(labels))
-
-        img_metadata = {key: val[index] for key, val in self._datum_metadata.items()}
-        img_metadata = img_metadata | additional_metadata
-
-        return img, target, img_metadata
-
-    @abstractmethod
-    def _read_annotations(self, annotation: _TAnnotation) -> tuple[list[list[float]], list[int], dict[str, Any]]: ...
-
-
-class BaseSegDataset(
-    BaseDataset[_TArray, SegmentationTarget[_TArray], list[str], str],
-    BaseDatasetMixin[_TArray],
-    SegmentationDataset[_TArray],
-):
-    """
-    Base class for segmentation datasets.
-    """
-
-    _masks: Sequence[str]
-
-    def __getitem__(self, index: int) -> tuple[_TArray, SegmentationTarget[_TArray], dict[str, Any]]:
-        """
-        Args
-        ----
-        index : int
-            Value of the desired data point
-
-        Returns
-        -------
-        tuple[TArray, SegmentationTarget[TArray], dict[str, Any]]
-            Image, target, datum_metadata - target.mask returns the ground truth mask
-        """
-        # Grab the labels from the annotations
-        _, labels, additional_metadata = self._read_annotations(self._targets[index])
-        # Grab the ground truth masks
-        mask = self._read_file(self._masks[index])
-        # Get the image
-        img = self._read_file(self._filepaths[index])
-        img = self._transform(img)
-
-        target = SegmentationTarget(mask, self._as_array(labels), self._one_hot_encode(labels))
-
-        img_metadata = {key: val[index] for key, val in self._datum_metadata.items()}
-        img_metadata = img_metadata | additional_metadata
-
-        return img, target, img_metadata
-
-    @abstractmethod
-    def _read_annotations(self, annotation: str) -> tuple[list[list[float]], list[int], dict[str, Any]]: ...

dataeval/utils/datasets/_cifar10.py

@@ -1,201 +0,0 @@
-from __future__ import annotations
-
-__all__ = []
-
-from pathlib import Path
-from typing import TYPE_CHECKING, Any, Literal, Sequence, TypeVar
-
-import numpy as np
-from numpy.typing import NDArray
-
-from dataeval.utils.datasets._base import BaseICDataset, DataLocation
-from dataeval.utils.datasets._mixin import BaseDatasetNumpyMixin
-
-if TYPE_CHECKING:
-    from dataeval.typing import Transform
-
-CIFARClassStringMap = Literal["airplane", "automobile", "bird", "cat", "deer", "dog", "frog", "horse", "ship", "truck"]
-TCIFARClassMap = TypeVar("TCIFARClassMap", CIFARClassStringMap, int, list[CIFARClassStringMap], list[int])
-
-
-class CIFAR10(BaseICDataset[NDArray[Any]], BaseDatasetNumpyMixin):
-    """
-    `CIFAR10 <https://www.cs.toronto.edu/~kriz/cifar.html>`_ Dataset as NumPy arrays.
-
-    Parameters
-    ----------
-    root : str or pathlib.Path
-        Root directory where the data should be downloaded to or the ``cifar10`` folder of the already downloaded data.
-    image_set : "train", "test" or "base", default "train"
-        If "base", returns all of the data to allow the user to create their own splits.
-    transforms : Transform, Sequence[Transform] or None, default None
-        Transform(s) to apply to the data.
-    download : bool, default False
-        If True, downloads the dataset from the internet and puts it in root directory.
-        Class checks to see if data is already downloaded to ensure it does not create a duplicate download.
-    verbose : bool, default False
-        If True, outputs print statements.
-
-    Attributes
-    ----------
-    path : pathlib.Path
-        Location of the folder containing the data.
-    image_set : "train", "test" or "base"
-        The selected image set from the dataset.
-    transforms : Sequence[Transform]
-        The transforms to be applied to the data.
-    size : int
-        The size of the dataset.
-    index2label : dict[int, str]
-        Dictionary which translates from class integers to the associated class strings.
-    label2index : dict[str, int]
-        Dictionary which translates from class strings to the associated class integers.
-    metadata : DatasetMetadata
-        Typed dictionary containing dataset metadata, such as `id` which returns the dataset class name.
-    """
-
-    _resources = [
-        DataLocation(
-            url="https://www.cs.toronto.edu/~kriz/cifar-10-binary.tar.gz",
-            filename="cifar-10-binary.tar.gz",
-            md5=True,
-            checksum="c32a1d4ab5d03f1284b67883e8d87530",
-        ),
-    ]
-
-    index2label: dict[int, str] = {
-        0: "airplane",
-        1: "automobile",
-        2: "bird",
-        3: "cat",
-        4: "deer",
-        5: "dog",
-        6: "frog",
-        7: "horse",
-        8: "ship",
-        9: "truck",
-    }
-
-    def __init__(
-        self,
-        root: str | Path,
-        image_set: Literal["train", "test", "base"] = "train",
-        transforms: Transform[NDArray[Any]] | Sequence[Transform[NDArray[Any]]] | None = None,
-        download: bool = False,
-        verbose: bool = False,
-    ) -> None:
-        super().__init__(
-            root,
-            image_set,
-            transforms,
-            download,
-            verbose,
-        )
-
-    def _load_bin_data(self, data_folder: list[Path]) -> tuple[list[str], list[int], dict[str, Any]]:
-        batch_nums = np.zeros(60000, dtype=np.uint8)
-        all_labels = np.zeros(60000, dtype=np.uint8)
-        all_images = np.zeros((60000, 3, 32, 32), dtype=np.uint8)
-        # Process each batch file, skipping .meta and .html files
-        for batch_file in data_folder:
-            # Get batch parameters
-            batch_type = "test" if "test" in batch_file.stem else "train"
-            batch_num = 5 if batch_type == "test" else int(batch_file.stem.split("_")[-1]) - 1
-
-            # Load data
-            batch_images, batch_labels = self._unpack_batch_files(batch_file)
-
-            # Stack data
-            num_images = batch_images.shape[0]
-            batch_start = batch_num * num_images
-            all_images[batch_start : batch_start + num_images] = batch_images
-            all_labels[batch_start : batch_start + num_images] = batch_labels
-            batch_nums[batch_start : batch_start + num_images] = batch_num
-
-        # Save data
-        self._loaded_data = all_images
-        np.savez(self.path / "cifar10", images=self._loaded_data, labels=all_labels, batches=batch_nums)
-
-        # Select data
-        image_list = np.arange(all_labels.shape[0]).astype(str)
-        if self.image_set == "train":
-            return (
-                image_list[np.nonzero(batch_nums != 5)[0]].tolist(),
-                all_labels[batch_nums != 5].tolist(),
-                {"batch_num": batch_nums[batch_nums != 5].tolist()},
-            )
-        if self.image_set == "test":
-            return (
-                image_list[np.nonzero(batch_nums == 5)[0]].tolist(),
-                all_labels[batch_nums == 5].tolist(),
-                {"batch_num": batch_nums[batch_nums == 5].tolist()},
-            )
-        return image_list.tolist(), all_labels.tolist(), {"batch_num": batch_nums.tolist()}
-
-    def _load_data_inner(self) -> tuple[list[str], list[int], dict[str, Any]]:
-        """Function to load in the file paths for the data and labels and retrieve metadata"""
-        data_file = self.path / "cifar10.npz"
-        if not data_file.exists():
-            data_folder = sorted((self.path / "cifar-10-batches-bin").glob("*.bin"))
-            if not data_folder:
-                raise FileNotFoundError
-            return self._load_bin_data(data_folder)
-
-        # Load data
-        data = np.load(data_file)
-        self._loaded_data = data["images"]
-        all_labels = data["labels"]
-        batch_nums = data["batches"]
-
-        # Select data
-        image_list = np.arange(all_labels.shape[0]).astype(str)
-        if self.image_set == "train":
-            return (
-                image_list[np.nonzero(batch_nums != 5)[0]].tolist(),
-                all_labels[batch_nums != 5].tolist(),
-                {"batch_num": batch_nums[batch_nums != 5].tolist()},
-            )
-        if self.image_set == "test":
-            return (
-                image_list[np.nonzero(batch_nums == 5)[0]].tolist(),
-                all_labels[batch_nums == 5].tolist(),
-                {"batch_num": batch_nums[batch_nums == 5].tolist()},
-            )
-        return image_list.tolist(), all_labels.tolist(), {"batch_num": batch_nums.tolist()}
-
-    def _unpack_batch_files(self, file_path: Path) -> tuple[NDArray[np.uint8], NDArray[np.uint8]]:
-        # Load pickle data with latin1 encoding
-        with file_path.open("rb") as f:
-            buffer = np.frombuffer(f.read(), dtype=np.uint8)
-            # Each entry is 1 byte for label + 3072 bytes for image (3*32*32)
-            entry_size = 1 + 3072
-            num_entries = buffer.size // entry_size
-            # Extract labels (first byte of each entry)
-            labels = buffer[::entry_size]
-
-            # Extract image data and reshape to (N, 3, 32, 32)
-            images = np.zeros((num_entries, 3, 32, 32), dtype=np.uint8)
-            for i in range(num_entries):
-                # Skip the label byte and get image data for this entry
-                start_idx = i * entry_size + 1  # +1 to skip label
-                img_flat = buffer[start_idx : start_idx + 3072]
-
-                # The CIFAR format stores channels in blocks (all R, then all G, then all B)
-                # Each channel block is 1024 bytes (32x32)
-                red_channel = img_flat[0:1024].reshape(32, 32)
-                green_channel = img_flat[1024:2048].reshape(32, 32)
-                blue_channel = img_flat[2048:3072].reshape(32, 32)
-
-                # Stack the channels in the proper C×H×W format
-                images[i, 0] = red_channel  # Red channel
-                images[i, 1] = green_channel  # Green channel
-                images[i, 2] = blue_channel  # Blue channel
-        return images, labels
-
-    def _read_file(self, path: str) -> NDArray[Any]:
-        """
-        Function to grab the correct image from the loaded data.
-        Overwrite of the base `_read_file` because data is an all or nothing load.
-        """
-        index = int(path)
-        return self._loaded_data[index]