dataeval 0.74.0__py3-none-any.whl → 0.74.2__py3-none-any.whl

dataeval/workflows/sufficiency.py

@@ -16,11 +16,11 @@ from scipy.optimize import basinhopping
 from torch.utils.data import Dataset
 
 from dataeval.interop import as_numpy
-from dataeval.output import OutputMetadata, set_metadata
+from dataeval.output import Output, set_metadata
 
 
 @dataclass(frozen=True)
-class SufficiencyOutput(OutputMetadata):
+class SufficiencyOutput(Output):
     """
     Output class for :class:`Sufficiency` workflow
 
@@ -47,7 +47,7 @@ class SufficiencyOutput(OutputMetadata):
             if c != c_v:
                 raise ValueError(f"{m} does not contain the expected number ({c}) of data points.")
 
-    @set_metadata()
+    @set_metadata
     def project(
         self,
         projection: int | Iterable[int],
@@ -484,7 +484,7 @@ class Sufficiency(Generic[T]):
     def eval_kwargs(self, value: Mapping[str, Any] | None) -> None:
         self._eval_kwargs = {} if value is None else value
 
-    @set_metadata(["runs", "substeps"])
+    @set_metadata(state=["runs", "substeps"])
     def evaluate(self, eval_at: int | Iterable[int] | None = None, niter: int = 1000) -> SufficiencyOutput:
         """
         Creates data indices, trains models, and returns plotting data

