dataeval 0.69.3__py3-none-any.whl → 0.70.0__py3-none-any.whl

dataeval/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.69.3"
+__version__ = "0.70.0"
 
 from importlib.util import find_spec
 
@@ -7,9 +7,9 @@ _IS_TENSORFLOW_AVAILABLE = find_spec("tensorflow") is not None and find_spec("te
 
 del find_spec
 
-from . import detectors, flags, metrics  # noqa: E402
+from . import detectors, metrics  # noqa: E402
 
-__all__ = ["detectors", "flags", "metrics"]
+__all__ = ["detectors", "metrics"]
 
 if _IS_TORCH_AVAILABLE:  # pragma: no cover
     from . import torch, utils, workflows

dataeval/_internal/datasets.py

@@ -0,0 +1,300 @@
+from __future__ import annotations
+
+import hashlib
+import os
+import zipfile
+from pathlib import Path
+from typing import Literal
+from urllib.error import HTTPError, URLError
+from urllib.request import urlretrieve
+
+import numpy as np
+from numpy.typing import NDArray
+from torch.utils.data import Dataset
+from torchvision.datasets import CIFAR10, VOCDetection  # noqa: F401
+
+
+def _validate_file(fpath, file_md5, chunk_size=65535):
+    hasher = hashlib.md5()
+    with open(fpath, "rb") as fpath_file:
+        while chunk := fpath_file.read(chunk_size):
+            hasher.update(chunk)
+    return hasher.hexdigest() == file_md5
+
+
+def _get_file(
+    root: str | Path,
+    fname: str,
+    origin: str,
+    file_md5: str | None = None,
+):
+    fname = os.fspath(fname) if isinstance(fname, os.PathLike) else fname
+    fpath = os.path.join(root, fname)
+
+    download = False
+    if os.path.exists(fpath):
+        if file_md5 is not None and not _validate_file(fpath, file_md5):
+            download = True
+        else:
+            print("Files already downloaded and verified")
+    else:
+        download = True
+
+    if download:
+        try:
+            error_msg = "URL fetch failure on {}: {} -- {}"
+            try:
+                urlretrieve(origin, fpath)
+            except HTTPError as e:
+                raise Exception(error_msg.format(origin, e.code, e.msg)) from e
+            except URLError as e:
+                raise Exception(error_msg.format(origin, e.errno, e.reason)) from e
+        except (Exception, KeyboardInterrupt):
+            if os.path.exists(fpath):
+                os.remove(fpath)
+            raise
+
+        if os.path.exists(fpath) and file_md5 is not None and not _validate_file(fpath, file_md5):
+            raise ValueError(
+                "Incomplete or corrupted file detected. "
+                f"The md5 file hash does not match the provided value "
+                f"of {file_md5}.",
+            )
+    return fpath
+
+
+def download_dataset(url: str, root: str | Path, fname: str, md5: str) -> str:
+    """Code to download mnist and corruptions, originates from tensorflow_datasets (tfds):
+    https://github.com/tensorflow/datasets/blob/master/tensorflow_datasets/image_classification/mnist_corrupted.py
+    """
+    name, _ = os.path.splitext(fname)
+    folder = os.path.join(root, name)
+    os.makedirs(folder, exist_ok=True)
+
+    path = _get_file(
+        root,
+        fname,
+        origin=url + fname,
+        file_md5=md5,
+    )
+    extract_archive(path, remove_finished=True)
+    return path
+
+
+def extract_archive(
+    from_path: str | Path,
+    to_path: str | Path | None = None,
+    remove_finished: bool = False,
+):
+    """Extract an archive.
+
+    The archive type and a possible compression is automatically detected from the file name.
+    """
+    from_path = Path(from_path)
+    if not from_path.is_absolute():
+        from_path = from_path.resolve()
+
+    if to_path is None:
+        to_path = os.path.dirname(from_path)
+
+    # Extracting zip
+    with zipfile.ZipFile(from_path, "r", compression=zipfile.ZIP_STORED) as zzip:
+        zzip.extractall(to_path)
+
+    if remove_finished:
+        os.remove(from_path)
+
+
+class MNIST(Dataset):
+    """MNIST Dataset and Corruptions.
+
+    Args:
+        root : str | ``pathlib.Path``
+            Root directory of dataset where the ``mnist_c/`` folder exists.
+        train : bool, default True
+            If True, creates dataset from ``train_images.npy`` and ``train_labels.npy``.
+        download : bool, default False
+            If True, downloads the dataset from the internet and puts it in root
+            directory. If dataset is already downloaded, it is not downloaded again.
+        size : int, default -1
+            Limit the dataset size, must be a value greater than 0.
+        unit_interval : bool, default False
+            Shift the data values to the unit interval [0-1].
+        dtype : type | None, default None
+            Change the numpy dtype - data is loaded as np.uint8
+        channels : Literal['channels_first' | 'channels_last'] | None, default None
+            Location of channel axis if desired, default has no channels (N, 28, 28)
+        flatten : bool, default False
+            Flatten data into single dimension (N, 784) - cannot use both channels and flatten,
+            channels takes priority over flatten.
+        normalize : tuple[mean, std] | None, default None
+            Normalize images acorrding to provided mean and standard deviation
+        corruption : Literal['identity' | 'shot_noise' | 'impulse_noise' | 'glass_blur' |
+            'motion_blur' | 'shear' | 'scale' | 'rotate' | 'brightness' | 'translate' | 'stripe' |
+            'fog' | 'spatter' | 'dotted_line' | 'zigzag' | 'canny_edges'] | None, default None
+            The desired corruption style or None.
+    """
+
+    mirror = "https://zenodo.org/record/3239543/files/"
+
+    resources = ("mnist_c.zip", "4b34b33045869ee6d424616cd3a65da3")
+
+    classes = [
+        "0 - zero",
+        "1 - one",
+        "2 - two",
+        "3 - three",
+        "4 - four",
+        "5 - five",
+        "6 - six",
+        "7 - seven",
+        "8 - eight",
+        "9 - nine",
+    ]
+
+    @property
+    def train_labels(self):
+        return self.targets
+
+    @property
+    def test_labels(self):
+        return self.targets
+
+    @property
+    def train_data(self):
+        return self.data
+
+    @property
+    def test_data(self):
+        return self.data
+
+    def __init__(
+        self,
+        root: str | Path,
+        train: bool = True,
+        download: bool = False,
+        size: int = -1,
+        unit_interval: bool = False,
+        dtype: type | None = None,
+        channels: Literal["channels_first", "channels_last"] | None = None,
+        flatten: bool = False,
+        normalize: tuple[float, float] | None = None,
+        corruption: Literal[
+            "identity",
+            "shot_noise",
+            "impulse_noise",
+            "glass_blur",
+            "motion_blur",
+            "shear",
+            "scale",
+            "rotate",
+            "brightness",
+            "translate",
+            "stripe",
+            "fog",
+            "spatter",
+            "dotted_line",
+            "zigzag",
+            "canny_edges",
+        ]
+        | None = None,
+    ) -> None:
+        if isinstance(root, str):
+            root = os.path.expanduser(root)
+        self.root = root  # location of stored dataset
+        self.train = train  # training set or test set
+        self.size = size
+        self.unit_interval = unit_interval
+        self.dtype = dtype
+        self.channels = channels
+        self.flatten = flatten
+        self.normalize = normalize
+
+        if corruption is None:
+            corruption = "identity"
+        elif corruption == "identity":
+            print("Identity is not a corrupted dataset but the original MNIST dataset")
+        self.corruption = corruption
+
+        if os.path.exists(self.mnist_folder):
+            print("Files already downloaded and verified")
+        elif download:
+            download_dataset(self.mirror, self.root, self.resources[0], self.resources[1])
+        else:
+            raise RuntimeError("Dataset not found. You can use download=True to download it")
+
+        self.data, self.targets = self._load_data()
+
+    def _load_data(self):
+        image_file = f"{'train' if self.train else 'test'}_images.npy"
+        data = self._read_image_file(os.path.join(self.mnist_folder, image_file))
+
+        label_file = f"{'train' if self.train else 'test'}_labels.npy"
+        targets = self._read_label_file(os.path.join(self.mnist_folder, label_file))
+
+        if self.size >= 1 and self.size >= len(self.classes):
+            final_data = []
+            final_targets = []
+            for label in range(len(self.classes)):
+                indices = np.where(targets == label)[0]
+                selected_indices = indices[: int(self.size / len(self.classes))]
+                final_data.append(data[selected_indices])
+                final_targets.append(targets[selected_indices])
+            data = np.concatenate(final_data)
+            targets = np.concatenate(final_targets)
+            shuffled_indices = np.random.permutation(data.shape[0])
+            data = data[shuffled_indices]
+            targets = targets[shuffled_indices]
+        elif self.size >= 1:
+            data = data[: self.size]
+            targets = targets[: self.size]
+
+        if self.unit_interval:
+            data = data / 255
+
+        if self.normalize:
+            data = (data - self.normalize[0]) / self.normalize[1]
+
+        if self.dtype:
+            data = data.astype(self.dtype)
+
+        if self.channels == "channels_first":
+            data = np.moveaxis(data, -1, 1)
+        elif self.channels is None:
+            data = data[:, :, :, 0]
+
+        if self.flatten and self.channels is None:
+            data = data.reshape(data.shape[0], -1)
+
+        return data, targets
+
+    def __getitem__(self, index: int) -> tuple[NDArray, int]:
+        """
+        Args:
+            index (int): Index
+
+        Returns:
+            tuple: (image, target) where target is index of the target class.
+        """
+        img, target = self.data[index], int(self.targets[index])
+
+        return img, target
+
+    def __len__(self) -> int:
+        return len(self.data)
+
+    @property
+    def mnist_folder(self) -> str:
+        return os.path.join(self.root, "mnist_c", self.corruption)
+
+    @property
+    def class_to_idx(self) -> dict[str, int]:
+        return {_class: i for i, _class in enumerate(self.classes)}
+
+    def _read_label_file(self, path: str) -> NDArray:
+        x = np.load(path, allow_pickle=False)
+        return x
+
+    def _read_image_file(self, path: str) -> NDArray:
+        x = np.load(path, allow_pickle=False)
+        return x

dataeval/_internal/detectors/drift/base.py

@@ -16,7 +16,7 @@ from typing import Callable, Literal
 import numpy as np
 from numpy.typing import ArrayLike, NDArray
 
-from dataeval._internal.interop import to_numpy
+from dataeval._internal.interop import as_numpy, to_numpy
 from dataeval._internal.output import OutputMetadata, set_metadata
 
 
@@ -234,7 +234,7 @@ class BaseDrift:
         if correction not in ["bonferroni", "fdr"]:
             raise ValueError("`correction` must be `bonferroni` or `fdr`.")
 
-        self._x_ref = x_ref
+        self._x_ref = to_numpy(x_ref)
         self.x_ref_preprocessed = x_ref_preprocessed
 
         # Other attributes
@@ -242,7 +242,7 @@ class BaseDrift:
         self.update_x_ref = update_x_ref
         self.preprocess_fn = preprocess_fn
         self.correction = correction
-        self.n = len(self._x_ref)  # type: ignore
+        self.n = len(self._x_ref)
 
         # Ref counter for preprocessed x
         self._x_refcount = 0
@@ -260,9 +260,8 @@ class BaseDrift:
         if not self.x_ref_preprocessed:
             self.x_ref_preprocessed = True
             if self.preprocess_fn is not None:
-                self._x_ref = self.preprocess_fn(self._x_ref)
+                self._x_ref = as_numpy(self.preprocess_fn(self._x_ref))
 
-        self._x_ref = to_numpy(self._x_ref)
         return self._x_ref
 
     def _preprocess(self, x: ArrayLike) -> ArrayLike:
@@ -380,7 +379,7 @@ class BaseDriftUnivariate(BaseDrift):
                 self._n_features = self.x_ref.reshape(self.x_ref.shape[0], -1).shape[-1]
             else:
                 # infer number of features after applying preprocessing step
-                x = to_numpy(self.preprocess_fn(self._x_ref[0:1]))  # type: ignore
+                x = as_numpy(self.preprocess_fn(self._x_ref[0:1]))  # type: ignore
                 self._n_features = x.reshape(x.shape[0], -1).shape[-1]
 
         return self._n_features

dataeval/_internal/detectors/drift/mmd.py

@@ -14,7 +14,7 @@ from typing import Callable
 import torch
 from numpy.typing import ArrayLike
 
-from dataeval._internal.interop import to_numpy
+from dataeval._internal.interop import as_numpy
 from dataeval._internal.output import set_metadata
 
 from .base import BaseDrift, DriftBaseOutput, UpdateStrategy, preprocess_x, update_x_ref
@@ -110,7 +110,7 @@ class DriftMMD(BaseDrift):
         self.device = get_device(device)
 
         # initialize kernel
-        sigma_tensor = torch.from_numpy(to_numpy(sigma)).to(self.device) if sigma is not None else None
+        sigma_tensor = torch.from_numpy(as_numpy(sigma)).to(self.device) if sigma is not None else None
         self.kernel = kernel(sigma_tensor).to(self.device) if kernel == GaussianRBF else kernel
 
         # compute kernel matrix for the reference data
@@ -147,7 +147,7 @@ class DriftMMD(BaseDrift):
             p-value obtained from the permutation test, MMD^2 between the reference and test set,
             and MMD^2 threshold above which drift is flagged
         """
-        x = to_numpy(x)
+        x = as_numpy(x)
         x_ref = torch.from_numpy(self.x_ref).to(self.device)
         n = x.shape[0]
         kernel_mat = self._kernel_matrix(x_ref, torch.from_numpy(x).to(self.device))

dataeval/_internal/detectors/duplicates.py

@@ -1,13 +1,12 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Generic, Iterable, Sequence, TypeVar, cast
+from typing import Generic, Iterable, Sequence, TypeVar
 
 from numpy.typing import ArrayLike
 
 from dataeval._internal.detectors.merged_stats import combine_stats, get_dataset_step_from_idx
-from dataeval._internal.flags import ImageStat
-from dataeval._internal.metrics.stats import StatsOutput, imagestats
+from dataeval._internal.metrics.stats.hashstats import HashStatsOutput, hashstats
 from dataeval._internal.output import OutputMetadata, set_metadata
 
 DuplicateGroup = list[int]
@@ -53,26 +52,23 @@ class Duplicates:
     -------
     Initialize the Duplicates class:
 
-    >>> dups = Duplicates()
+    >>> all_dupes = Duplicates()
+    >>> exact_dupes = Duplicates(only_exact=True)
     """
 
     def __init__(self, only_exact: bool = False):
-        self.stats: StatsOutput
+        self.stats: HashStatsOutput
         self.only_exact = only_exact
 
-    def _get_duplicates(self) -> dict[str, list[list[int]]]:
-        stats_dict = self.stats.dict()
-        if "xxhash" in stats_dict:
-            exact_dict: dict[int, list] = {}
-            for i, value in enumerate(stats_dict["xxhash"]):
-                exact_dict.setdefault(value, []).append(i)
-            exact = [sorted(v) for v in exact_dict.values() if len(v) > 1]
-        else:
-            exact = []
+    def _get_duplicates(self, stats: dict) -> dict[str, list[list[int]]]:
+        exact_dict: dict[int, list] = {}
+        for i, value in enumerate(stats["xxhash"]):
+            exact_dict.setdefault(value, []).append(i)
+        exact = [sorted(v) for v in exact_dict.values() if len(v) > 1]
 
-        if "pchash" in stats_dict and not self.only_exact:
+        if not self.only_exact:
             near_dict: dict[int, list] = {}
-            for i, value in enumerate(stats_dict["pchash"]):
+            for i, value in enumerate(stats["pchash"]):
                 near_dict.setdefault(value, []).append(i)
             near = [sorted(v) for v in near_dict.values() if len(v) > 1 and not any(set(v).issubset(x) for x in exact)]
         else:
@@ -84,14 +80,14 @@ class Duplicates:
         }
 
     @set_metadata("dataeval.detectors", ["only_exact"])
