oodeel 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

oodeel/methods/gen.py

@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+# Copyright IRT Antoine de Saint Exupéry et Université Paul Sabatier Toulouse III - All
+# rights reserved. DEEL is a research program operated by IVADO, IRT Saint Exupéry,
+# CRIAQ and ANITI - https://www.deel.ai/
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+import numpy as np
+
+from ..types import DatasetType
+from ..types import TensorType
+from ..types import Tuple
+from .base import OODBaseDetector
+
+
+class GEN(OODBaseDetector):
+    """
+    Generalized Entropy method for OOD detection.
+    "GEN: Pushing the Limits of Softmax-Based Out-of-Distribution Detection"
+    https://openaccess.thecvf.com/content/CVPR2023/html/Liu_GEN_Pushing_the_Limits_of_Softmax-Based_Out-of-Distribution_Detection_CVPR_2023_paper.html,
+
+    Args:
+        gamma (float): parameter for the generalized entropy. Must be between 0 and 1.
+            Defaults to 0.1.
+        k (int): number of softmax values to keep for the entropy computation. Only the
+            top-k softmax probabilities will be used. Defaults to 100.
+        use_react (bool): if true, apply ReAct method by clipping penultimate
+            activations under a threshold value.
+        react_quantile (Optional[float]): q value in the range [0, 1] used to compute
+            the react clipping threshold defined as the q-th quantile penultimate layer
+            activations. Defaults to 0.8.
+    """
+
+    def __init__(
+        self,
+        gamma: float = 0.1,
+        k: int = 100,
+        use_react: bool = False,
+        use_scale: bool = False,
+        use_ash: bool = False,
+        react_quantile: float = 0.8,
+        scale_percentile: float = 0.85,
+        ash_percentile: float = 0.90,
+    ):
+        super().__init__(
+            use_react=use_react,
+            use_scale=use_scale,
+            use_ash=use_ash,
+            react_quantile=react_quantile,
+            scale_percentile=scale_percentile,
+            ash_percentile=ash_percentile,
+        )
+        self.gamma = gamma
+        self.k = k
+
+    def _score_tensor(self, inputs: TensorType) -> Tuple[np.ndarray]:
+        """
+        Computes an OOD score for input samples "inputs" based on
+        the distance to nearest neighbors in the feature space of self.model
+
+        Args:
+            inputs: input samples to score
+
+        Returns:
+            Tuple[np.ndarray]: scores, logits
+        """
+
+        _, logits = self.feature_extractor.predict_tensor(inputs)
+        probs = self.op.softmax(logits)
+        probs = self.op.convert_to_numpy(probs)
+        probs = np.sort(probs)[:, -self.k :]  # Keep the k largest probabilities
+        scores = np.sum(probs**self.gamma * (1 - probs) ** (self.gamma), axis=-1)
+        return scores
+
+    def _fit_to_dataset(self, fit_dataset: DatasetType) -> None:
+        """
+        Fits the OOD detector to fit_dataset.
+
+        Args:
+            fit_dataset: dataset to fit the OOD detector on
+        """
+        pass
+
+    @property
+    def requires_to_fit_dataset(self) -> bool:
+        """
+        Whether an OOD detector needs a `fit_dataset` argument in the fit function.
+
+        Returns:
+            bool: True if `fit_dataset` is required else False.
+        """
+        return False
+
+    @property
+    def requires_internal_features(self) -> bool:
+        """
+        Whether an OOD detector acts on internal model features.
+
+        Returns:
+            bool: True if the detector perform computations on an intermediate layer
+            else False.
+        """
+        return False

oodeel/methods/gram.py

@@ -76,7 +76,7 @@ class Gram(OODBaseDetector):
 
     def __init__(
         self,
-        orders: List[int] = [i for i in range(1, 11)],
+        orders: List[int] = [i for i in range(1, 6)],
         quantile: float = 0.01,
     ):
         super().__init__()
@@ -90,6 +90,7 @@ class Gram(OODBaseDetector):
         self,
         fit_dataset: Union[TensorType, DatasetType],
         val_split: float = 0.2,
