dataeval 0.72.0__py3-none-any.whl → 0.72.2__py3-none-any.whl

dataeval/{_internal/detectors → detectors/linters}/outliers.py

@@ -1,18 +1,20 @@
 from __future__ import annotations
 
+__all__ = ["OutliersOutput", "Outliers"]
+
 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
+from dataeval.detectors.linters.merged_stats import combine_stats, get_dataset_step_from_idx
+from dataeval.metrics.stats.base import BOX_COUNT, SOURCE_INDEX
+from dataeval.metrics.stats.datasetstats import DatasetStatsOutput, datasetstats
+from dataeval.metrics.stats.dimensionstats import DimensionStatsOutput
+from dataeval.metrics.stats.pixelstats import PixelStatsOutput
+from dataeval.metrics.stats.visualstats import VisualStatsOutput
+from dataeval.output import OutputMetadata, set_metadata
 
 IndexIssueMap = dict[int, dict[str, float]]
 OutlierStatsOutput = Union[DimensionStatsOutput, PixelStatsOutput, VisualStatsOutput]
@@ -27,7 +29,7 @@ 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.
+        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.
@@ -37,7 +39,7 @@ class OutliersOutput(Generic[TIndexIssueMap], OutputMetadata):
 
     issues: TIndexIssueMap
 
-    def __len__(self):
+    def __len__(self) -> int:
         if isinstance(self.issues, dict):
             return len(self.issues)
         else:
@@ -69,7 +71,7 @@ def _get_outlier_mask(
 
 class Outliers:
     r"""
-    Calculates statistical outliers of a dataset using various statistical tests applied to each image
+    Calculates statistical Outliers of a dataset using various statistical tests applied to each image
 
     Parameters
     ----------
@@ -86,7 +88,7 @@ class Outliers:
 
     See Also
     --------
-    Duplicates
+    :term:`Duplicates`
 
     Note
     ----
@@ -157,12 +159,12 @@ class Outliers:
     @overload
     def from_stats(self, stats: Sequence[OutlierStatsOutput]) -> OutliersOutput[list[IndexIssueMap]]: ...
 
-    @set_metadata("dataeval.detectors", ["outlier_method", "outlier_threshold"])
+    @set_metadata(["outlier_method", "outlier_threshold"])
     def from_stats(
         self, stats: OutlierStatsOutput | DatasetStatsOutput | Sequence[OutlierStatsOutput]
-    ) -> OutliersOutput:
+    ) -> OutliersOutput[IndexIssueMap] | OutliersOutput[list[IndexIssueMap]]:
         """
-        Returns indices of outliers with the issues identified for each
+        Returns indices of Outliers with the issues identified for each
 
         Parameters
         ----------
@@ -195,7 +197,7 @@ class Outliers:
         {}
         """  # noqa: E501
         if isinstance(stats, DatasetStatsOutput):
-            outliers = self._get_outliers({k: v for o in stats.outputs() for k, v in o.dict().items()})
+            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)):
@@ -226,19 +228,10 @@ class Outliers:
 
         return OutliersOutput(output_list)
 
-    @set_metadata(
-        "dataeval.detectors",
-        [
-            "use_dimension",
-            "use_pixel",
-            "use_visual",
-            "outlier_method",
-            "outlier_threshold",
-        ],
-    )
+    @set_metadata(["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
+        Returns indices of Outliers with the issues identified for each
 
         Parameters
         ----------

dataeval/detectors/ood/__init__.py

@@ -1,23 +1,15 @@
 """
-Out-of-distribution detectors identify data that is different from the data used to train a particular model.
+Out-of-distribution (OOD)` detectors identify data that is different from the data used to train a particular model.
 """
 
 from dataeval import _IS_TENSORFLOW_AVAILABLE
 
 if _IS_TENSORFLOW_AVAILABLE:  # pragma: no cover
-    from dataeval._internal.detectors.ood.ae import OOD_AE
-    from dataeval._internal.detectors.ood.aegmm import OOD_AEGMM
-    from dataeval._internal.detectors.ood.base import OODOutput, OODScoreOutput
-    from dataeval._internal.detectors.ood.llr import OOD_LLR
-    from dataeval._internal.detectors.ood.vae import OOD_VAE
-    from dataeval._internal.detectors.ood.vaegmm import OOD_VAEGMM
+    from dataeval.detectors.ood.ae import OOD_AE
+    from dataeval.detectors.ood.aegmm import OOD_AEGMM
+    from dataeval.detectors.ood.base import OODOutput, OODScoreOutput
+    from dataeval.detectors.ood.llr import OOD_LLR
+    from dataeval.detectors.ood.vae import OOD_VAE
+    from dataeval.detectors.ood.vaegmm import OOD_VAEGMM
 
-    __all__ = [
-        "OOD_AE",
-        "OOD_AEGMM",
-        "OOD_LLR",
-        "OOD_VAE",
-        "OOD_VAEGMM",
-        "OODOutput",
-        "OODScoreOutput",
-    ]
+    __all__ = ["OOD_AE", "OOD_AEGMM", "OOD_LLR", "OOD_VAE", "OOD_VAEGMM", "OODOutput", "OODScoreOutput"]

dataeval/{_internal/detectors → detectors}/ood/ae.py

@@ -8,6 +8,8 @@ Licensed under Apache Software License (Apache 2.0)
 
 from __future__ import annotations
 
+__all__ = ["OOD_AE"]
+
 from typing import Callable
 
 import numpy as np
@@ -15,21 +17,20 @@ import tensorflow as tf
 import tf_keras as keras
 from numpy.typing import ArrayLike
 
-from dataeval._internal.detectors.ood.base import OODBase, OODScoreOutput
-from dataeval._internal.interop import as_numpy
-from dataeval._internal.models.tensorflow.autoencoder import AE
-from dataeval._internal.models.tensorflow.utils import predict_batch
-from dataeval._internal.output import set_metadata
+from dataeval.detectors.ood.base import OODBase, OODScoreOutput
+from dataeval.interop import as_numpy
+from dataeval.utils.tensorflow._internal.autoencoder import AE
+from dataeval.utils.tensorflow._internal.utils import predict_batch
 
 
 class OOD_AE(OODBase):
     """
-    Autoencoder based out-of-distribution detector.
+    Autoencoder-based :term:`out of distribution<Out-of-distribution (OOD)>` detector.
 
     Parameters
     ----------
     model : AE
-        An Autoencoder model.
+       An :term:`autoencoder<Autoencoder>` model.
     """
 
     def __init__(self, model: AE) -> None:
@@ -49,8 +50,7 @@ class OOD_AE(OODBase):
             loss_fn = keras.losses.MeanSquaredError()
         super().fit(as_numpy(x_ref), threshold_perc, loss_fn, optimizer, epochs, batch_size, verbose)
 
-    @set_metadata("dataeval.detectors")
-    def score(self, X: ArrayLike, batch_size: int = int(1e10)) -> OODScoreOutput:
+    def _score(self, X: ArrayLike, batch_size: int = int(1e10)) -> OODScoreOutput:
         self._validate(X := as_numpy(X))
 
         # reconstruct instances

dataeval/{_internal/detectors → detectors}/ood/aegmm.py

@@ -8,19 +8,20 @@ Licensed under Apache Software License (Apache 2.0)
 
 from __future__ import annotations
 
+__all__ = ["OOD_AEGMM"]
+
 from typing import Callable
 
 import tensorflow as tf
 import tf_keras as keras
 from numpy.typing import ArrayLike
 
-from dataeval._internal.detectors.ood.base import OODGMMBase, OODScoreOutput
-from dataeval._internal.interop import to_numpy
-from dataeval._internal.models.tensorflow.autoencoder import AEGMM
-from dataeval._internal.models.tensorflow.gmm import gmm_energy
-from dataeval._internal.models.tensorflow.losses import LossGMM
-from dataeval._internal.models.tensorflow.utils import predict_batch
-from dataeval._internal.output import set_metadata
+from dataeval.detectors.ood.base import OODGMMBase, OODScoreOutput
+from dataeval.interop import to_numpy
+from dataeval.utils.tensorflow._internal.autoencoder import AEGMM
+from dataeval.utils.tensorflow._internal.gmm import gmm_energy
+from dataeval.utils.tensorflow._internal.loss import LossGMM
+from dataeval.utils.tensorflow._internal.utils import predict_batch
 
 
 class OOD_AEGMM(OODGMMBase):
@@ -30,7 +31,7 @@ class OOD_AEGMM(OODGMMBase):
     Parameters
     ----------
     model : AEGMM
-        An AEGMM model.
+       An AEGMM model.
     """
 
     def __init__(self, model: AEGMM) -> None:
@@ -50,28 +51,7 @@ class OOD_AEGMM(OODGMMBase):
             loss_fn = LossGMM()
         super().fit(x_ref, threshold_perc, loss_fn, optimizer, epochs, batch_size, verbose)
 
-    @set_metadata("dataeval.detectors")
-    def score(self, X: ArrayLike, batch_size: int = int(1e10)) -> OODScoreOutput:
-        """
-        Compute the out-of-distribution (OOD) score for a given dataset.
-
-        Parameters
-        ----------
-        X : ArrayLike
-            Input data to score.
-        batch_size : int, default 1e10
-            Number of instances to process in each batch.
-            Use a smaller batch size if your dataset is large or if you encounter memory issues.
-
-        Returns
-        -------
-        OODScoreOutput
-            An object containing the instance-level OOD score.
-
-        Note
-        ----
-        This model does not produce a feature level score like the OOD_AE or OOD_VAE models.
-        """
+    def _score(self, X: ArrayLike, batch_size: int = int(1e10)) -> OODScoreOutput:
         self._validate(X := to_numpy(X))
         _, z, _ = predict_batch(X, self.model, batch_size=batch_size)
         energy, _ = gmm_energy(z, self.gmm_params, return_mean=False)

dataeval/{_internal/detectors → detectors}/ood/base.py

@@ -8,6 +8,8 @@ Licensed under Apache Software License (Apache 2.0)
 
 from __future__ import annotations
 
+__all__ = ["OODOutput", "OODScoreOutput"]
+
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from typing import Callable, Literal, cast
@@ -17,10 +19,10 @@ import tensorflow as tf
 import tf_keras as keras
 from numpy.typing import ArrayLike, NDArray
 
-from dataeval._internal.interop import to_numpy
-from dataeval._internal.models.tensorflow.gmm import GaussianMixtureModelParams, gmm_params
-from dataeval._internal.models.tensorflow.trainer import trainer
-from dataeval._internal.output import OutputMetadata, set_metadata
+from dataeval.interop import to_numpy
+from dataeval.output import OutputMetadata, set_metadata
+from dataeval.utils.tensorflow._internal.gmm import GaussianMixtureModelParams, gmm_params
+from dataeval.utils.tensorflow._internal.trainer import trainer
 
 
 @dataclass(frozen=True)
@@ -32,7 +34,7 @@ class OODOutput(OutputMetadata):
     Attributes
     ----------
     is_ood : NDArray
-        Array of images that are detected as out of distribution
+        Array of images that are detected as :term:Out-of-Distribution (OOD)`
     instance_score : NDArray
         Instance score of the evaluated dataset
     feature_score : NDArray | None
@@ -61,7 +63,7 @@ class OODScoreOutput(OutputMetadata):
     instance_score: NDArray[np.float32]
     feature_score: NDArray[np.float32] | None = None
 
-    def get(self, ood_type: Literal["instance", "feature"]) -> NDArray:
+    def get(self, ood_type: Literal["instance", "feature"]) -> NDArray[np.float32]:
         """
         Returns either the instance or feature score
 
@@ -107,9 +109,12 @@ class OODBase(ABC):
         self._validate(X)
 
     @abstractmethod
+    def _score(self, X: ArrayLike, batch_size: int = int(1e10)) -> OODScoreOutput: ...
+
+    @set_metadata()
     def score(self, X: ArrayLike, batch_size: int = int(1e10)) -> OODScoreOutput:
         """
-        Compute the out-of-distribution (OOD) scores for a given dataset.
+        Compute the :term:`out of distribution<Out-of-distribution (OOD)>` scores for a given dataset.
 
         Parameters
         ----------
@@ -124,6 +129,7 @@ class OODBase(ABC):
         OODScoreOutput
             An object containing the instance-level and feature-level OOD scores.
         """
+        return self._score(X, batch_size)
 
     def _threshold_score(self, ood_type: Literal["feature", "instance"] = "instance") -> np.floating:
         return np.percentile(self._ref_score.get(ood_type), self._threshold_perc)
@@ -131,12 +137,12 @@ class OODBase(ABC):
     def fit(
         self,
         x_ref: ArrayLike,
-        threshold_perc: float = 100.0,
-        loss_fn: Callable[..., tf.Tensor] | None = None,
-        optimizer: keras.optimizers.Optimizer = keras.optimizers.Adam,
-        epochs: int = 20,
-        batch_size: int = 64,
-        verbose: bool = True,
+        threshold_perc: float,
+        loss_fn: Callable[..., tf.Tensor],
+        optimizer: keras.optimizers.Optimizer,
+        epochs: int,
+        batch_size: int,
+        verbose: bool,
     ) -> None:
         """
         Train the model and infer the threshold value.
@@ -174,7 +180,7 @@ class OODBase(ABC):
         self._ref_score = self.score(x_ref, batch_size)
         self._threshold_perc = threshold_perc
 
-    @set_metadata("dataeval.detectors")
+    @set_metadata()
     def predict(
         self,
         X: ArrayLike,
@@ -182,7 +188,7 @@ class OODBase(ABC):
         ood_type: Literal["feature", "instance"] = "instance",
     ) -> OODOutput:
         """
-        Predict whether instances are out-of-distribution or not.
+        Predict whether instances are :term:`out of distribution<Out-of-distribution (OOD)>` or not.
 
         Parameters
         ----------
@@ -218,12 +224,12 @@ class OODGMMBase(OODBase):
     def fit(
         self,
         x_ref: ArrayLike,
-        threshold_perc: float = 100.0,
-        loss_fn: Callable[..., tf.Tensor] | None = None,
-        optimizer: keras.optimizers.Optimizer = keras.optimizers.Adam,
-        epochs: int = 20,
-        batch_size: int = 64,
-        verbose: bool = True,
+        threshold_perc: float,
+        loss_fn: Callable[..., tf.Tensor],
+        optimizer: keras.optimizers.Optimizer,
+        epochs: int,
+        batch_size: int,
+        verbose: bool,
     ) -> None:
         # Train the model
         trainer(

dataeval/{_internal/detectors → detectors}/ood/llr.py

@@ -8,6 +8,8 @@ Licensed under Apache Software License (Apache 2.0)
 
 from __future__ import annotations
 
+__all__ = ["OOD_LLR"]
+
 from functools import partial
 from typing import Callable
 
@@ -18,15 +20,14 @@ from numpy.typing import ArrayLike, NDArray
 from tf_keras.layers import Input
 from tf_keras.models import Model
 
-from dataeval._internal.detectors.ood.base import OODBase, OODScoreOutput
-from dataeval._internal.interop import to_numpy
-from dataeval._internal.models.tensorflow.pixelcnn import PixelCNN
-from dataeval._internal.models.tensorflow.trainer import trainer
-from dataeval._internal.models.tensorflow.utils import predict_batch
-from dataeval._internal.output import set_metadata
+from dataeval.detectors.ood.base import OODBase, OODScoreOutput
+from dataeval.interop import to_numpy
+from dataeval.utils.tensorflow._internal.pixelcnn import PixelCNN
+from dataeval.utils.tensorflow._internal.trainer import trainer
+from dataeval.utils.tensorflow._internal.utils import predict_batch
 
 
-def build_model(
+def _build_model(
     dist: PixelCNN, input_shape: tuple | None = None, filepath: str | None = None
 ) -> tuple[keras.Model, PixelCNN]:
     """
@@ -35,7 +36,7 @@ def build_model(
     Parameters
     ----------
     dist
-        TensorFlow distribution.
+        :term:`TensorFlow` distribution.
     input_shape
         Input shape of the model.
     filepath
@@ -54,11 +55,11 @@ def build_model(
     return model, dist
 
 
-def mutate_categorical(
+def _mutate_categorical(
     X: NDArray,
     rate: float,
     seed: int = 0,
-    feature_range: tuple = (0, 255),
+    feature_range: tuple[int, int] = (0, 255),
 ) -> tf.Tensor:
     """
     Randomly change integer feature values to values within a set range
@@ -113,17 +114,17 @@ class OOD_LLR(OODBase):
         log_prob: Callable | None = None,
         sequential: bool = False,
     ) -> None:
-        self.dist_s = model
-        self.dist_b = (
+        self.dist_s: PixelCNN = model
+        self.dist_b: PixelCNN = (
             model.copy()
             if hasattr(model, "copy")
             else keras.models.clone_model(model)
             if model_background is None
             else model_background
         )
-        self.has_log_prob = hasattr(model, "log_prob")
-        self.sequential = sequential
-        self.log_prob = log_prob
+        self.has_log_prob: bool = hasattr(model, "log_prob")
+        self.sequential: bool = sequential
+        self.log_prob: Callable | None = log_prob
 
         self._ref_score: OODScoreOutput
         self._threshold_perc: float
@@ -138,8 +139,12 @@ class OOD_LLR(OODBase):
         epochs: int = 20,
         batch_size: int = 64,
         verbose: bool = True,
-        mutate_fn: Callable = mutate_categorical,
-        mutate_fn_kwargs: dict = {"rate": 0.2, "seed": 0, "feature_range": (0, 255)},
+        mutate_fn: Callable = _mutate_categorical,
+        mutate_fn_kwargs: dict[str, float | int | tuple[int, int]] = {
+            "rate": 0.2,
+            "seed": 0,
+            "feature_range": (0, 255),
+        },
         mutate_batch_size: int = int(1e10),
     ) -> None:
         """
@@ -200,11 +205,11 @@ class OOD_LLR(OODBase):
 
         if use_build:
             # build and train semantic model
-            self.model_s = build_model(self.dist_s, input_shape)[0]
+            self.model_s: keras.Model = _build_model(self.dist_s, input_shape)[0]
             self.model_s.compile(optimizer=optimizer_s)
             self.model_s.fit(X, **kwargs)
             # build and train background model
-            self.model_b = build_model(self.dist_b, input_shape)[0]
+            self.model_b: keras.Model = _build_model(self.dist_b, input_shape)[0]
             self.model_b.compile(optimizer=optimizer_b)
             self.model_b.fit(X_back, **kwargs)
         else:
@@ -230,7 +235,7 @@ class OOD_LLR(OODBase):
         batch_size: int = int(1e10),
     ) -> NDArray:
         """
-        Compute log probability of a batch of instances under the generative model.
+        Compute log probability of a batch of instances under the :term:`generative model<Generative Model>`.
         """
         logp_fn = partial(dist.log_prob, return_per_feature=return_per_feature)
         # TODO: TBD: can this be any of the other types from predict_batch? i.e. tf.Tensor or tuple
@@ -269,7 +274,7 @@ class OOD_LLR(OODBase):
         return_per_feature
             Return likelihood ratio per feature.
         batch_size
-            Batch size for the generative model evaluations.
+            Batch size for the :term:`generative model<Generative Model>` evaluations.
 
         Returns
         -------
@@ -280,8 +285,7 @@ class OOD_LLR(OODBase):
         logp_b = logp_fn(self.dist_b, X, return_per_feature=return_per_feature, batch_size=batch_size)
         return logp_s - logp_b
 
-    @set_metadata("dataeval.detectors")
-    def score(
+    def _score(
         self,
         X: ArrayLike,
         batch_size: int = int(1e10),

dataeval/detectors/ood/metadata_ks_compare.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import numbers
+import warnings
+from typing import Any, Mapping
+
+import numpy as np
+from numpy.typing import NDArray
+from scipy.stats import iqr, ks_2samp
+from scipy.stats import wasserstein_distance as emd
+
+
+def meta_distribution_compare(
+    md0: Mapping[str, list[Any] | NDArray[Any]], md1: Mapping[str, list[Any] | NDArray[Any]]
+) -> dict[str, dict[str, float]]:
+    """Measures the featurewise distance between two metadata distributions, and computes a p-value to evaluate its
+        significance.
+
+        Uses the Earth Mover's Distance and the Kolmogorov-Smirnov two-sample test, featurewise.
+
+        Parameters
+        ----------
+        md0 : Mapping[str, list[Any] | NDArray[Any]]
+            A set of arrays of values, indexed by metadata feature names, with one value per data example per feature.
+        md1 : Mapping[str, list[Any] | NDArray[Any]]
+            Another set of arrays of values, indexed by metadata feature names, with one value per data example per
+            feature.
+
+        Returns
+        -------
+        dict[str, KstestResult]
+            A dictionary with keys corresponding to metadata feature names, and values that are KstestResult objects, as
+            defined by scipy.stats.ks_2samp. These values also have two additional attributes: shift_magnitude and
+            statistic_location. The first is the Earth Mover's Distance normalized by the interquartile range (IQR) of
+            the reference, while the second is the value at which the KS statistic has its maximum, measured in
+            IQR-normalized units relative to the median of the reference distribution.
+
+        Examples
+        --------
+        Imagine we have 3 data examples, and that the corresponding metadata contains 2 features called time and
+        altitude.
+
+    >>> import numpy
+    >>> md0 = {"time": [1.2, 3.4, 5.6], "altitude": [235, 6789, 101112]}
+    >>> md1 = {"time": [7.8, 9.10, 11.12], "altitude": [532, 9876, 211101]}
+    >>> md_out = meta_distribution_compare(md0, md1)
+    >>> for k, v in md_out.items():
+    >>>     print(k)
+    >>>     for kv in v:
+    >>>         print("\t", f"{kv}: {v[kv]:.3f}")
+    time
+             statistic_location: 0.444
+             shift_magnitude: 2.700
+             pvalue: 0.000
+    altitude
+             statistic_location: 0.478
+             shift_magnitude: 0.749
+             pvalue: 0.944
+    """
+
+    if (metadata_keys := md0.keys()) != md1.keys():
+        raise ValueError(f"Both sets of metadata keys must be identical: {list(md0)}, {list(md1)}")
+
+    mdc_dict = {}  # output dict
+    for k in metadata_keys:
+        mdc_dict.update({k: {}})
+
+        x0, x1 = list(md0[k]), list(md1[k])
+
+        allx = x0 + x1  # "+" sign concatenates lists.
+
+        if not all(isinstance(allxi, numbers.Number) for allxi in allx):  # NB: np.nan *is* a number in this context.
+            continue  # non-numeric features will return an empty dict for feature k
+
+        # from Numerical Recipes in C, 3rd ed. p. 737. If too few points, warn and keep going.
+        if np.sqrt(((N := len(x0)) * (M := len(x1))) / (N + M)) < 4:
+            warnings.warn(
+                f"Sample sizes of {N}, {M} for feature {k} will yield unreliable p-values from the KS test.",
+                UserWarning,
+            )
+
+        xmin, xmax = min(allx), max(allx)
+        if xmin == xmax:  # only one value in this feature, so fill in the obvious results for feature k
+            mdc_dict[k].update({"statistic_location": 0.0, "shift_magnitude": 0.0, "pvalue": 1.0})
+            continue
+
+        ks_result = ks_2samp(x0, x1, method="asymp")
+        dev = ks_result.statistic_location - xmin  #  pyright: ignore  (KSresult type)
+        loc = dev / (xmax - xmin) if xmax > xmin else dev
+
+        dX = iqr(x0)  # preferred value of dX, which is the scale of the the md0 values for feature k
+        dX = (max(x0) - min(x0)) / 2.0 if dX == 0 else dX  # reasonable alternative value of dX, when iqr is zero.
+        dX = 1.0 if dX == 0 else dX  # if dX is *still* zero, just avoid division by zero this way
+
+        drift = emd(x0, x1) / dX
+
+        mdc_dict[k].update({"statistic_location": loc, "shift_magnitude": drift, "pvalue": ks_result.pvalue})  #  pyright: ignore
+
+    return mdc_dict