-    def evaluate(self, data: Iterable[ArrayLike] | StatsOutput | Sequence[StatsOutput]) -> DuplicatesOutput:
+    def from_stats(self, hashes: HashStatsOutput | Sequence[HashStatsOutput]) -> DuplicatesOutput:
         """
         Returns duplicate image indices for both exact matches and near matches
 
         Parameters
         ----------
-        data : Iterable[ArrayLike], shape - (N, C, H, W) | StatsOutput | Sequence[StatsOutput]
-            A dataset of images in an ArrayLike format or the output(s) from an imagestats metric analysis
+        data : HashStatsOutput | Sequence[HashStatsOutput]
+            The output(s) from a hashstats analysis
 
         Returns
         -------
@@ -100,39 +96,60 @@ class Duplicates:
 
         See Also
         --------
-        imagestats
+        hashstats
 
         Example
         -------
-        >>> dups.evaluate(images)
-        DuplicatesOutput(exact=[[3, 20], [16, 37]], near=[[3, 20, 22], [12, 18], [13, 36], [14, 31], [17, 27], [19, 38, 47]])
-        """  # noqa: E501
+        >>> exact_dupes.from_stats([hashes1, hashes2])
+        DuplicatesOutput(exact=[{0: [3, 20]}, {0: [16], 1: [12]}], near=[])
+        """
 
-        stats, dataset_steps = combine_stats(data)
+        if isinstance(hashes, HashStatsOutput):
+            return DuplicatesOutput(**self._get_duplicates(hashes.dict()))
 
-        if isinstance(stats, StatsOutput):
-            if not stats.xxhash:
-                raise ValueError("StatsOutput must include xxhash information of the images.")
-            if not self.only_exact and not stats.pchash:
-                raise ValueError("StatsOutput must include pchash information of the images for near matches.")
-            self.stats = stats
-        else:
-            flags = ImageStat.XXHASH | (ImageStat(0) if self.only_exact else ImageStat.PCHASH)
-            self.stats = imagestats(cast(Iterable[ArrayLike], data), flags)
+        if not isinstance(hashes, Sequence):
+            raise TypeError("Invalid stats output type; only use output from hashstats.")
 
-        duplicates = self._get_duplicates()
+        combined, dataset_steps = combine_stats(hashes)
+        duplicates = self._get_duplicates(combined.dict())
 
         # split up results from combined dataset into individual dataset buckets
-        if dataset_steps:
-            dup_list: list[list[int]]
-            for dup_type, dup_list in duplicates.items():
-                dup_list_dict = []
-                for idxs in dup_list:
-                    dup_dict = {}
-                    for idx in idxs:
-                        k, v = get_dataset_step_from_idx(idx, dataset_steps)
-                        dup_dict.setdefault(k, []).append(v)
-                    dup_list_dict.append(dup_dict)
-                duplicates[dup_type] = dup_list_dict
+        for dup_type, dup_list in duplicates.items():
+            dup_list_dict = []
+            for idxs in dup_list:
+                dup_dict = {}
+                for idx in idxs:
+                    k, v = get_dataset_step_from_idx(idx, dataset_steps)
+                    dup_dict.setdefault(k, []).append(v)
+                dup_list_dict.append(dup_dict)
+            duplicates[dup_type] = dup_list_dict
+
+        return DuplicatesOutput(**duplicates)
+
+    @set_metadata("dataeval.detectors", ["only_exact"])
+    def evaluate(self, data: Iterable[ArrayLike]) -> DuplicatesOutput:
+        """
+        Returns duplicate image indices for both exact matches and near matches
+
+        Parameters
+        ----------
+        data : Iterable[ArrayLike], shape - (N, C, H, W) | StatsOutput | Sequence[StatsOutput]
+            A dataset of images in an ArrayLike format or the output(s) from a hashstats analysis
+
+        Returns
+        -------
+        DuplicatesOutput
+            List of groups of indices that are exact and near matches
 