+        verbose: bool = False,
     ) -> None:
         """
         Compute the quantiles of channelwise correlations for each layer, power of
@@ -102,13 +103,19 @@ class Gram(OODBaseDetector):
                 construct the index with.
             val_split (float): The percentage of fit data to use as validation data for
                 normalization. Default to 0.2.
+            verbose (bool): Whether to print information during the fitting process.
+                Default to False.
         """
         self.postproc_fns = [
             self._stat for i in range(len(self.feature_extractor.feature_layers_id))
         ]
 
+        # fit_stats shape: [n_features, n_samples, n_orders, n_channels]
         fit_stats, info = self.feature_extractor.predict(
-            fit_dataset, postproc_fns=self.postproc_fns, return_labels=True
+            fit_dataset,
+            postproc_fns=self.postproc_fns,
+            return_labels=True,
+            verbose=verbose,
         )
         labels = info["labels"]
         self._classes = np.sort(np.unique(self.op.convert_to_numpy(labels)))
@@ -256,21 +263,25 @@ class Gram(OODBaseDetector):
                         (fm_s[0], fm_s[-1], -1),
                     )
                 else:
+                    # batch, channel, spatial
                     feature_map_p = self.op.reshape(
                         feature_map_p, (fm_s[0], fm_s[1], -1)
                     )
+                # batch, channel, channel
                 feature_map_p = self.op.matmul(
                     feature_map_p, self.op.permute(feature_map_p, (0, 2, 1))
                 )
+            # normalize the Gram matrix
             feature_map_p = self.op.sign(feature_map_p) * (
                 self.op.abs(feature_map_p) ** (1 / p)
             )
             # get the lower triangular part of the matrix
             feature_map_p = self.op.tril(feature_map_p)
-            # directly sum row-wise (to limit computational burden)
+            # directly sum row-wise (to limit computational burden) -> batch, channel
             feature_map_p = self.op.sum(feature_map_p, dim=2)
             # stat.append(self.op.t(feature_map_p))
             stat.append(feature_map_p)
+        # batch, n_orders, channel
         stat = self.op.stack(stat, 1)
         return stat
 
@@ -293,4 +304,4 @@ class Gram(OODBaseDetector):
             bool: True if the detector perform computations on an intermediate layer
             else False.
         """
-        return False
+        return True

oodeel/methods/mahalanobis.py

@@ -55,7 +55,7 @@ class Mahalanobis(OODBaseDetector):
             fit_dataset (Union[TensorType, DatasetType]): input dataset (ID)
         """
         # extract features and labels
-        features, infos = self.feature_extractor.predict(fit_dataset)
+        features, infos = self.feature_extractor.predict(fit_dataset, detach=True)
         labels = infos["labels"]
 
         # unique sorted classes
@@ -63,22 +63,24 @@ class Mahalanobis(OODBaseDetector):
 
         # compute mus and covs
         mus = dict()
-        covs = dict()
+        mean_cov = None
         for cls in self._classes:
             indexes = self.op.equal(labels, cls)
             _features_cls = self.op.flatten(features[0][indexes])
             mus[cls] = self.op.mean(_features_cls, dim=0)
             _zero_f_cls = _features_cls - mus[cls]