{dataeval-0.74.0.dist-info → dataeval-0.74.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dataeval
-Version: 0.74.0
+Version: 0.74.2
 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
@@ -21,17 +21,12 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Topic :: Scientific/Engineering
 Provides-Extra: all
-Provides-Extra: tensorflow
 Provides-Extra: torch
-Requires-Dist: markupsafe (<3.0.2) ; extra == "tensorflow" or extra == "all"
-Requires-Dist: matplotlib ; extra == "torch" or extra == "all"
-Requires-Dist: numpy (>1.24.3)
+Requires-Dist: matplotlib ; extra == "all"
+Requires-Dist: numpy (>=1.24.3)
 Requires-Dist: pillow (>=10.3.0)
 Requires-Dist: scikit-learn (>=1.5.0)
 Requires-Dist: scipy (>=1.10)
-Requires-Dist: tensorflow (>=2.16,<2.18) ; extra == "tensorflow" or extra == "all"
-Requires-Dist: tensorflow_probability (>=0.24,<0.25) ; extra == "tensorflow" or extra == "all"
-Requires-Dist: tf-keras (>=2.16,<2.18) ; extra == "tensorflow" 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: tqdm

dataeval-0.74.2.dist-info/RECORD

@@ -0,0 +1,66 @@
+dataeval/__init__.py,sha256=w_On8sJ5o_f8PboMo6LLErdFSqDAQ1Jg_e0mcp-5FRU,959
+dataeval/detectors/__init__.py,sha256=Y-0bbyWyuMvZU80bCx6WPt3IV_r2hu9ymzpA8uzMqoI,206
+dataeval/detectors/drift/__init__.py,sha256=BSXm21y7cAawHep-ZldCJ5HOvzYjPzYGKGrmoEs3i0E,737
+dataeval/detectors/drift/base.py,sha256=QDGHMu1WADD-38MEIOwjQMEQM3DE7B0yFHO3hsMbV-E,14481
+dataeval/detectors/drift/cvm.py,sha256=kc59w2_wtxFGNnLcaJRvX5v_38gPXiebSGNiFVdunEQ,4142
+dataeval/detectors/drift/ks.py,sha256=gcpe1WIQeNeZdLYkdMZCFLXUp1bHMQUxwJE6-RLVOXs,4229
+dataeval/detectors/drift/mmd.py,sha256=C0FX5v9ZJzmKNYEcYUaC7sDtMpJ2dZpwikNDu-AEWiI,7584
+dataeval/detectors/drift/torch.py,sha256=igEQ2DV9JmcpTdUKCOHBi5LxtoNeCAslJS2Ldulg1hw,7585
+dataeval/detectors/drift/uncertainty.py,sha256=Xz2yzJjtJfw1vLag234jwRvaa_HK36nMajGx8bQaNRs,5322
+dataeval/detectors/drift/updates.py,sha256=UJ0z5hlunRi7twnkLABfdJG3tT2EqX4y9IGx8_USYvo,1780
+dataeval/detectors/linters/__init__.py,sha256=BvpaB1RUpkEhhXk3Mqi5NYoOcJKZRFSBOJCmQOIfYRU,483
+dataeval/detectors/linters/clusterer.py,sha256=hK-ak02GaxwWuufesZMKDsvoE5fMdXO7UWsLiK8hfY0,21008
+dataeval/detectors/linters/duplicates.py,sha256=2bmPTFqoefeiAQV9y4CGlHV_mJNrysJSEFLXLd2DO4I,5661
+dataeval/detectors/linters/merged_stats.py,sha256=X-bDTwjyR8RuVmzxLaHZmQ5nI3oOWvsqVlitdSncapk,1355
+dataeval/detectors/linters/outliers.py,sha256=X48bzTfTr1LqC6WKVKBRfvpjcQRgmb93cNLT7Oipe3M,10113
+dataeval/detectors/ood/__init__.py,sha256=-D4Fq-ysFylNNMqjHG1ALbB9qBCm_UinkCAgsK9HGg0,408
+dataeval/detectors/ood/ae_torch.py,sha256=pO9w5221bXR9lEBkE7oakXeE7PXUUR--xcTpmHvOCSk,2142
+dataeval/detectors/ood/base.py,sha256=UzcDbXl8Gv43VFzjrOegTnKSIoEYmfDP7fAySeWyWPw,6955
+dataeval/detectors/ood/base_torch.py,sha256=yFbSfQsBMwZeVf8mrixmkZYBGChhV5oAHtkgzWnMzsA,3405
+dataeval/detectors/ood/metadata_ks_compare.py,sha256=LNDNWGEDKTW8_-djgmK53sn9EZzzXq1Sgwc47k0QI-Y,5380
+dataeval/detectors/ood/metadata_least_likely.py,sha256=nxMCXUOjOfWHDTGT2SLE7OYBCydRq8zHLd8t17k7hMM,5193
+dataeval/detectors/ood/metadata_ood_mi.py,sha256=KLay2BmgHrStBV92VpIs_B1yEfQKllsMTgzOQEng01I,4065
+dataeval/interop.py,sha256=5lACbR7bZYGCagiwbXzAWvWeHRj8kWBmsTC9oEjFh78,2249
+dataeval/logging.py,sha256=uGxXPqGpn5guQjuHtm25rzILaz7nCQUsy2o7tFo91OI,343
+dataeval/metrics/__init__.py,sha256=fPBNLd-T6mCErZBBJrxWmXIL0jCk7fNUYIcNEBkMa80,238
+dataeval/metrics/bias/__init__.py,sha256=dYiPHenS8J7pgRMMW2jNkTBmTbPoYTxT04fZu9PFats,747
+dataeval/metrics/bias/balance.py,sha256=_TZEe17AT-qOvPp-QFrQfTqNwh8uVVCYjC4Sv6JBx9o,9118
+dataeval/metrics/bias/coverage.py,sha256=o65_IgrWSlGnYeYZFABjwKaxq09uqyy5esHJM67PJ-k,4528
+dataeval/metrics/bias/diversity.py,sha256=WL1NbZiRrv0SIq97FY3womZNCSl_EBMVlBWQZAUtjk8,7701
+dataeval/metrics/bias/metadata_preprocessing.py,sha256=ekUFiirkmaHDiH7nJjkNpiUQD7OolAPhHorjLxpXv_Y,12248
+dataeval/metrics/bias/metadata_utils.py,sha256=HmTjlRRTdM9566oKUDDdVMJ8luss4DYykFOiS2FQzhM,6558
+dataeval/metrics/bias/parity.py,sha256=hnA7qQH4Uy3tl_krluZ9BPD5zYjjagUxZt2fEiIa2yE,12745
+dataeval/metrics/estimators/__init__.py,sha256=O6ocxJq8XDkfJWwXeJnnnzbOyRnFPKF4kTIVTTZYOA8,380
+dataeval/metrics/estimators/ber.py,sha256=fs3_e9pgu7I50QIALWtF2aidkBZhTCKVE2pA7PyB5Go,5019
+dataeval/metrics/estimators/divergence.py,sha256=r_SKSurf1TdI5E1ivENqDnz8cQ3_sxVGKAqmF9cqcT4,4275
+dataeval/metrics/estimators/uap.py,sha256=Aw5ReoWNK73Tq96r__qN_-cvHrELauqtDX3Af_QxX4s,2157
+dataeval/metrics/stats/__init__.py,sha256=igLRaAt1nX6yRwC4xI0zNPBADi3u7EsSxWP3OZ8AqcU,1086
+dataeval/metrics/stats/base.py,sha256=_C05KUAuDrfX3N-19o25V3vmXr0-45A5fc57cXyV8qs,12161
+dataeval/metrics/stats/boxratiostats.py,sha256=bZunY-b8Y2IQqHlTusQN77ujLOHftogEQIARDpdVv6A,6463
+dataeval/metrics/stats/datasetstats.py,sha256=rZUDiciHwEpnXmkI8-uJNiYwUuTL9ssZMKMx73hVX-Y,6219
+dataeval/metrics/stats/dimensionstats.py,sha256=xITgQF_oomb6Ty_dJcbT3ARGGNp4QRcYSgnkjB4f-YE,4054
+dataeval/metrics/stats/hashstats.py,sha256=vxw_K74EJM9CZy-EV617vdrysFO8nEspVWqIYsIHC-c,4958
+dataeval/metrics/stats/labelstats.py,sha256=K0hJTphMe7htSjyss8GPtKDiHepTuU60_hX0xRA-uAg,4096
+dataeval/metrics/stats/pixelstats.py,sha256=2zr9i3GLNx1i_SCtbfdtZNxXBEc_9wCe4qDpmXLVbKY,4576
+dataeval/metrics/stats/visualstats.py,sha256=vLIC4sMo796axWl-4e4RzT33ll-_6ki54Dirn3V-EL8,4948
+dataeval/output.py,sha256=hR5TJ67f7FgrZO9Du46aw-jvRpMjOimSgJSau4ZNK44,3565
+dataeval/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataeval/utils/__init__.py,sha256=z7HxSijjycey-rGdQkgVOdpvT0oO2pKAuT4uYyxYGMs,555
+dataeval/utils/gmm.py,sha256=YuLsJKsVWgH_wHr1u_hSRH5Yeexdj8exht8h99L7bLo,561
+dataeval/utils/image.py,sha256=KgC_1nW__nGN5q6bVZNvG4U_qIBdjcPATz9qe8f2XuA,1928
+dataeval/utils/metadata.py,sha256=0A--iru0zEmi044mKz5P35q69KrI30yoiRSlvs7TSdQ,9418
+dataeval/utils/shared.py,sha256=xvF3VLfyheVwJtdtDrneOobkKf7t-JTmf_w91FWXmqo,3616
+dataeval/utils/split_dataset.py,sha256=KYIl2ueLN0BeBoEvbUP5FdwVcMYW_l-ES1nQf_zKpQA,18776
+dataeval/utils/torch/__init__.py,sha256=lpkqfgyARUxgrV94cZESQv8PIP2p-UnwItZ_wIr0XzQ,675
+dataeval/utils/torch/blocks.py,sha256=HVhBTMMD5NA4qheMUgyol1KWiKZDIuc8k5j4RcMKmhk,1466
+dataeval/utils/torch/datasets.py,sha256=10elNgLuH_FDX_CHE3y2Z215JN4-PQovQm5brcIJOeM,15021
+dataeval/utils/torch/gmm.py,sha256=VbLlUQohwToApT493_tjQBWy2UM5R-3ppS9Dp-eP7BA,3240
+dataeval/utils/torch/models.py,sha256=sdGeo7a8vshCTGA4lYyVxxb_aDWUlxdtIVxrddS-_ls,8542
+dataeval/utils/torch/trainer.py,sha256=8BEXr6xtk-CHJTcNxOBnWgkFWfJUAiBy28cEdBhLMRU,7883
+dataeval/utils/torch/utils.py,sha256=nWRcT6z6DbFVrL1RyxCOX3DPoCrv9G0B-VI_9LdGCQQ,5784
+dataeval/workflows/__init__.py,sha256=ef1MiVL5IuhlDXXbwsiAfafhnr7tD3TXF9GRusy9_O8,290
+dataeval/workflows/sufficiency.py,sha256=v9AV3BZT0NW-zD2VNIL_5aWspvoscrxRIUKcUdpy7HI,18540
+dataeval-0.74.2.dist-info/LICENSE.txt,sha256=Kpzcfobf1HlqafF-EX6dQLw9TlJiaJzfgvLQFukyXYw,1060
+dataeval-0.74.2.dist-info/METADATA,sha256=Rcnn55cRPZ2JZ1jn8YamuVDxmQVDKEItK4oqZyAYkHM,4298
+dataeval-0.74.2.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+dataeval-0.74.2.dist-info/RECORD,,

dataeval/detectors/ood/ae.py

@@ -1,76 +0,0 @@
-"""
-Source code derived from Alibi-Detect 0.11.4
-https://github.com/SeldonIO/alibi-detect/tree/v0.11.4
-
-Original code Copyright (c) 2023 Seldon Technologies Ltd
-Licensed under Apache Software License (Apache 2.0)
-"""
-
-from __future__ import annotations
-
-__all__ = ["OOD_AE"]
-
-from typing import TYPE_CHECKING, Callable
-
-import numpy as np
-from numpy.typing import ArrayLike
-
-from dataeval.detectors.ood.base import OODScoreOutput
-from dataeval.detectors.ood.base_tf import OODBase
-from dataeval.interop import as_numpy
-from dataeval.utils.lazy import lazyload
-from dataeval.utils.tensorflow._internal.utils import predict_batch
-
-if TYPE_CHECKING:
-    import tensorflow as tf
-    import tf_keras as keras
-
-    import dataeval.utils.tensorflow._internal.models as tf_models
-else:
-    tf = lazyload("tensorflow")
-    keras = lazyload("tf_keras")
-    tf_models = lazyload("dataeval.utils.tensorflow._internal.models")
-
-
-class OOD_AE(OODBase):
-    """
-    Autoencoder-based :term:`out of distribution<Out-of-distribution (OOD)>` detector.
-
-    Parameters
-    ----------
-    model : AE
-       An :term:`autoencoder<Autoencoder>` model.
-    """
-
-    def __init__(self, model: tf_models.AE) -> None:
-        super().__init__(model)
-
-    def fit(
-        self,
-        x_ref: ArrayLike,
-        threshold_perc: float = 100.0,
-        loss_fn: Callable[..., tf.Tensor] | None = None,
-        optimizer: keras.optimizers.Optimizer | None = None,
-        epochs: int = 20,
-        batch_size: int = 64,
-        verbose: bool = True,
-    ) -> None:
-        if loss_fn is None:
-            loss_fn = keras.losses.MeanSquaredError()
-        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)) -> OODScoreOutput:
-        self._validate(X := as_numpy(X))
-
-        # reconstruct instances
-        X_recon = predict_batch(X, self.model, batch_size=batch_size)
-
-        # compute feature and instance level scores
-        fscore = np.power(X - X_recon, 2)
-        fscore_flat = fscore.reshape(fscore.shape[0], -1).copy()
-        n_score_features = int(np.ceil(fscore_flat.shape[1]))
-        sorted_fscore = np.sort(fscore_flat, axis=1)
-        sorted_fscore_perc = sorted_fscore[:, -n_score_features:]
-        iscore = np.mean(sorted_fscore_perc, axis=1)
-
-        return OODScoreOutput(iscore, fscore)

