oodeel 0.4.0__py3-none-any.whl

oodeel/utils/general_utils.py

@@ -0,0 +1,97 @@
+# -*- 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.
+from ..types import Any
+from ..types import Callable
+
+
+def is_from(model_or_tensor: Any, framework: str) -> bool:
+    """Check whether a model or tensor belongs to a specific framework
+
+    Args:
+        model_or_tensor (Any): Neural network or Tensor
+        framework (str):  Model or tensor framework ("torch" | "keras" | "tensorflow")
+
+    Returns:
+        bool: Whether the model belongs to specified framework or not
+    """
+    keywords_list = []
+    class_parents = list(model_or_tensor.__class__.__mro__)
+    for class_id in class_parents:
+        class_list = str(class_id).split("'")[1].split(".")
+        for keyword in class_list:
+            keywords_list.append(keyword)
+
+    if framework == "huggingface":
+        framework = "transformers"
+
+    return framework in keywords_list
+
+
+def import_backend_specific_stuff(model: Callable):
+    """Get backend specific data handler, operator and feature extractor class.
+
+    Args:
+        model (Callable): a model (Keras or PyTorch) used to identify the backend.
+
+    Returns:
+        str: backend name
+        DataHandler: torch or tf data handler
+        Operator: torch or tf operator
+        FeatureExtractor: torch or tf feature extractor class
+    """
+    if is_from(model, "keras"):
+        from ..extractor.keras_feature_extractor import KerasFeatureExtractor
+        from ..datasets.tf_data_handler import TFDataHandler
+        from ..utils import TFOperator
+
+        backend = "tensorflow"
+        data_handler = TFDataHandler()
+        op = TFOperator()
+        FeatureExtractorClass = KerasFeatureExtractor
+
+    # For huggingface models, is_from(model, "torch") will also return True so
+    # it has to be checked before torch
+    elif is_from(model, "huggingface"):
+        from ..extractor.hf_torch_feature_extractor import HFTorchFeatureExtractor
+        from ..datasets.torch_data_handler import TorchDataHandler
+        from ..utils import TorchOperator
+
+        backend = "torch"
+        data_handler = TorchDataHandler()
+        op = TorchOperator(model)
+        FeatureExtractorClass = HFTorchFeatureExtractor
+
+    elif is_from(model, "torch"):
+        from ..extractor.torch_feature_extractor import TorchFeatureExtractor
+        from ..datasets.torch_data_handler import TorchDataHandler
+        from ..utils import TorchOperator
+
+        backend = "torch"
+        data_handler = TorchDataHandler()
+        op = TorchOperator(model)
+        FeatureExtractorClass = TorchFeatureExtractor
+
+    else:
+        raise NotImplementedError()
+
+    return backend, data_handler, op, FeatureExtractorClass

oodeel/utils/operator.py