-            covs[cls] = (
+            cov_cls = (
                 self.op.matmul(self.op.t(_zero_f_cls), _zero_f_cls)
                 / _zero_f_cls.shape[0]
             )
+            if mean_cov is None:
+                mean_cov = (len(_features_cls) / len(features[0])) * cov_cls
+            else:
+                mean_cov += (len(_features_cls) / len(features[0])) * cov_cls
 
-        # mean cov and its inverse
-        mean_cov = self.op.mean(self.op.stack(list(covs.values())), dim=0)
-
-        self._mus = mus
+        # pseudo-inverse of the mean covariance matrix
         self._pinv_cov = self.op.pinv(mean_cov)
+        self._mus = mus
 
     def _score_tensor(self, inputs: TensorType) -> Tuple[np.ndarray]:
         """

oodeel/methods/mls.py

@@ -53,11 +53,19 @@ class MLS(OODBaseDetector):
         self,
         output_activation: str = "linear",
         use_react: bool = False,
+        use_scale: bool = False,
+        use_ash: bool = False,
         react_quantile: float = 0.8,
+        scale_percentile: float = 0.85,
+        ash_percentile: float = 0.90,
     ):
         super().__init__(
             use_react=use_react,
+            use_scale=use_scale,
+            use_ash=use_ash,
             react_quantile=react_quantile,
+            scale_percentile=scale_percentile,
+            ash_percentile=ash_percentile,
         )
         self.output_activation = output_activation
 

oodeel/methods/odin.py

@@ -48,12 +48,20 @@ class ODIN(OODBaseDetector):
         temperature: float = 1000,
         noise: float = 0.014,
         use_react: bool = False,
+        use_scale: bool = False,
+        use_ash: bool = False,
         react_quantile: float = 0.8,
+        scale_percentile: float = 0.85,
+        ash_percentile: float = 0.90,
     ):
         self.temperature = temperature
         super().__init__(
             use_react=use_react,
+            use_scale=use_scale,
+            use_ash=use_ash,
             react_quantile=react_quantile,
+            scale_percentile=scale_percentile,
+            ash_percentile=ash_percentile,
         )
         self.noise = noise
 

oodeel/methods/rmds.py

@@ -0,0 +1,122 @@
+# -*- coding: utf-8 -*-
+# Copyright IRT Antoine de Saint Exupéry et Université Paul Sabatier Toulouse III - All
+# rights reserved. DEEL is a research program operated by IVADO, IRT Saint Exupéry,
+# CRIAQ and ANITI - https://www.deel.ai/
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+import numpy as np
+
+from ..types import DatasetType
+from ..types import TensorType
+from ..types import Tuple
+from oodeel.methods.mahalanobis import Mahalanobis
+
+
+class RMDS(Mahalanobis):
+    """
+    "A Simple Fix to Mahalanobis Distance for Improving Near-OOD Detection"
+    https://arxiv.org/abs/2106.09022
+
+    Args:
+        eps (float): magnitude for gradient based input perturbation.
+            Defaults to 0.02.
+    """
+
+    def __init__(self, eps: float = 0.002):
+        super().__init__(eps=eps)
+
+    def _fit_to_dataset(self, fit_dataset: DatasetType) -> None:
+        """
+        Constructs the per class means and the covariance matrix,
+        as well as the background mean and covariance matrix,
+        from ID data "fit_dataset".
+        The means and pseudo-inverses of the covariance matrices
+        will be used for RMDS score computation.
+
+        Args:
+            fit_dataset (Union[TensorType, DatasetType]): input dataset (ID)
+        """
+        # means and pseudo-inverse of the mean convariance matrix from Mahalanobis
+        super()._fit_to_dataset(fit_dataset)
+
+        # extract features
+        features, _ = self.feature_extractor.predict(fit_dataset)
+
+        # compute background mu and cov
+        _features_bg = self.op.flatten(features[0])
+        mu_bg = self.op.mean(_features_bg, dim=0)
+        _zero_f_bg = _features_bg - mu_bg
+        cov_bg = self.op.matmul(self.op.t(_zero_f_bg), _zero_f_bg) / _zero_f_bg.shape[0]
+
+        # background mu and pseudo-inverse of the mean covariance matrices
+        self._mu_bg = mu_bg
+        self._pinv_cov_bg = self.op.pinv(cov_bg)
+
+    def _score_tensor(self, inputs: TensorType) -> Tuple[np.ndarray]:
+        """
+        Computes an OOD score for input samples "inputs" based on the RMDS
+        distance with respect to the closest class-conditional Gaussian distribution,
+        and the background distribution.
+
+        Args:
+            inputs (TensorType): input samples
+
+        Returns:
+            Tuple[np.ndarray]: scores, logits
+        """
+        # input preprocessing (perturbation)
+        if self.eps > 0:
+            inputs_p = self._input_perturbation(inputs)
+        else:
+            inputs_p = inputs
+
+        # mahalanobis score on perturbed inputs
+        features_p, _ = self.feature_extractor.predict_tensor(inputs_p)
+        features_p = self.op.flatten(features_p[0])
+        gaussian_score_p = self._mahalanobis_score(features_p)
+
+        # background score on perturbed inputs
+        gaussian_score_bg = self._background_score(features_p)
+
+        # take the highest score for each sample
+        gaussian_score_corrected = self.op.max(
+            gaussian_score_p - gaussian_score_bg, dim=1
+        )
+        return -self.op.convert_to_numpy(gaussian_score_corrected)
+
+    def _background_score(self, out_features: TensorType) -> TensorType:
+        """
+        Mahalanobis distance-based background score. For each test sample, it computes
+        the log of the probability densities of some observations (assuming a
+        normal distribution) using the mahalanobis distance with respect to the
+        background distribution.
+
+        Args:
+            out_features (TensorType): test samples features
+
+        Returns:
+            TensorType: confidence scores (with respect to the background distribution)
+        """
+        zero_f = out_features - self._mu_bg
+        # gaussian log prob density (mahalanobis)
+        log_probs_f = -0.5 * self.op.diag(
+            self.op.matmul(self.op.matmul(zero_f, self._pinv_cov_bg), self.op.t(zero_f))
+        )
+        gaussian_score = self.op.reshape(log_probs_f, (-1, 1))
+        return gaussian_score

oodeel/methods/she.py

@@ -0,0 +1,197 @@
+# -*- coding: utf-8 -*-
+# Copyright IRT Antoine de Saint Exupéry et Université Paul Sabatier Toulouse III - All
+# rights reserved. DEEL is a research program operated by IVADO, IRT Saint Exupéry,
+# CRIAQ and ANITI - https://www.deel.ai/
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+import numpy as np
+
+from ..types import DatasetType
+from ..types import TensorType
+from ..types import Union
+from .base import OODBaseDetector
+
+
+class SHE(OODBaseDetector):
+    """
+    "Out-of-Distribution Detection based on In-Distribution Data Patterns Memorization
+    with Modern Hopfield Energy"
+    [link](https://openreview.net/forum?id=KkazG4lgKL)
+
+    This method first computes the mean of the internal layer representation of ID data
+    for each ID class. This mean is seen as the average of the ID activation patterns
+    as defined in the original paper.
+    The method then returns the maximum value of the dot product between the internal
+    layer representation of the input and the average patterns, which is a simplified
+    version of Hopfield energy as defined in the original paper.
+
+    Remarks:
+    *   An input perturbation is applied in the same way as in Mahalanobis score
+    *   The original paper only considers the penultimate layer of the neural
+    network, while we aggregate the results of multiple layers after normalizing by
+    the dimension of each vector (the activation vector for dense layers, and the
+    average pooling of the feature map for convolutional layers).
+
+    Args:
+        eps (float): magnitude for gradient based input perturbation.
+            Defaults to 0.0014.
+    """
+
+    def __init__(
+        self,
+        eps: float = 0.0014,
+    ):
+        super().__init__()
+        self.eps = eps
+        self.postproc_fns = None
+
+    def _postproc_feature_maps(self, feature_map):
+        if len(feature_map.shape) > 2:
+            feature_map = self.op.avg_pool_2d(feature_map)
+        return self.op.flatten(feature_map)
+
+    def _fit_to_dataset(
+        self,
+        fit_dataset: Union[TensorType, DatasetType],
+    ) -> None:
+        """
+        Compute the means of the input dataset in the activation space of the selected
+        layers. The means are computed for each class in the dataset.
+
+        Args:
+            fit_dataset (Union[TensorType, DatasetType]): input dataset (ID) to
+                construct the index with.
+            ood_dataset (Union[TensorType, DatasetType]): OOD dataset to tune the
+                aggregation coefficients.
+        """
+        self.postproc_fns = [
+            self._postproc_feature_maps
+            for i in range(len(self.feature_extractor.feature_layers_id))
+        ]
+
+        features, infos = self.feature_extractor.predict(
+            fit_dataset, postproc_fns=self.postproc_fns
+        )
+
+        labels = infos["labels"]
+        preds = self.op.argmax(infos["logits"], dim=-1)
+        preds = self.op.convert_to_numpy(preds)
+
+        # unique sorted classes
+        self._classes = np.sort(np.unique(self.op.convert_to_numpy(labels)))
+        labels = self.op.convert_to_numpy(labels)
+
+        self._mus = list()
+        for feature in features:
+            mus_f = list()
+            for cls in self._classes:
+                indexes = np.equal(labels, cls) & np.equal(preds, cls)
+                _features_cls = feature[indexes]
+                mus_f.append(
+                    self.op.unsqueeze(self.op.mean(_features_cls, dim=0), dim=0)
+                )
+            self._mus.append(self.op.permute(self.op.cat(mus_f), (1, 0)))
+
+    def _score_tensor(self, inputs: TensorType) -> np.ndarray:
+        """
+        Computes an OOD score for input samples "inputs" based on
+        the aggregation of neural mean discrepancies from different layers.
+
+        Args:
+            inputs: input samples to score
+
+        Returns:
+            scores
+        """
+
+        inputs_p = self._input_perturbation(inputs)
+        features, logits = self.feature_extractor.predict_tensor(
+            inputs_p, postproc_fns=self.postproc_fns
+        )
+
+        scores = self._get_she_output(features)
+
+        return -self.op.convert_to_numpy(scores)
+
+    def _get_she_output(self, features):
+        scores = None
+        for feature, mus_f in zip(features, self._mus):
+            she = self.op.matmul(self.op.squeeze(feature), mus_f) / feature.shape[1]
+            she = self.op.max(she, dim=1)
+            scores = she if scores is None else she + scores
+        return scores
+
+    def _input_perturbation(self, inputs: TensorType) -> TensorType:
+        """
+        Apply small perturbation on inputs to make the in- and out- distribution
+        samples more separable.
+
+        Args:
+            inputs (TensorType): input samples
+
+        Returns:
+            TensorType: Perturbed inputs
+        """
+
+        def __loss_fn(inputs: TensorType) -> TensorType:
+            """
+            Loss function for the input perturbation.
+
+            Args:
+                inputs (TensorType): input samples
+
+            Returns:
+                TensorType: loss value
+            """
+            # extract features
+            out_features, _ = self.feature_extractor.predict(
+                inputs, detach=False, postproc_fns=self.postproc_fns
+            )
+            # get mahalanobis score for the class maximizing it
+            she_score = self._get_she_output(out_features)
+            log_probs_f = self.op.log(she_score)
+            return self.op.mean(log_probs_f)
+
+        # compute gradient
+        gradient = self.op.gradient(__loss_fn, inputs)
+        gradient = self.op.sign(gradient)
+
+        inputs_p = inputs - self.eps * gradient
+        return inputs_p
+
+    @property
+    def requires_to_fit_dataset(self) -> bool:
+        """
+        Whether an OOD detector needs a `fit_dataset` argument in the fit function.
+
+        Returns:
+            bool: True if `fit_dataset` is required else False.
+        """
+        return True
+
+    @property
+    def requires_internal_features(self) -> bool:
+        """
+        Whether an OOD detector acts on internal model features.
+
+        Returns:
+            bool: True if the detector perform computations on an intermediate layer
+            else False.
+        """
+        return True

oodeel/methods/vim.py

@@ -61,7 +61,7 @@ class VIM(OODBaseDetector):
         pca_origin (str): either "pseudo" for using $W^{-1}b$ where $W^{-1}$ is
             the pseudo inverse of the final linear layer applied to bias term
             (as in the VIM paper), or "center" for using the mean of the data in
-            feature space. Defaults to "center".
+            feature space. Defaults to "pseudo".
     """
 
     def __init__(

oodeel/preprocess/__init__.py

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+# Copyright IRT Antoine de Saint Exupéry et Université Paul Sabatier Toulouse III - All
+# rights reserved. DEEL is a research program operated by IVADO, IRT Saint Exupéry,
+# CRIAQ and ANITI - https://www.deel.ai/
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+try:
+    from .tf_preprocess import TFRandomPatchPermutation
+except ImportError:
+    pass
+
+try:
+    from .torch_preprocess import TorchRandomPatchPermutation
+except ImportError:
+    pass