dataeval/detectors/ood/aegmm.py

@@ -1,67 +0,0 @@
-"""
-Source code derived from Alibi-Detect 0.11.4
-https://github.com/SeldonIO/alibi-detect/tree/v0.11.4
-
-Original code Copyright (c) 2023 Seldon Technologies Ltd
-Licensed under Apache Software License (Apache 2.0)
-"""
-
-from __future__ import annotations
-
-__all__ = ["OOD_AEGMM"]
-
-from typing import TYPE_CHECKING, Callable
-
-from numpy.typing import ArrayLike
-
-from dataeval.detectors.ood.base import OODScoreOutput
-from dataeval.detectors.ood.base_tf import OODBaseGMM
-from dataeval.interop import to_numpy
-from dataeval.utils.lazy import lazyload
-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
-
-if TYPE_CHECKING:
-    import tensorflow as tf
-    import tf_keras as keras
-
-    import dataeval.utils.tensorflow._internal.models as tf_models
-else:
-    tf = lazyload("tensorflow")
-    keras = lazyload("tf_keras")
-    tf_models = lazyload("dataeval.utils.tensorflow._internal.models")
-
-
-class OOD_AEGMM(OODBaseGMM):
-    """
-    AE with Gaussian Mixture Model based outlier detector.
-
-    Parameters
-    ----------
-    model : AEGMM
-       An AEGMM model.
-    """
-
-    def __init__(self, model: tf_models.AEGMM) -> None:
-        super().__init__(model)
-
-    def fit(
-        self,
-        x_ref: ArrayLike,
-        threshold_perc: float = 100.0,
-        loss_fn: Callable[..., tf.Tensor] | None = None,
-        optimizer: keras.optimizers.Optimizer | None = None,
-        epochs: int = 20,
-        batch_size: int = 64,
-        verbose: bool = True,
-    ) -> None:
-        if loss_fn is None:
-            loss_fn = LossGMM()
-        super().fit(x_ref, threshold_perc, loss_fn, optimizer, epochs, batch_size, verbose)
-
-    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)
-        return OODScoreOutput(energy.numpy())  # type: ignore