@@ -0,0 +1,253 @@
+# -*- 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.
+from abc import ABC
+from abc import abstractmethod
+
+import numpy as np
+
+from ..types import Callable
+from ..types import List
+from ..types import Optional
+from ..types import TensorType
+from ..types import Union
+
+
+class Operator(ABC):
+    """Class to handle tensorflow and torch operations with a unified API"""
+
+    @staticmethod
+    @abstractmethod
+    def softmax(tensor: TensorType) -> TensorType:
+        """Softmax function along the last dimension"""
+        raise NotImplementedError()
+
+    @staticmethod
+    @abstractmethod
+    def argmax(tensor: TensorType, dim: Optional[int] = None) -> TensorType:
+        """Argmax function"""
+        raise NotImplementedError()
+
+    @staticmethod
+    @abstractmethod
+    def max(
+        tensor: TensorType, dim: Optional[int] = None, keepdim: bool = False
+    ) -> TensorType:
+        """Max function"""
+        raise NotImplementedError()
+
+    @staticmethod
+    @abstractmethod
+    def min(
+        tensor: TensorType, dim: Optional[int] = None, keepdim: bool = False
+    ) -> TensorType:
+        """Min function"""
+        raise NotImplementedError()
+
+    @staticmethod
+    @abstractmethod
+    def one_hot(tensor: TensorType, num_classes: int) -> TensorType:
+        """One hot function"""
+        raise NotImplementedError()
+
+    @staticmethod
+    @abstractmethod
+    def sign(tensor: TensorType) -> TensorType:
+        """Sign function"""
+        raise NotImplementedError()
+
+    @staticmethod
+    @abstractmethod
+    def CrossEntropyLoss(reduction: str = "mean"):
+        """Cross Entropy Loss from logits"""
+        raise NotImplementedError()
+
+    @staticmethod
+    @abstractmethod
+    def norm(tensor: TensorType, dim: Optional[int] = None) -> TensorType:
+        """Norm function"""
+        raise NotImplementedError()
+
+    @staticmethod
+    @abstractmethod
+    def matmul(tensor_1: TensorType, tensor_2: TensorType) -> TensorType:
+        """Matmul operation"""
+        raise NotImplementedError()
+
+    @staticmethod
+    @abstractmethod
+    def convert_to_numpy(tensor: TensorType) -> np.ndarray:
+        "Convert a tensor to a NumPy array"
+        raise NotImplementedError()
+
+    @staticmethod
+    @abstractmethod
+    def gradient(func: Callable, inputs: TensorType) -> TensorType:
+        """Compute gradients for a batch of samples.
+
+        Args:
+            func (Callable): Function used for computing gradient. Must be built with
+                differentiable operations only, and return a scalar.
+            inputs (Any): Input tensor wrt which the gradients are computed
+
+        Returns:
+            Gradients computed, with the same shape as the inputs.
+        """
+        raise NotImplementedError()
+
+    @staticmethod
+    @abstractmethod
+    def stack(tensors: List[TensorType], dim: int = 0) -> TensorType:
+        "Stack tensors along a new dimension"
+        raise NotImplementedError()
+
+    @staticmethod
+    @abstractmethod
+    def cat(tensors: List[TensorType], dim: int = 0) -> TensorType:
+        "Concatenate tensors in a given dimension"
+        raise NotImplementedError()
+
+    @staticmethod
+    @abstractmethod
+    def mean(tensor: TensorType, dim: Optional[int] = None) -> TensorType:
+        "Mean function"
+        raise NotImplementedError()
+
+    @staticmethod
+    @abstractmethod
+    def flatten(tensor: TensorType) -> TensorType:
+        "Flatten to 2D tensor (batch_size, -1)"
+        # Flatten the features to 2D (n_batch, n_features)
+        raise NotImplementedError()
+
+    @staticmethod
+    @abstractmethod
+    def from_numpy(arr: np.ndarray) -> TensorType:
+        "Convert a NumPy array to a tensor"
+        # TODO change dtype
+        raise NotImplementedError()
+
+    @staticmethod
+    @abstractmethod
+    def t(tensor: TensorType) -> TensorType:
+        "Transpose function for tensor of rank 2"
+        raise NotImplementedError()
+
+    @staticmethod
+    @abstractmethod
+    def permute(tensor: TensorType) -> TensorType:
+        "Transpose function for tensor of rank 2"
+        raise NotImplementedError()
+
+    @staticmethod
+    @abstractmethod
+    def diag(tensor: TensorType) -> TensorType:
+        "Diagonal function: return the diagonal of a 2D tensor"
+        raise NotImplementedError()
+
+    @staticmethod
+    @abstractmethod
+    def reshape(tensor: TensorType, shape: List[int]) -> TensorType:
+        "Reshape function"
+        raise NotImplementedError()
+
+    @staticmethod
+    @abstractmethod
+    def equal(tensor: TensorType, other: Union[TensorType, int, float]) -> TensorType:
+        "Computes element-wise equality"
+        raise NotImplementedError()
+
+    @staticmethod
+    @abstractmethod
+    def pinv(tensor: TensorType) -> TensorType:
+        "Computes the pseudoinverse (Moore-Penrose inverse) of a matrix."
+        raise NotImplementedError()
+
+    @staticmethod
+    @abstractmethod
+    def eigh(tensor: TensorType) -> TensorType:
+        "Computes the eigen decomposition of a self-adjoint matrix."
+        raise NotImplementedError()
+
+    @staticmethod
+    def quantile(tensor: TensorType, q: float, dim: int = None) -> TensorType:
+        "Computes the quantile of a tensor's components"
+        raise NotImplementedError()
+
+    @staticmethod
+    def relu(tensor: TensorType) -> TensorType:
+        "Apply relu to a tensor"
+        raise NotImplementedError()
+
+    @staticmethod
+    @abstractmethod
+    def einsum(equation: str, *tensors: TensorType) -> TensorType:
+        "Computes the einsum between tensors following equation"
+        raise NotImplementedError()
+
+    @staticmethod
+    @abstractmethod
+    def tril(tensor: TensorType, diagonal: int = 0) -> TensorType:
+        "Set the upper triangle of the matrix formed by the last two dimensions of"
+        "tensor to zero"
+        raise NotImplementedError()
+
+    @staticmethod
+    def sum(tensor: TensorType, dim: Union[tuple, list, int] = None) -> TensorType:
+        "sum along dim"
+        raise NotImplementedError()
+
+    @staticmethod
+    def unsqueeze(tensor: TensorType, dim: int) -> TensorType:
+        "unsqueeze/expand_dim along dim"
+        raise NotImplementedError()
+
+    @staticmethod
+    def squeeze(tensor: TensorType, dim: int = None) -> TensorType:
+        "squeeze along dim"
+        raise NotImplementedError()
+
+    @staticmethod
+    def abs(tensor: TensorType) -> TensorType:
+        "compute absolute value"
+        raise NotImplementedError()
+
+    @staticmethod
+    def where(
+        condition: TensorType,
+        input: Union[TensorType, float],
+        other: Union[TensorType, float],
+    ) -> TensorType:
+        "Applies where function to condition"
+        raise NotImplementedError()
+
+    @staticmethod
+    @abstractmethod
+    def avg_pool_2d(tensor: TensorType) -> TensorType:
+        """Perform avg pool in 2d as in torch.nn.functional.adaptive_avg_pool2d"""
+        raise NotImplementedError()
+
+    @staticmethod
+    @abstractmethod
+    def log(tensor: TensorType) -> TensorType:
+        """Perform log"""
+        raise NotImplementedError()

