dataeval 0.85.0__py3-none-any.whl → 0.86.1__py3-none-any.whl

dataeval/utils/_mst.py

@@ -83,6 +83,4 @@ def compute_neighbors(
 
     nbrs = NearestNeighbors(n_neighbors=k + 1, algorithm=algorithm).fit(B)
     nns = nbrs.kneighbors(A)[1]
-    nns = nns[:, 1:].squeeze()
-
-    return nns
+    return nns[:, 1:].squeeze()

dataeval/utils/_plot.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 __all__ = []
 
 import contextlib
+import math
 from typing import Any
 
 import numpy as np
@@ -160,11 +161,9 @@ def histogram_plot(
     import matplotlib.pyplot as plt
 
     num_metrics = len(data_dict)
-    if num_metrics > 2:
-        rows = int(len(data_dict) / 3)
-        fig, axs = plt.subplots(rows, 3, figsize=(10, rows * 2.5))
-    else:
-        fig, axs = plt.subplots(1, num_metrics, figsize=(4 * num_metrics, 4))
+    rows = math.ceil(num_metrics / 3)
+    cols = min(num_metrics, 3)
+    fig, axs = plt.subplots(rows, 3, figsize=(cols * 3 + 1, rows * 3))
 
     for ax, metric in zip(
         axs.flat,
@@ -178,6 +177,10 @@ def histogram_plot(
         ax.set_ylabel(ylabel)
         ax.set_xlabel(xlabel)
 
+    for ax in axs.flat[num_metrics:]:
+        ax.axis("off")
+        ax.set_visible(False)
+
     fig.tight_layout()
     return fig
 
@@ -216,11 +219,9 @@ def channel_histogram_plot(
     label_kwargs = {"label": [f"Channel {i}" for i in range(max_channels)]}
 
     num_metrics = len(data_keys)
-    if num_metrics > 2:
-        rows = int(len(data_keys) / 3)
-        fig, axs = plt.subplots(rows, 3, figsize=(10, rows * 2.5))
-    else:
-        fig, axs = plt.subplots(1, num_metrics, figsize=(4 * num_metrics, 4))
+    rows = math.ceil(num_metrics / 3)
+    cols = min(num_metrics, 3)
+    fig, axs = plt.subplots(rows, 3, figsize=(cols * 3 + 1, rows * 3))
 
     for ax, metric in zip(
         axs.flat,
@@ -245,5 +246,9 @@ def channel_histogram_plot(
         ax.set_ylabel(ylabel)
         ax.set_xlabel(xlabel)
 
+    for ax in axs.flat[num_metrics:]:
+        ax.axis("off")
+        ax.set_visible(False)
+
     fig.tight_layout()
     return fig

dataeval/utils/data/_dataset.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 __all__ = []
 
-from typing import Any, Generic, Iterable, Literal, Sequence, TypeVar
+from typing import Any, Generic, Iterable, Literal, Sequence, SupportsFloat, SupportsInt, TypeVar, cast
 
 from dataeval.typing import (
     Array,
@@ -17,8 +17,8 @@ from dataeval.utils._array import as_numpy
 def _validate_data(
     datum_type: Literal["ic", "od"],
     images: Array | Sequence[Array],
-    labels: Sequence[int] | Sequence[Sequence[int]],
-    bboxes: Sequence[Sequence[Sequence[float]]] | None,
+    labels: Array | Sequence[int] | Sequence[Array] | Sequence[Sequence[int]],
+    bboxes: Array | Sequence[Array] | Sequence[Sequence[Array]] | Sequence[Sequence[Sequence[float]]] | None,
     metadata: Sequence[dict[str, Any]] | None,
 ) -> None:
     # Validate inputs
@@ -34,16 +34,21 @@ def _validate_data(
         raise ValueError(f"Number of metadata ({len(metadata)}) does not match number of images ({dataset_len}).")
 
     if datum_type == "ic":
-        if not isinstance(labels, Sequence) or not isinstance(labels[0], int):
+        if not isinstance(labels, (Sequence, Array)) or not isinstance(labels[0], (int, SupportsInt)):
             raise TypeError("Labels must be a sequence of integers for image classification.")
     elif datum_type == "od":
-        if not isinstance(labels, Sequence) or not isinstance(labels[0], Sequence) or not isinstance(labels[0][0], int):
+        if (
+            not isinstance(labels, (Sequence, Array))
+            or not isinstance(labels[0], (Sequence, Array))
+            or not isinstance(cast(Sequence[Any], labels[0])[0], (int, SupportsInt))
+        ):
             raise TypeError("Labels must be a sequence of sequences of integers for object detection.")
         if (
             bboxes is None
             or not isinstance(bboxes, (Sequence, Array))
             or not isinstance(bboxes[0], (Sequence, Array))
             or not isinstance(bboxes[0][0], (Sequence, Array))
+            or not isinstance(bboxes[0][0][0], (float, SupportsFloat))
             or not len(bboxes[0][0]) == 4
         ):
             raise TypeError("Boxes must be a sequence of sequences of (x0, y0, x1, y1) for object detection.")
@@ -52,11 +57,10 @@ def _validate_data(
 
 
 def _find_max(arr: ArrayLike) -> Any:
-    if isinstance(arr, (Iterable, Sequence, Array)):
+    if not isinstance(arr, (bytes, str)) and isinstance(arr, (Iterable, Sequence, Array)):
         if isinstance(arr[0], (Iterable, Sequence, Array)):
             return max([_find_max(x) for x in arr])  # type: ignore
-        else:
-            return max(arr)
+        return max(arr)
     return arr
 
 
@@ -92,12 +96,14 @@ class CustomImageClassificationDataset(BaseAnnotatedDataset[Sequence[int]], Imag
     def __init__(
         self,
         images: Array | Sequence[Array],
-        labels: Sequence[int],
+        labels: Array | Sequence[int],
         metadata: Sequence[dict[str, Any]] | None,
         classes: Sequence[str] | None,
         name: str | None = None,
     ) -> None:
-        super().__init__("ic", images, labels, metadata, classes)
+        super().__init__(
+            "ic", images, as_numpy(labels).tolist() if isinstance(labels, Array) else labels, metadata, classes
+        )
         if name is not None:
             self.__name__ = name
             self.__class__.__name__ = name
@@ -135,18 +141,24 @@ class CustomObjectDetectionDataset(BaseAnnotatedDataset[Sequence[Sequence[int]]]
     def __init__(
         self,
         images: Array | Sequence[Array],
-        labels: Sequence[Sequence[int]],
-        bboxes: Sequence[Sequence[Sequence[float]]],
+        labels: Array | Sequence[Array] | Sequence[Sequence[int]],
+        bboxes: Array | Sequence[Array] | Sequence[Sequence[Array]] | Sequence[Sequence[Sequence[float]]],
         metadata: Sequence[dict[str, Any]] | None,
         classes: Sequence[str] | None,
         name: str | None = None,
     ) -> None:
-        super().__init__("od", images, labels, metadata, classes)
+        super().__init__(
+            "od",
+            images,
+            [as_numpy(label).tolist() if isinstance(label, Array) else label for label in labels],
+            metadata,
+            classes,
+        )
         if name is not None:
             self.__name__ = name
             self.__class__.__name__ = name
             self.__class__.__qualname__ = name
-        self._bboxes = bboxes
+        self._bboxes = [[as_numpy(box).tolist() if isinstance(box, Array) else box for box in bbox] for bbox in bboxes]
 
     @property
     def metadata(self) -> DatasetMetadata:
@@ -162,7 +174,7 @@ class CustomObjectDetectionDataset(BaseAnnotatedDataset[Sequence[Sequence[int]]]
 
 def to_image_classification_dataset(
     images: Array | Sequence[Array],
-    labels: Sequence[int],
+    labels: Array | Sequence[int],
     metadata: Sequence[dict[str, Any]] | None,
     classes: Sequence[str] | None,
     name: str | None = None,
@@ -174,7 +186,7 @@ def to_image_classification_dataset(
     ----------
     images : Array | Sequence[Array]
         The images to use in the dataset.
-    labels : Sequence[int]
+    labels : Array | Sequence[int]
         The labels to use in the dataset.
     metadata : Sequence[dict[str, Any]] | None
         The metadata to use in the dataset.
@@ -191,8 +203,8 @@ def to_image_classification_dataset(
 
 def to_object_detection_dataset(
     images: Array | Sequence[Array],
-    labels: Sequence[Sequence[int]],
-    bboxes: Sequence[Sequence[Sequence[float]]],
+    labels: Array | Sequence[Array] | Sequence[Sequence[int]],
+    bboxes: Array | Sequence[Array] | Sequence[Sequence[Array]] | Sequence[Sequence[Sequence[float]]],
     metadata: Sequence[dict[str, Any]] | None,
     classes: Sequence[str] | None,
     name: str | None = None,
@@ -204,9 +216,9 @@ def to_object_detection_dataset(
     ----------
     images : Array | Sequence[Array]
         The images to use in the dataset.
-    labels : Sequence[Sequence[int]]
+    labels : Array | Sequence[Array] | Sequence[Sequence[int]]
         The labels to use in the dataset.
-    bboxes : Sequence[Sequence[Sequence[float]]]
+    bboxes : Array | Sequence[Array] | Sequence[Sequence[Array]] | Sequence[Sequence[Sequence[float]]]
         The bounding boxes (x0,y0,x1,y0) to use in the dataset.
     metadata : Sequence[dict[str, Any]] | None
         The metadata to use in the dataset.

dataeval/utils/data/metadata.py

@@ -228,58 +228,130 @@ def flatten(
 
     if return_dropped:
         return output, size, _sorted_drop_reasons(dropped)
+    if dropped:
+        dropped_items = "\n".join([f"    {k}: {v}" for k, v in _sorted_drop_reasons(dropped).items()])
+        warnings.warn(f"Metadata entries were dropped:\n{dropped_items}")
+    return output, size
+
+
+def _flatten_for_merge(
+    metadatum: Mapping[str, Any],
+    ignore_lists: bool,
+    fully_qualified: bool,
+    targets: int | None,
+) -> tuple[dict[str, list[Any]] | dict[str, Any], int, dict[str, list[str]]]:
+    flattened, image_repeats, dropped_inner = flatten(
+        metadatum, return_dropped=True, ignore_lists=ignore_lists, fully_qualified=fully_qualified
+    )
+    if targets is not None:
+        # check for mismatch in targets per image and force ignore_lists
+        if not ignore_lists and targets != image_repeats:
+            flattened, image_repeats, dropped_inner = flatten(
+                metadatum, return_dropped=True, ignore_lists=True, fully_qualified=fully_qualified
+            )
+        if targets != image_repeats:
+            flattened = {k: [v] * targets for k, v in flattened.items()}
+        image_repeats = targets
+    return flattened, image_repeats, dropped_inner
+
+
+def _merge(
+    dicts: list[Mapping[str, Any]],
+    ignore_lists: bool,
+    fully_qualified: bool,
+    targets_per_image: Sequence[int] | None,
+) -> tuple[dict[str, list[Any]], dict[str, set[DropReason]], NDArray[np.intp]]:
+    merged: dict[str, list[Any]] = {}
+    isect: set[str] = set()
+    union: set[str] = set()
+    image_repeats = np.zeros(len(dicts), dtype=np.int_)
+    dropped: dict[str, set[DropReason]] = {}
+    for i, d in enumerate(dicts):
+        targets = None if targets_per_image is None else targets_per_image[i]
+        flattened, image_repeats[i], dropped_inner = _flatten_for_merge(d, ignore_lists, fully_qualified, targets)
+        isect = isect.intersection(flattened.keys()) if isect else set(flattened.keys())
+        union.update(flattened.keys())
+        for k, v in dropped_inner.items():
+            dropped.setdefault(k, set()).update({DropReason(vv) for vv in v})
+        for k, v in flattened.items():
+            merged.setdefault(k, []).extend(flattened[k]) if isinstance(v, list) else merged.setdefault(k, []).append(v)
+
+    for k in union - isect:
+        dropped.setdefault(k, set()).add(DropReason.INCONSISTENT_KEY)
+
+    if image_repeats.sum() == image_repeats.size:
+        image_indices = np.arange(image_repeats.size)
     else:
-        if dropped:
-            dropped_items = "\n".join([f"    {k}: {v}" for k, v in _sorted_drop_reasons(dropped).items()])
-            warnings.warn(f"Metadata entries were dropped:\n{dropped_items}")
-        return output, size
+        image_ids = np.arange(image_repeats.size)
+        image_data = np.concatenate(
+            [np.repeat(image_ids[i], image_repeats[i]) for i in range(image_ids.size)], dtype=np.int_
+        )
+        _, image_unsorted = np.unique(image_data, return_inverse=True)
+        image_indices = np.sort(image_unsorted)
 
+    merged = {k: _simplify_type(v) for k, v in merged.items() if k in isect}
+    return merged, dropped, image_indices
 
-def _is_metadata_dict_of_dicts(metadata: Mapping) -> bool:
-    """EXPERIMENTAL: Attempt to detect if metadata is a dict of dicts"""
-    # single dict
-    if len(metadata) < 2:
-        return False
 
-    # dict of non dicts
-    keys = list(metadata)
-    if not isinstance(metadata[keys[0]], Mapping):
-        return False
+@overload
+def merge(
+    metadata: Iterable[Mapping[str, Any]],
+    *,
+    return_dropped: Literal[True],
+    return_numpy: Literal[False] = False,
+    ignore_lists: bool = False,
+    fully_qualified: bool = False,
+    targets_per_image: Sequence[int] | None = None,
+    image_index_key: str = "_image_index",
+) -> tuple[dict[str, list[Any]], dict[str, list[str]]]: ...
+
 
-    # dict of dicts with matching keys
-    return set(metadata[keys[0]]) == set(metadata[keys[1]])
+@overload
+def merge(
+    metadata: Iterable[Mapping[str, Any]],
+    *,
+    return_dropped: Literal[False] = False,
+    return_numpy: Literal[False] = False,
+    ignore_lists: bool = False,
+    fully_qualified: bool = False,
+    targets_per_image: Sequence[int] | None = None,
+    image_index_key: str = "_image_index",
+) -> dict[str, list[Any]]: ...
 
 
 @overload
 def merge(
     metadata: Iterable[Mapping[str, Any]],
+    *,
     return_dropped: Literal[True],
+    return_numpy: Literal[True],
     ignore_lists: bool = False,
     fully_qualified: bool = False,
-    return_numpy: bool = False,
     targets_per_image: Sequence[int] | None = None,
     image_index_key: str = "_image_index",
-) -> tuple[dict[str, list[Any]] | dict[str, NDArray[Any]], dict[str, list[str]]]: ...
+) -> tuple[dict[str, NDArray[Any]], dict[str, list[str]]]: ...
 
 
 @overload
 def merge(
     metadata: Iterable[Mapping[str, Any]],
+    *,
     return_dropped: Literal[False] = False,
+    return_numpy: Literal[True],
     ignore_lists: bool = False,
     fully_qualified: bool = False,
-    return_numpy: bool = False,
     targets_per_image: Sequence[int] | None = None,
     image_index_key: str = "_image_index",
-) -> dict[str, list[Any]] | dict[str, NDArray[Any]]: ...
+) -> dict[str, NDArray[Any]]: ...
 
 
 def merge(
     metadata: Iterable[Mapping[str, Any]],
+    *,
     return_dropped: bool = False,
+    return_numpy: bool = False,
     ignore_lists: bool = False,
     fully_qualified: bool = False,
-    return_numpy: bool = False,
     targets_per_image: Sequence[int] | None = None,
     image_index_key: str = "_image_index",
 ):
@@ -298,12 +370,12 @@ def merge(
         Iterable collection of metadata dictionaries to flatten and merge
     return_dropped: bool, default False
         Option to return a dictionary of dropped keys and the reason(s) for dropping
+    return_numpy : bool, default False
+        Option to return results as lists or NumPy arrays
     ignore_lists : bool, default False
         Option to skip expanding lists within metadata
     fully_qualified : bool, default False
         Option to return dictionary keys full qualified instead of minimized
-    return_numpy : bool, default False
-        Option to return results as lists or NumPy arrays
     targets_per_image : Sequence[int] or None, default None
         Number of targets for each image metadata entry
     image_index_key : str, default "_image_index"
@@ -330,74 +402,24 @@ def merge(
     >>> dropped_keys
     {'target_c': ['inconsistent_key']}
     """
-    merged: dict[str, list[Any]] = {}
-    isect: set[str] = set()
-    union: set[str] = set()
-    keys: list[str] | None = None
-    dicts: list[Mapping[str, Any]]
-
-    # EXPERIMENTAL
-    if isinstance(metadata, Mapping) and _is_metadata_dict_of_dicts(metadata):
-        warnings.warn("Experimental processing for dict of dicts.")
-        keys = [str(k) for k in metadata]
-        dicts = list(metadata.values())
-        ignore_lists = True
-    else:
-        dicts = list(metadata)
+
+    dicts: list[Mapping[str, Any]] = list(metadata)
 
     if targets_per_image is not None and len(dicts) != len(targets_per_image):
         raise ValueError("Number of targets per image must be equal to number of metadata entries.")
 
-    image_repeats = np.zeros(len(dicts), dtype=np.int_)
-    dropped: dict[str, set[DropReason]] = {}
-    for i, d in enumerate(dicts):
-        flattened, image_repeats[i], dropped_inner = flatten(
-            d, return_dropped=True, ignore_lists=ignore_lists, fully_qualified=fully_qualified
-        )
-        if targets_per_image is not None:
-            # check for mismatch in targets per image and force ignore_lists
-            if not ignore_lists and targets_per_image[i] != image_repeats[i]:
-                flattened, image_repeats[i], dropped_inner = flatten(
-                    d, return_dropped=True, ignore_lists=True, fully_qualified=fully_qualified
-                )
-            if targets_per_image[i] != image_repeats[i]:
-                flattened = {k: [v] * targets_per_image[i] for k, v in flattened.items()}
-            image_repeats[i] = targets_per_image[i]
-        isect = isect.intersection(flattened.keys()) if isect else set(flattened.keys())
-        union.update(flattened.keys())
-        for k, v in dropped_inner.items():
-            dropped.setdefault(k, set()).update({DropReason(vv) for vv in v})
-        for k, v in flattened.items():
-            merged.setdefault(k, []).extend(flattened[k]) if isinstance(v, list) else merged.setdefault(k, []).append(v)
-
-    for k in union - isect:
-        dropped.setdefault(k, set()).add(DropReason.INCONSISTENT_KEY)
-
-    if image_repeats.sum() == image_repeats.size:
-        image_indices = np.arange(image_repeats.size)
-    else:
-        image_ids = np.arange(image_repeats.size)
-        image_data = np.concatenate(
-            [np.repeat(image_ids[i], image_repeats[i]) for i in range(image_ids.size)], dtype=np.int_
-        )
-        _, image_unsorted = np.unique(image_data, return_inverse=True)
-        image_indices = np.sort(image_unsorted)
-
-    output: dict[str, Any] = {}
+    merged, dropped, image_indices = _merge(dicts, ignore_lists, fully_qualified, targets_per_image)
 
-    if keys:
-        output["keys"] = np.array(keys) if return_numpy else keys
+    output: dict[str, Any] = {k: np.asarray(v) for k, v in merged.items()} if return_numpy else merged
 
-    for k in (key for key in merged if key in isect):
-        cv = _simplify_type(merged[k])
-        output[k] = np.array(cv) if return_numpy else cv
     if image_index_key not in output:
         output[image_index_key] = image_indices if return_numpy else image_indices.tolist()
 
     if return_dropped:
         return output, _sorted_drop_reasons(dropped)
-    else:
-        if dropped:
-            dropped_items = "\n".join([f"    {k}: {v}" for k, v in _sorted_drop_reasons(dropped).items()])
-            warnings.warn(f"Metadata entries were dropped:\n{dropped_items}")
-        return output
+
+    if dropped:
+        dropped_items = "\n".join([f"    {k}: {v}" for k, v in _sorted_drop_reasons(dropped).items()])
+        warnings.warn(f"Metadata entries were dropped:\n{dropped_items}")
+
+    return output

dataeval/utils/datasets/__init__.py

@@ -1,5 +1,6 @@
 """Provides access to common Computer Vision datasets."""
 
+from dataeval.utils.datasets._antiuav import AntiUAVDetection
 from dataeval.utils.datasets._cifar10 import CIFAR10
 from dataeval.utils.datasets._milco import MILCO
 from dataeval.utils.datasets._mnist import MNIST
@@ -10,6 +11,7 @@ __all__ = [
     "MNIST",
     "Ships",
     "CIFAR10",
+    "AntiUAVDetection",
     "MILCO",
     "VOCDetection",
     "VOCDetectionTorch",

dataeval/utils/datasets/_antiuav.py

@@ -0,0 +1,189 @@
+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]], 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