dataeval/detectors/ood/base_tf.py

@@ -1,109 +0,0 @@
-"""
-Source code derived from Alibi-Detect 0.11.4
-https://github.com/SeldonIO/alibi-detect/tree/v0.11.4
-
-Original code Copyright (c) 2023 Seldon Technologies Ltd
-Licensed under Apache Software License (Apache 2.0)
-"""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Callable, cast
-
-from numpy.typing import ArrayLike
-
-from dataeval.detectors.ood.base import OODBaseMixin, OODFitMixin, OODGMMMixin
-from dataeval.interop import to_numpy
-from dataeval.utils.lazy import lazyload
-from dataeval.utils.tensorflow._internal.gmm import gmm_params
-from dataeval.utils.tensorflow._internal.trainer import trainer
-
-if TYPE_CHECKING:
-    import tensorflow as tf
-    import tf_keras as keras
-else:
-    tf = lazyload("tensorflow")
-    keras = lazyload("tf_keras")
-
-
-class OODBase(OODBaseMixin[keras.Model], OODFitMixin[Callable[..., tf.Tensor], keras.optimizers.Optimizer]):
-    def __init__(self, model: keras.Model) -> None:
-        super().__init__(model)
-
-    def fit(
-        self,
-        x_ref: ArrayLike,
-        threshold_perc: float,
-        loss_fn: Callable[..., tf.Tensor] | None,
-        optimizer: keras.optimizers.Optimizer | None,
-        epochs: int,
-        batch_size: int,
-        verbose: bool,
-    ) -> None:
-        """
-        Train the model and infer the threshold value.
-
-        Parameters
-        ----------
-        x_ref : ArrayLike
-            Training data.
-        threshold_perc : float, default 100.0
-            Percentage of reference data that is normal.
-        loss_fn : Callable | None, default None
-            Loss function used for training.
-        optimizer : Optimizer, default keras.optimizers.Adam
-            Optimizer used for training.
-        epochs : int, default 20
-            Number of training epochs.
-        batch_size : int, default 64
-            Batch size used for training.
-        verbose : bool, default True
-            Whether to print training progress.
-        """
-
-        # Train the model
-        trainer(
-            model=self.model,
-            loss_fn=loss_fn,
-            x_train=to_numpy(x_ref),
-            y_train=None,
-            optimizer=optimizer,
-            epochs=epochs,
-            batch_size=batch_size,
-            verbose=verbose,
-        )
-
-        # Infer the threshold values
-        self._ref_score = self.score(x_ref, batch_size)
-        self._threshold_perc = threshold_perc
-
-
-class OODBaseGMM(OODBase, OODGMMMixin[tf.Tensor]):
-    def fit(
-        self,
-        x_ref: ArrayLike,
-        threshold_perc: float,
-        loss_fn: Callable[..., tf.Tensor] | None,
-        optimizer: keras.optimizers.Optimizer | None,
-        epochs: int,
-        batch_size: int,
-        verbose: bool,
-    ) -> None:
-        # Train the model
-        trainer(
-            model=self.model,
-            loss_fn=loss_fn,
-            x_train=to_numpy(x_ref),
-            optimizer=optimizer,
-            epochs=epochs,
-            batch_size=batch_size,
-            verbose=verbose,
-        )
-
-        # Calculate the GMM parameters
-        _, z, gamma = cast(tuple[tf.Tensor, tf.Tensor, tf.Tensor], self.model(x_ref))
-        self._gmm_params = gmm_params(z, gamma)
-
-        # Infer the threshold values
-        self._ref_score = self.score(x_ref, batch_size)
-        self._threshold_perc = threshold_perc