oodeel/utils/tf_operator.py

@@ -0,0 +1,269 @@
+# -*- 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
+import tensorflow as tf
+import tensorflow_probability as tfp
+
+from ..types import Callable
+from ..types import List
+from ..types import Optional
+from ..types import TensorType
+from ..types import Union
+from .general_utils import is_from
+from .operator import Operator
+
+
+def sanitize_input(tensor_arg_func: Callable):
+    """ensures the decorated function receives a tf.Tensor"""
+
+    def wrapper(obj, tensor, *args, **kwargs):
+        if isinstance(tensor, tf.Tensor):
+            pass
+        elif is_from(tensor, "torch"):
+            tensor = tf.convert_to_tensor(tensor.numpy())
+        else:
+            tensor = tf.convert_to_tensor(tensor)
+
+        return tensor_arg_func(obj, tensor, *args, **kwargs)
+
+    return wrapper
+
+
+class TFOperator(Operator):
+    """Class to handle tensorflow operations with a unified API"""
+
+    @staticmethod
+    def softmax(tensor: TensorType) -> tf.Tensor:
+        """Softmax function along the last dimension"""
+        return tf.keras.activations.softmax(tensor, axis=-1)
+
+    @staticmethod
+    def argmax(tensor: TensorType, dim: Optional[int] = None) -> tf.Tensor:
+        """Argmax function"""
+        if dim is None:
+            return tf.argmax(tf.reshape(tensor, [-1]))
+        return tf.argmax(tensor, axis=dim)
+
+    @staticmethod
+    def max(
+        tensor: TensorType, dim: Optional[int] = None, keepdim: bool = False
+    ) -> tf.Tensor:
+        """Max function"""
+        return tf.reduce_max(tensor, axis=dim, keepdims=keepdim)
+
+    @staticmethod
+    def min(
+        tensor: TensorType, dim: Optional[int] = None, keepdim: bool = False
+    ) -> tf.Tensor:
+        """Min function"""
+        return tf.reduce_min(tensor, axis=dim, keepdims=keepdim)
+
+    @staticmethod
+    def one_hot(tensor: TensorType, num_classes: int) -> tf.Tensor:
+        """One hot function"""
+        return tf.one_hot(tensor, num_classes)
+
+    @staticmethod
+    def sign(tensor: TensorType) -> tf.Tensor:
+        """Sign function"""
+        return tf.sign(tensor)
+
+    @staticmethod
+    def CrossEntropyLoss(reduction: str = "mean"):
+        """Cross Entropy Loss from logits"""
+
+        tf_reduction = {"mean": "sum_over_batch_size", "sum": "sum"}[reduction]
+
+        def sanitized_ce_loss(inputs, targets):
+            return tf.keras.losses.SparseCategoricalCrossentropy(
+                from_logits=True, reduction=tf_reduction
+            )(targets, inputs)
+
+        return sanitized_ce_loss
+
+    @staticmethod
+    def norm(tensor: TensorType, dim: Optional[int] = None) -> tf.Tensor:
+        """Tensor Norm"""
+        return tf.norm(tensor, axis=dim)
+
+    @staticmethod
+    @tf.function
+    def matmul(tensor_1: TensorType, tensor_2: TensorType) -> tf.Tensor:
+        """Matmul operation"""
+        return tf.matmul(tensor_1, tensor_2)
+
+    @staticmethod
+    def convert_to_numpy(tensor: TensorType) -> np.ndarray:
+        """Convert tensor into a np.ndarray"""
+        if not isinstance(tensor, np.ndarray):
+            return tensor.numpy()
+        return tensor
+
+    @staticmethod
+    def gradient(func: Callable, inputs: tf.Tensor, *args, **kwargs) -> tf.Tensor:
+        """Compute gradients for a batch of samples.
+
+        Args:
+            func (Callable): Function used for computing gradient. Must be built with
+                tensorflow differentiable operations only, and return a scalar.
+            inputs (tf.Tensor): Input tensor wrt which the gradients are computed
+            *args: Additional Args for func.
+            **kwargs: Additional Kwargs for func.
+
+        Returns:
+            tf.Tensor: Gradients computed, with the same shape as the inputs.
+        """
+        with tf.GradientTape(watch_accessed_variables=False) as tape:
+            tape.watch(inputs)
+            outputs = func(inputs, *args, **kwargs)
+        return tape.gradient(outputs, inputs)
+
+    @staticmethod
+    def stack(tensors: List[TensorType], dim: int = 0) -> tf.Tensor:
+        "Stack tensors along a new dimension"
+        return tf.stack(tensors, dim)
+
+    @staticmethod
+    def cat(tensors: List[TensorType], dim: int = 0) -> tf.Tensor:
+        "Concatenate tensors in a given dimension"
+        return tf.concat(tensors, dim)
+
+    @staticmethod
+    def mean(tensor: TensorType, dim: Optional[int] = None) -> tf.Tensor:
+        "Mean function"
+        return tf.reduce_mean(tensor, dim)
+
+    @staticmethod
+    def flatten(tensor: TensorType) -> tf.Tensor:
+        "Flatten to 2D tensor of shape (tensor.shape[0], -1)"
+        # Flatten the features to 2D (n_batch, n_features)
+        return tf.reshape(tensor, shape=[tf.shape(tensor)[0], -1])
+
+    @staticmethod
+    def from_numpy(arr: np.ndarray) -> tf.Tensor:
+        "Convert a NumPy array to a tensor"
+        # TODO change dtype
+        return tf.convert_to_tensor(arr)
+
+    @staticmethod
+    def t(tensor: TensorType) -> tf.Tensor:
+        "Transpose function for tensor of rank 2"
+        return tf.transpose(tensor)
+
+    @staticmethod
+    def permute(tensor: TensorType, dims) -> tf.Tensor:
+        "Transpose function for tensor of rank 2"
+        return tf.transpose(tensor, dims)
+
+    @staticmethod
+    def diag(tensor: TensorType) -> tf.Tensor:
+        "Diagonal function: return the diagonal of a 2D tensor"
+        return tf.linalg.diag_part(tensor)
+
+    @staticmethod
+    def reshape(tensor: TensorType, shape: List[int]) -> tf.Tensor:
+        "Reshape function"
+        return tf.reshape(tensor, shape)
+
+    @staticmethod
+    def equal(tensor: TensorType, other: Union[TensorType, int, float]) -> tf.Tensor:
+        "Computes element-wise equality"
+        return tf.math.equal(tensor, other)
+
+    @staticmethod
+    def pinv(tensor: TensorType) -> tf.Tensor:
+        "Computes the pseudoinverse (Moore-Penrose inverse) of a matrix."
+        return tf.linalg.pinv(tensor)
+
+    @staticmethod
+    def eigh(tensor: TensorType) -> tf.Tensor:
+        "Computes the eigen decomposition of a self-adjoint matrix."
+        eigval, eigvec = tf.linalg.eigh(tensor)
+        return eigval, eigvec
+
+    @staticmethod
+    def quantile(tensor: TensorType, q: float, dim: int = None) -> tf.Tensor:
+        "Computes the quantile of a tensor's components. q in (0,1)"
+        q = tfp.stats.percentile(tensor, q * 100, axis=dim)
+        return float(q) if dim is None else q
+
+    @staticmethod
+    def relu(tensor: TensorType) -> tf.Tensor:
+        "Apply relu to a tensor"
+        return tf.nn.relu(tensor)
+
+    @staticmethod
+    def einsum(equation: str, *tensors: TensorType) -> tf.Tensor:
+        "Computes the einsum between tensors following equation"
+        return tf.einsum(equation, *tensors)
+
+    @staticmethod
+    def tril(tensor: TensorType, diagonal: int = 0) -> tf.Tensor:
+        "Set the upper triangle of the matrix formed by the last two dimensions of"
+        "tensor to zero"
+        return tf.experimental.numpy.tril(tensor, k=diagonal)
+
+    @staticmethod
+    def sum(tensor: TensorType, dim: Union[tuple, list, int] = None) -> tf.Tensor:
+        "sum along dim"
+        if tensor.dtype == tf.bool:
+            tensor = tf.cast(tensor, tf.float32)
+        return tf.reduce_sum(tensor, axis=dim)
+
+    @staticmethod
+    def unsqueeze(tensor: TensorType, dim: int) -> tf.Tensor:
+        "expand_dim along dim"
+        return tf.expand_dims(tensor, dim)
+
+    @staticmethod
+    def squeeze(tensor: TensorType, dim: int = None) -> tf.Tensor:
+        "expand_dim along dim"
+        return tf.squeeze(tensor, dim)
+
+    @staticmethod
+    def abs(tensor: TensorType) -> tf.Tensor:
+        "compute absolute value"
+        return tf.abs(tensor)
+
+    @staticmethod
+    def where(
+        condition: TensorType,
+        input: Union[TensorType, float],
+        other: Union[TensorType, float],
+    ) -> tf.Tensor:
+        "Applies where function to condition"
+        return tf.where(condition, input, other)
+
+    @staticmethod
+    def percentile(x, q):
+        return tfp.stats.percentile(x, q)
+
+    @staticmethod
+    def avg_pool_2d(tensor: TensorType) -> tf.Tensor:
+        """Perform avg pool in 2d as in torch.nn.functional.adaptive_avg_pool2d"""
+        return tf.reduce_mean(tensor, axis=(-3, -2))
+
+    @staticmethod
+    def log(tensor: TensorType) -> tf.Tensor:
+        """Perform log"""
+        return tf.math.log(tensor)