dataeval 0.69.4__tar.gz → 0.70.0__tar.gz

{dataeval-0.69.4 → dataeval-0.70.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dataeval
-Version: 0.69.4
+Version: 0.70.0
 Summary: DataEval provides a simple interface to characterize image data and its impact on model performance across classification and object-detection tasks
 Home-page: https://dataeval.ai/
 License: MIT
@@ -32,8 +32,8 @@ Requires-Dist: scipy (>=1.10)
 Requires-Dist: tensorflow (>=2.14.1,<2.16) ; extra == "tensorflow" or extra == "all"
 Requires-Dist: tensorflow-io-gcs-filesystem (>=0.35.0,<0.37) ; extra == "tensorflow" or extra == "all"
 Requires-Dist: tensorflow_probability (>=0.22.1,<0.24) ; extra == "tensorflow" or extra == "all"
-Requires-Dist: torch (>=2.0.1,!=2.2.0) ; extra == "torch" or extra == "all"
-Requires-Dist: torchvision (>=0.16.0) ; extra == "torch" or extra == "all"
+Requires-Dist: torch (>=2.2.0) ; extra == "torch" or extra == "all"
+Requires-Dist: torchvision (>=0.17.0) ; extra == "torch" or extra == "all"
 Requires-Dist: xxhash (>=3.3)
 Project-URL: Documentation, https://dataeval.readthedocs.io/
 Project-URL: Repository, https://github.com/aria-ml/dataeval/

{dataeval-0.69.4 → dataeval-0.70.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dataeval"
-version = "0.69.4" # dynamic
+version = "0.70.0" # dynamic
 description = "DataEval provides a simple interface to characterize image data and its impact on model performance across classification and object-detection tasks"
 license = "MIT"
 readme = "README.md"
@@ -54,8 +54,8 @@ nvidia-cudnn-cu11 = {version = ">=8.6.0.163", optional = true}
 tensorflow = {version = ">=2.14.1, <2.16", optional = true}
 tensorflow-io-gcs-filesystem = {version = ">=0.35.0, <0.37", optional = true}
 tensorflow_probability = {version = ">=0.22.1, <0.24", optional = true}
-torch = {version = ">=2.0.1, !=2.2.0", source = "pytorch", optional = true}
-torchvision = {version = ">=0.16.0", source = "pytorch", optional = true}
+torch = {version = ">=2.2.0", source = "pytorch", optional = true}
+torchvision = {version = ">=0.17.0", source = "pytorch", optional = true}
 
 [tool.poetry.extras]
 tensorflow = ["tensorflow", "tensorflow-io-gcs-filesystem", "tensorflow_probability", "nvidia-cudnn-cu11"]
@@ -131,6 +131,7 @@ omit = [
   "*/_internal/models/pytorch/blocks.py",
   "*/_internal/models/pytorch/utils.py",
   "*/_internal/models/tensorflow/pixelcnn.py",
+  "*/_internal/datasets.py",
 ]
 fail_under = 90
 
@@ -173,6 +174,7 @@ docstring-code-line-length = "dynamic"
 
 [tool.codespell]
 skip = './*env*,./prototype,./output,./docs/_build,./docs/.jupyter_cache,CHANGELOG.md,poetry.lock,*.html'
+ignore-words-list = ["Hart"]
 
 [build-system]
 requires = ["poetry-core>=1.0.0", "poetry-dynamic-versioning"]

{dataeval-0.69.4 → dataeval-0.70.0}/src/dataeval/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.69.4"
+__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-0.69.4 → dataeval-0.70.0}/src/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-0.69.4 → dataeval-0.70.0}/src/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-0.69.4 → dataeval-0.70.0}/src/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-0.70.0/src/dataeval/_internal/detectors/merged_stats.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from copy import deepcopy
+from typing import Sequence, TypeVar
+
+import numpy as np
+
+from dataeval._internal.metrics.stats.base import BaseStatsOutput
+
+TStatsOutput = TypeVar("TStatsOutput", bound=BaseStatsOutput)
+
+
+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.")
+
+    sum_dict = deepcopy(a.dict())
+
+    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]))
+
+    return type(a)(**sum_dict)
+
+
+def combine_stats(stats: Sequence[TStatsOutput]) -> tuple[TStatsOutput, list[int]]:
+    output = None
+    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
+
+
+def get_dataset_step_from_idx(idx: int, dataset_steps: list[int]) -> tuple[int, int]:
+    last_step = 0
+    for i, step in enumerate(dataset_steps):
+        if idx < step:
+            return i, idx - last_step
+        last_step = step
+    return -1, idx