dataeval/detectors/ood/llr.py

@@ -1,302 +0,0 @@
-"""
-Source code derived from Alibi-Detect 0.11.4
-https://github.com/SeldonIO/alibi-detect/tree/v0.11.4
-
-Original code Copyright (c) 2023 Seldon Technologies Ltd
-Licensed under Apache Software License (Apache 2.0)
-"""
-
-from __future__ import annotations
-
-__all__ = ["OOD_LLR"]
-
-from functools import partial
-from typing import TYPE_CHECKING, Callable
-
-import numpy as np
-from numpy.typing import ArrayLike, NDArray
-
-from dataeval.detectors.ood.base import OODBaseMixin, OODScoreOutput
-from dataeval.interop import to_numpy
-from dataeval.utils.lazy import lazyload
-from dataeval.utils.tensorflow._internal.trainer import trainer
-from dataeval.utils.tensorflow._internal.utils import predict_batch
-
-if TYPE_CHECKING:
-    import tensorflow as tf
-    import tf_keras as keras
-
-    import dataeval.utils.tensorflow._internal.models as tf_models
-else:
-    tf = lazyload("tensorflow")
-    keras = lazyload("tf_keras")
-    tf_models = lazyload("dataeval.utils.tensorflow._internal.models")
-
-
-def _build_model(
-    dist: tf_models.PixelCNN, input_shape: tuple | None = None, filepath: str | None = None
-) -> tuple[keras.Model, tf_models.PixelCNN]:
-    """
-    Create keras.Model from TF distribution.
-
-    Parameters
-    ----------
-    dist
-        :term:`TensorFlow` distribution.
-    input_shape
-        Input shape of the model.
-    filepath
-        File to load model weights from.
-
-    Returns
-    -------
-    TensorFlow model.
-    """
-    x_in = keras.layers.Input(shape=input_shape)
-    log_prob = dist.log_prob(x_in)
-    model = keras.models.Model(inputs=x_in, outputs=log_prob)
-    model.add_loss(-tf.reduce_mean(log_prob))
-    if isinstance(filepath, str):
-        model.load_weights(filepath)
-    return model, dist
-
-
-def _mutate_categorical(
-    X: NDArray,
-    rate: float,
-    seed: int = 0,
-    feature_range: tuple[int, int] = (0, 255),
-) -> tf.Tensor:
-    """
-    Randomly change integer feature values to values within a set range
-    with a specified permutation rate.
-
-    Parameters
-    ----------
-    X
-        Batch of data to be perturbed.
-    rate
-        Permutation rate (between 0 and 1).
-    seed
-        Random seed.
-    feature_range
-        Min and max range for perturbed features.
-
-    Returns
-    -------
-    Array with perturbed data.
-    """
-    frange = (feature_range[0] + 1, feature_range[1] + 1)
-    shape = X.shape
-    n_samples = np.prod(shape)
-    mask = tf.random.categorical(tf.math.log([[1.0 - rate, rate]]), n_samples, seed=seed, dtype=tf.int32)
-    mask = tf.reshape(mask, shape)
-    possible_mutations = tf.random.uniform(shape, minval=frange[0], maxval=frange[1], dtype=tf.int32, seed=seed + 1)
-    X = tf.math.floormod(tf.cast(X, tf.int32) + mask * possible_mutations, frange[1])  # type: ignore py38
-    return tf.cast(X, tf.float32)  # type: ignore
-
-
-class OOD_LLR(OODBaseMixin[tf_models.PixelCNN]):
-    """
-    Likelihood Ratios based outlier detector.
-
-    Parameters
-    ----------
-    model : PixelCNN
-        Generative distribution model.
-    model_background : Optional[PixelCNN], default None
-        Optional model for the background. Only needed if it is different from `model`.
-    log_prob : Optional[Callable], default None
-        Function used to evaluate log probabilities under the model
-        if the model does not have a `log_prob` function.
-    sequential : bool, default False
-        Whether the data is sequential. Used to create targets during training.
-    """
-
-    def __init__(
-        self,
-        model: tf_models.PixelCNN,
-        model_background: tf_models.PixelCNN | None = None,
-        log_prob: Callable | None = None,
-        sequential: bool = False,
-    ) -> None:
-        self.dist_s: tf_models.PixelCNN = model
-        self.dist_b: tf_models.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: bool = hasattr(model, "log_prob")
-        self.sequential: bool = sequential
-        self.log_prob: Callable | None = log_prob
-
-        self._ref_score: OODScoreOutput
-        self._threshold_perc: float
-        self._data_info: tuple[tuple, type] | None = None
-
-    def fit(
-        self,
-        x_ref: ArrayLike,
-        threshold_perc: float = 100.0,
-        loss_fn: Callable | None = None,
-        optimizer: keras.optimizers.Optimizer | None = None,
-        epochs: int = 20,
-        batch_size: int = 64,
-        verbose: bool = True,
-        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:
-        """
-        Train semantic and background generative models.
-
-        Parameters
-        ----------
-        x_ref : ArrayLike
-            Training data.
-        threshold_perc : float, default 100.0
-            Percentage of reference data that is normal.
-        loss_fn : Callable | None, default None
-            Loss function used for training.
-        optimizer : keras.optimizers.Optimizer, default keras.optimizers.Adam
-            Optimizer used for training.
-        epochs : int, default 20
-            Number of training epochs.
-        batch_size : int, default 64
-            Batch size used for training.
-        verbose : bool, default True
-            Whether to print training progress.
-        mutate_fn : Callable, default mutate_categorical
-            Mutation function used to generate the background dataset.
-        mutate_fn_kwargs : dict, default {"rate": 0.2, "seed": 0, "feature_range": (0, 255)}
-            Kwargs for the mutation function used to generate the background dataset.
-            Default values set for an image dataset.
-        mutate_batch_size: int, default int(1e10)
-            Batch size used to generate the mutations for the background dataset.
-        """
-        x_ref = to_numpy(x_ref)
-        input_shape = x_ref.shape[1:]
-        optimizer = keras.optimizers.Adam() if optimizer is None else optimizer
-        # Separate into two separate optimizers, one for semantic model and one for background model
-        optimizer_s = optimizer
-        optimizer_b = optimizer.__class__.from_config(optimizer.get_config())
-
-        # training arguments
-        kwargs = {
-            "epochs": epochs,
-            "batch_size": batch_size,
-            "verbose": verbose,
-        }
-
-        # create background data
-        mutate_fn = partial(mutate_fn, **mutate_fn_kwargs)
-        X_back = predict_batch(x_ref, mutate_fn, batch_size=mutate_batch_size, dtype=x_ref.dtype)  # type: ignore
-
-        # prepare sequential data
-        if self.sequential and not self.has_log_prob:
-            y, y_back = x_ref[:, 1:], X_back[:, 1:]  # type: ignore
-            X, X_back = x_ref[:, :-1], X_back[:, :-1]  # type: ignore
-        else:
-            X = x_ref
-            y, y_back = None, None
-
-        # check if model needs to be built
-        use_build = self.has_log_prob and not isinstance(self.dist_s, keras.Model)
-
-        if use_build:
-            # build and train semantic model
-            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: 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:
-            # train semantic model
-            args = [self.dist_s, X]
-            kwargs.update({"y_train": y, "loss_fn": loss_fn, "optimizer": optimizer_s})
-            trainer(*args, **kwargs)
-
-            # train background model
-            args = [self.dist_b, X_back]
-            kwargs.update({"y_train": y_back, "loss_fn": loss_fn, "optimizer": optimizer_b})
-            trainer(*args, **kwargs)
-
-        self._datainfo = self._get_data_info(x_ref)
-        self._ref_score = self.score(x_ref, batch_size=batch_size)
-        self._threshold_perc = threshold_perc
-
-    def _logp(
-        self,
-        dist,
-        X: NDArray,
-        return_per_feature: bool = False,
-        batch_size: int = int(1e10),
-    ) -> NDArray:
-        """
-        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
-        return predict_batch(X, logp_fn, batch_size=batch_size)  # type: ignore[return-value]
-
-    def _logp_alt(
-        self,
-        model: keras.Model,
-        X: NDArray,
-        return_per_feature: bool = False,
-        batch_size: int = int(1e10),
-    ) -> NDArray:
-        """
-        Compute log probability of a batch of instances with the user defined log_prob function.
-        """
-        if self.sequential:
-            y, X = X[:, 1:], X[:, :-1]
-        else:
-            y = X.copy()
-        y_preds = predict_batch(X, model, batch_size=batch_size)
-        logp = self.log_prob(y, y_preds).numpy()  # type: ignore
-        if return_per_feature:
-            return logp
-        else:
-            axis = tuple(np.arange(len(logp.shape))[1:])
-            return np.mean(logp, axis=axis)
-
-    def _llr(self, X: NDArray, return_per_feature: bool, batch_size: int = int(1e10)) -> NDArray:
-        """
-        Compute likelihood ratios.
-
-        Parameters
-        ----------
-        X
-            Batch of instances.
-        return_per_feature
-            Return likelihood ratio per feature.
-        batch_size
-            Batch size for the :term:`generative model<Generative Model>` evaluations.
-
-        Returns
-        -------
-        Likelihood ratios.
-        """
-        logp_fn = self._logp if not isinstance(self.log_prob, Callable) else self._logp_alt  # type: ignore
-        logp_s = logp_fn(self.dist_s, X, return_per_feature=return_per_feature, batch_size=batch_size)
-        logp_b = logp_fn(self.dist_b, X, return_per_feature=return_per_feature, batch_size=batch_size)
-        return logp_s - logp_b
-
-    def _score(
-        self,
-        X: ArrayLike,
-        batch_size: int = int(1e10),
-    ) -> OODScoreOutput:
-        self._validate(X := to_numpy(X))
-        fscore = -self._llr(X, True, batch_size=batch_size)
-        iscore = -self._llr(X, False, batch_size=batch_size)
-        return OODScoreOutput(iscore, fscore)