+        See Also
+        --------
+        hashstats
+
+        Example
+        -------
+        >>> all_dupes.evaluate(images)
+        DuplicatesOutput(exact=[[3, 20], [16, 37]], near=[[3, 20, 22], [12, 18], [13, 36], [14, 31], [17, 27], [19, 38, 47]])
+        """  # noqa: E501
+        self.stats = hashstats(data)
+        duplicates = self._get_duplicates(self.stats.dict())
         return DuplicatesOutput(**duplicates)

dataeval/_internal/detectors/merged_stats.py

@@ -1,71 +1,40 @@
 from __future__ import annotations
 
-from typing import Sequence, cast
-from warnings import warn
+from copy import deepcopy
+from typing import Sequence, TypeVar
 
 import numpy as np
 
-from dataeval._internal.metrics.stats import StatsOutput
-from dataeval._internal.output import populate_defaults
+from dataeval._internal.metrics.stats.base import BaseStatsOutput
 
+TStatsOutput = TypeVar("TStatsOutput", bound=BaseStatsOutput)
 
-def add_stats(a: StatsOutput, b: StatsOutput) -> StatsOutput:
-    if not isinstance(a, StatsOutput) or not isinstance(b, StatsOutput):
-        raise TypeError(f"Cannot add object of type {type(a)} and type {type(b)}.")
 
-    a_dict = a.dict()
-    b_dict = b.dict()
-    a_keys = set(a_dict)
-    b_keys = set(b_dict)
+def add_stats(a: TStatsOutput, b: TStatsOutput) -> TStatsOutput:
+    if type(a) is not type(b):
+        raise TypeError(f"Types {type(a)} and {type(b)} cannot be added.")
 
-    missing_keys = a_keys - b_keys
-    if missing_keys:
-        raise ValueError(f"Required keys are missing: {missing_keys}.")
+    sum_dict = deepcopy(a.dict())
 
-    extra_keys = b_keys - a_keys
-    if extra_keys:
-        warn(f"Extraneous keys will be dropped: {extra_keys}.")
+    for k in sum_dict:
+        if isinstance(sum_dict[k], list):
+            sum_dict[k].extend(b.dict()[k])
+        else:
+            sum_dict[k] = np.concatenate((sum_dict[k], b.dict()[k]))
 
-    # perform add of multi-channel stats
-    if "ch_idx_map" in a_dict:
-        for k, v in a_dict.items():
-            if k == "ch_idx_map":
-                offset = sum([len(idxs) for idxs in v.values()])
-                for ch_k, ch_v in b_dict[k].items():
-                    if ch_k not in v:
-                        v[ch_k] = []
-                    a_dict[k][ch_k].extend([idx + offset for idx in ch_v])
-            else:
-                for ch_k in b_dict[k]:
-                    if ch_k not in v:
-                        v[ch_k] = b_dict[k][ch_k]
-                    else:
-                        v[ch_k] = np.concatenate((v[ch_k], b_dict[k][ch_k]), axis=1)
-    else:
-        for k in a_dict:
-            if isinstance(a_dict[k], list):
-                a_dict[k].extend(b_dict[k])
-            else:
-                a_dict[k] = np.concatenate((a_dict[k], b_dict[k]))
+    return type(a)(**sum_dict)
 
-    return StatsOutput(**populate_defaults(a_dict, StatsOutput))
-
-
-def combine_stats(stats) -> tuple[StatsOutput | None, list[int]]:
-    dataset_steps = []
-
-    if isinstance(stats, StatsOutput):
-        return stats, dataset_steps
 
+def combine_stats(stats: Sequence[TStatsOutput]) -> tuple[TStatsOutput, list[int]]:
     output = None
-    if isinstance(stats, Sequence) and isinstance(stats[0], StatsOutput):
-        stats = cast(Sequence[StatsOutput], stats)
-        cur_len = 0
-        for s in stats:
-            output = s if output is None else add_stats(output, s)
-            cur_len += len(s)
-            dataset_steps.append(cur_len)
-
+    dataset_steps = []
+    cur_len = 0
+    for s in stats:
+        output = s if output is None else add_stats(output, s)
+        cur_len += len(s)
+        dataset_steps.append(cur_len)
+    if output is None:
+        raise TypeError("Cannot combine empty sequence of stats.")
     return output, dataset_steps
 
 

dataeval/_internal/detectors/ood/ae.py

@@ -16,7 +16,7 @@ import tensorflow as tf
 from numpy.typing import ArrayLike
 
 from dataeval._internal.detectors.ood.base import OODBase, OODScore
-from dataeval._internal.interop import to_numpy
+from dataeval._internal.interop import as_numpy
 from dataeval._internal.models.tensorflow.autoencoder import AE
 from dataeval._internal.models.tensorflow.utils import predict_batch
 
@@ -46,10 +46,10 @@ class OOD_AE(OODBase):
     ) -> None:
         if loss_fn is None:
             loss_fn = keras.losses.MeanSquaredError()
-        super().fit(to_numpy(x_ref), threshold_perc, loss_fn, optimizer, epochs, batch_size, verbose)
+        super().fit(as_numpy(x_ref), threshold_perc, loss_fn, optimizer, epochs, batch_size, verbose)
 
     def score(self, X: ArrayLike, batch_size: int = int(1e10)) -> OODScore:
-        self._validate(X := to_numpy(X))
+        self._validate(X := as_numpy(X))
 
         # reconstruct instances
         X_recon = predict_batch(X, self.model, batch_size=batch_size)