{dataeval-0.69.4 → dataeval-0.70.0}/src/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)

dataeval-0.70.0/src/dataeval/_internal/detectors/outliers.py

@@ -0,0 +1,269 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Generic, Iterable, Literal, Sequence, TypeVar, Union, overload
+
+import numpy as np
+from numpy.typing import ArrayLike, NDArray
+
+from dataeval._internal.detectors.merged_stats import combine_stats, get_dataset_step_from_idx
+from dataeval._internal.metrics.stats.base import BOX_COUNT, SOURCE_INDEX
+from dataeval._internal.metrics.stats.datasetstats import DatasetStatsOutput, datasetstats
+from dataeval._internal.metrics.stats.dimensionstats import DimensionStatsOutput
+from dataeval._internal.metrics.stats.pixelstats import PixelStatsOutput
+from dataeval._internal.metrics.stats.visualstats import VisualStatsOutput
+from dataeval._internal.output import OutputMetadata, set_metadata
+
+IndexIssueMap = dict[int, dict[str, float]]
+OutlierStatsOutput = Union[DimensionStatsOutput, PixelStatsOutput, VisualStatsOutput]
+TIndexIssueMap = TypeVar("TIndexIssueMap", IndexIssueMap, list[IndexIssueMap])
+
+
+@dataclass(frozen=True)
+class OutliersOutput(Generic[TIndexIssueMap], OutputMetadata):
+    """
+    Attributes
+    ----------
+    issues : dict[int, dict[str, float]] | list[dict[int, dict[str, float]]]
+        Indices of image outliers with their associated issue type and calculated values.
+
+    - For a single dataset, a dictionary containing the indices of outliers and
+      a dictionary showing the issues and calculated values for the given index.
+    - For multiple stats outputs, a list of dictionaries containing the indices of
+      outliers and their associated issues and calculated values.
+    """
+
+    issues: TIndexIssueMap
+
+    def __len__(self):
+        if isinstance(self.issues, dict):
+            return len(self.issues)
+        else:
+            return sum(len(d) for d in self.issues)
+
+
+def _get_outlier_mask(
+    values: NDArray, method: Literal["zscore", "modzscore", "iqr"], threshold: float | None
+) -> NDArray:
+    if method == "zscore":
+        threshold = threshold if threshold else 3.0
+        std = np.std(values)
+        abs_diff = np.abs(values - np.mean(values))
+        return std != 0 and (abs_diff / std) > threshold
+    elif method == "modzscore":
+        threshold = threshold if threshold else 3.5
+        abs_diff = np.abs(values - np.median(values))
+        med_abs_diff = np.median(abs_diff) if np.median(abs_diff) != 0 else np.mean(abs_diff)
+        mod_z_score = 0.6745 * abs_diff / med_abs_diff
+        return mod_z_score > threshold
+    elif method == "iqr":
+        threshold = threshold if threshold else 1.5
+        qrt = np.percentile(values, q=(25, 75), method="midpoint")
+        iqr = (qrt[1] - qrt[0]) * threshold
+        return (values < (qrt[0] - iqr)) | (values > (qrt[1] + iqr))
+    else:
+        raise ValueError("Outlier method must be 'zscore' 'modzscore' or 'iqr'.")
+
+
+class Outliers:
+    r"""
+    Calculates statistical outliers of a dataset using various statistical tests applied to each image
+
+    Parameters
+    ----------
+    outlier_method : ["modzscore" | "zscore" | "iqr"], optional - default "modzscore"
+        Statistical method used to identify outliers
+    outlier_threshold : float, optional - default None
+        Threshold value for the given ``outlier_method``, above which data is considered an outlier.
+        Uses method specific default if `None`
+
+    Attributes
+    ----------
+    stats : tuple[DimensionStatsOutput, PixelStatsOutput, VisualStatsOutput]
+        Various stats output classes that hold the value of each metric for each image
+
+    See Also
+    --------
+    Duplicates
+
+    Notes
+    ------
+    There are 3 different statistical methods:
+
+    - zscore
+    - modzscore
+    - iqr
+
+    | The z score method is based on the difference between the data point and the mean of the data.
+        The default threshold value for `zscore` is 3.
+    | Z score = :math:`|x_i - \mu| / \sigma`
+
+    | The modified z score method is based on the difference between the data point and the median of the data.
+        The default threshold value for `modzscore` is 3.5.
+    | Modified z score = :math:`0.6745 * |x_i - x̃| / MAD`, where :math:`MAD` is the median absolute deviation
+
+    | The interquartile range method is based on the difference between the data point and
+        the difference between the 75th and 25th qartile. The default threshold value for `iqr` is 1.5.
+    | Interquartile range = :math:`threshold * (Q_3 - Q_1)`
+
+    Examples
+    --------
+    Initialize the Outliers class:
+
+    >>> outliers = Outliers()
+
+    Specifying an outlier method:
+
+    >>> outliers = Outliers(outlier_method="iqr")
+
+    Specifying an outlier method and threshold:
+
+    >>> outliers = Outliers(outlier_method="zscore", outlier_threshold=3.5)
+    """
+
+    def __init__(
+        self,
+        use_dimension: bool = True,
+        use_pixel: bool = True,
+        use_visual: bool = True,
+        outlier_method: Literal["zscore", "modzscore", "iqr"] = "modzscore",
+        outlier_threshold: float | None = None,
+    ):
+        self.stats: DatasetStatsOutput
+        self.use_dimension = use_dimension
+        self.use_pixel = use_pixel
+        self.use_visual = use_visual
+        self.outlier_method: Literal["zscore", "modzscore", "iqr"] = outlier_method
+        self.outlier_threshold = outlier_threshold
+
+    def _get_outliers(self, stats: dict) -> dict[int, dict[str, float]]:
+        flagged_images: dict[int, dict[str, float]] = {}
+        for stat, values in stats.items():
+            if stat in (SOURCE_INDEX, BOX_COUNT):
+                continue
+            if values.ndim == 1:
+                mask = _get_outlier_mask(values.astype(np.float64), self.outlier_method, self.outlier_threshold)
+                indices = np.flatnonzero(mask)
+                for i, value in zip(indices, values[mask]):
+                    flagged_images.setdefault(i, {}).update({stat: value})
+
+        return dict(sorted(flagged_images.items()))
+
+    @overload
+    def from_stats(self, stats: OutlierStatsOutput | DatasetStatsOutput) -> OutliersOutput[IndexIssueMap]: ...
+
+    @overload
+    def from_stats(self, stats: Sequence[OutlierStatsOutput]) -> OutliersOutput[list[IndexIssueMap]]: ...
+
+    @set_metadata("dataeval.detectors", ["outlier_method", "outlier_threshold"])
+    def from_stats(
+        self, stats: OutlierStatsOutput | DatasetStatsOutput | Sequence[OutlierStatsOutput]
+    ) -> OutliersOutput:
+        """
+        Returns indices of outliers with the issues identified for each
+
+        Parameters
+        ----------
+        stats : OutlierStatsOutput | DatasetStatsOutput | Sequence[OutlierStatsOutput]
+            The output(s) from a dimensionstats, pixelstats, or visualstats metric
+            analysis or an aggregate DatasetStatsOutput
+
+        Returns
+        -------
+        OutliersOutput
+            Output class containing the indices of outliers and a dictionary showing
+            the issues and calculated values for the given index.
+
+        See Also
+        --------
+        dimensionstats
+        pixelstats
+        visualstats
+
+        Example
+        -------
+        Evaluate the dataset:
+
+        >>> results = outliers.from_stats([stats1, stats2])
+        >>> len(results)
+        2
+        >>> results.issues[0]
+        {10: {'skew': -3.906, 'kurtosis': 13.266, 'entropy': 0.2128}, 12: {'std': 0.00536, 'var': 2.87e-05, 'skew': -3.906, 'kurtosis': 13.266, 'entropy': 0.2128}}
+        >>> results.issues[1]
+        {}
+        """  # noqa: E501
+        if isinstance(stats, DatasetStatsOutput):
+            outliers = self._get_outliers({k: v for o in stats.outputs() for k, v in o.dict().items()})
+            return OutliersOutput(outliers)
+
+        if isinstance(stats, (DimensionStatsOutput, PixelStatsOutput, VisualStatsOutput)):
+            return OutliersOutput(self._get_outliers(stats.dict()))
+
+        if not isinstance(stats, Sequence):
+            raise TypeError(
+                "Invalid stats output type; only use output from dimensionstats, pixelstats or visualstats."
+            )
+
+        stats_map: dict[type, list[int]] = {}
+        for i, stats_output in enumerate(stats):
+            if not isinstance(
+                stats_output, (DatasetStatsOutput, DimensionStatsOutput, PixelStatsOutput, VisualStatsOutput)
+            ):
+                raise TypeError(
+                    "Invalid stats output type; only use output from dimensionstats, pixelstats or visualstats."
+                )
+            stats_map.setdefault(type(stats_output), []).append(i)
+
+        output_list: list[dict[int, dict[str, float]]] = [{} for _ in stats]
+        for _, indices in stats_map.items():
+            substats, dataset_steps = combine_stats([stats[i] for i in indices])
+            outliers = self._get_outliers(substats.dict())
+            for idx, issue in outliers.items():
+                k, v = get_dataset_step_from_idx(idx, dataset_steps)
+                output_list[indices[k]][v] = issue
+
+        return OutliersOutput(output_list)
+
+    @set_metadata(
+        "dataeval.detectors",
+        [
+            "use_dimension",
+            "use_pixel",
+            "use_visual",
+            "outlier_method",
+            "outlier_threshold",
+        ],
+    )
+    def evaluate(self, data: Iterable[ArrayLike]) -> OutliersOutput[IndexIssueMap]:
+        """
+        Returns indices of outliers with the issues identified for each
+
+        Parameters
+        ----------
+        data : Iterable[ArrayLike], shape - (C, H, W)
+            A dataset of images in an ArrayLike format
+
+        Returns
+        -------
+        OutliersOutput
+            Output class containing the indices of outliers and a dictionary showing
+            the issues and calculated values for the given index.
+
+        Example
+        -------
+        Evaluate the dataset:
+
+        >>> results = outliers.evaluate(images)
+        >>> list(results.issues)
+        [10, 12]
+        >>> results.issues[10]
+        {'skew': -3.906, 'kurtosis': 13.266, 'entropy': 0.2128, 'contrast': 1.25, 'zeros': 0.05493}
+        """
+        self.stats = datasetstats(
+            images=data,
+            use_dimension=self.use_dimension,
+            use_pixel=self.use_pixel,
+            use_visual=self.use_visual,
+        )
+        outliers = self._get_outliers({k: v for o in self.stats.outputs() for k, v in o.dict().items()})
+        return OutliersOutput(outliers)