surrogates_interface 4.1.0__tar.gz → 4.1.2__tar.gz

{surrogates_interface-4.1.0 → surrogates_interface-4.1.2}/PKG-INFO

@@ -1,16 +1,15 @@
 Metadata-Version: 2.1
 Name: surrogates_interface
-Version: 4.1.0
+Version: 4.1.2
 Summary: Interface for surrogate models.
 Home-page: https://gitlab.windenergy.dtu.dk/surrogate-models/surrogate-models-interface
 License: MIT
 Author: DTU Wind and Energy Systems
 Maintainer: Riccardo Riva
 Maintainer-email: ricriv@dtu.dk
-Requires-Python: >=3.9,<3.12
+Requires-Python: >=3.10,<3.12
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Provides-Extra: code-style
@@ -20,24 +19,24 @@ Provides-Extra: smt
 Provides-Extra: test
 Provides-Extra: tf
 Provides-Extra: torch
-Requires-Dist: black ; extra == "code-style"
-Requires-Dist: codespell ; extra == "code-style"
-Requires-Dist: flake8 ; extra == "code-style"
-Requires-Dist: h5py
-Requires-Dist: isort ; extra == "code-style"
-Requires-Dist: matplotlib ; extra == "test" or extra == "smt"
+Requires-Dist: black (>=24.0.0,<25.0.0) ; extra == "code-style"
+Requires-Dist: codespell (>=2.0.0,<3.0.0) ; extra == "code-style"
+Requires-Dist: flake8 (>=7.0.0,<8.0.0) ; extra == "code-style"
+Requires-Dist: h5py (>=3.10.0,<4.0.0)
+Requires-Dist: isort (>=5.0.0,<6.0.0) ; extra == "code-style"
+Requires-Dist: keras (>=3.0.0,<4.0.0) ; extra == "tf" or extra == "torch"
+Requires-Dist: matplotlib (>=3.8.0,<4.0.0) ; extra == "test" or extra == "smt"
 Requires-Dist: numpy (>=1.10.0)
-Requires-Dist: numpydoc ; extra == "docs"
+Requires-Dist: numpydoc (>=1.8.0,<2.0.0) ; extra == "docs"
 Requires-Dist: openmdao (>=3.25,<4.0) ; extra == "docs" or extra == "test" or extra == "om"
 Requires-Dist: pydata-sphinx-theme ; extra == "docs"
-Requires-Dist: pytest ; extra == "test"
-Requires-Dist: pytest-cov ; extra == "test"
-Requires-Dist: pytest-testmon ; extra == "test"
-Requires-Dist: scikit-learn ; extra == "test" or extra == "smt" or extra == "tf"
+Requires-Dist: pytest (>=8.0.0,<9.0.0) ; extra == "test"
+Requires-Dist: pytest-cov (>=6.0.0,<7.0.0) ; extra == "test"
+Requires-Dist: scikit-learn (>=1.4.0,<2.0.0) ; extra == "test" or extra == "smt" or extra == "tf" or extra == "torch"
 Requires-Dist: smt (>=2.0.1,<3.0.0) ; extra == "test" or extra == "smt"
-Requires-Dist: sphinx ; extra == "docs"
+Requires-Dist: sphinx (>=8.0.0,<9.0.0) ; extra == "docs"
 Requires-Dist: sphinx-copybutton ; extra == "docs"
-Requires-Dist: sphinx-sitemap ; extra == "docs"
+Requires-Dist: sphinx-sitemap (>=2.0.0,<3.0.0) ; extra == "docs"
 Requires-Dist: sphinx_design ; extra == "docs"
 Requires-Dist: tensorflow (>=2.10.0,<3.0.0) ; extra == "test" or extra == "tf"
 Requires-Dist: tensorflow-intel (>=2.10.0,<3.0.0) ; (sys_platform == "win32") and (extra == "test" or extra == "tf")

{surrogates_interface-4.1.0 → surrogates_interface-4.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "surrogates_interface"
-version = "4.1.0"
+version = "4.1.2"
 description = "Interface for surrogate models."
 authors = ["DTU Wind and Energy Systems"]
 maintainers = [
@@ -16,25 +16,24 @@ generate-setup-file = false
 
 [tool.poetry.dependencies]
 
-python = ">=3.9,<3.12"
-numpy = ">=1.10.0"
-h5py = "*"
-black = {version="*", optional=true}
-flake8 = {version="*", optional=true}
-isort = {version="*", optional=true}
-codespell = {version="*", optional=true}
-pytest = {version="*", optional=true}
-pytest-cov = {version="*", optional=true}
-pytest-testmon = {version="*", optional=true}
+python = ">=3.10,<3.12"
+numpy = {version=">=1.10.0"}
+h5py = {version="^3.10.0"}
+black = {version="^24.0.0", optional=true}
+flake8 = {version="^7.0.0", optional=true}
+isort = {version="^5.0.0", optional=true}
+codespell = {version="^2.0.0", optional=true}
+pytest = {version="^8.0.0", optional=true}
+pytest-cov = {version="^6.0.0", optional=true}
 tomli = {version="^2.0.1", python="<3.11", optional=true}
-sphinx = {version="*", optional=true}
+sphinx = {version="^8.0.0", optional=true}
 pydata-sphinx-theme = {version="*", optional=true}
 sphinx-copybutton = {version="*", optional=true}
-sphinx-sitemap = {version="*", optional=true}
+sphinx-sitemap = {version="^2.0.0", optional=true}
 sphinx_design = {version="*", optional=true}
-numpydoc = {version="*", optional=true}
-matplotlib = {version="*", optional=true}
-scikit-learn = {version="*", optional=true}
+numpydoc = {version="^1.8.0", optional=true}
+matplotlib = {version="^3.8.0", optional=true}
+scikit-learn = {version="^1.4.0", optional=true}
 # The following configuration for TensorFlow seems to work on Windows and linux, as tested at
 # https://gitlab.windenergy.dtu.dk/surrogate-models/test-poetry-and-tensorflow
 tensorflow = {version = "^2.10.0", optional=true }
@@ -43,6 +42,7 @@ tensorflow-io-gcs-filesystem = [
     {version = "< 0.32.0", markers = "platform_system == 'Windows'", python=">=3.9,<3.12", optional=true}
 ]
 tensorflow-intel = {version="^2.10.0", platform = "win32", optional=true}
+keras = {version="^3.0.0", optional=true}
 smt = {version="^2.0.1", optional=true}
 openmdao = {version="^3.25", optional=true}
 torch = { version = "^2.0.0", optional=true }
@@ -67,7 +67,6 @@ code_style = ["black",
 test = ["matplotlib",  # Needed by SMT.
 	    "pytest",
 	    "pytest-cov",
-	    "pytest-testmon",
 	    "tomli",
 	    "scikit-learn",
 	    "smt",
@@ -87,11 +86,15 @@ tf = ["scikit-learn",
 	  "tensorflow",
 	  "tensorflow-io-gcs-filesystem",
 	  "tensorflow-intel",
+	  "keras",
 	  ]
 
 om = ["openmdao"]
 
-torch = ["torch"]
+torch = ["torch",
+         "scikit-learn",
+         "keras",
+		 ]
 
 
 

{surrogates_interface-4.1.0 → surrogates_interface-4.1.2}/surrogates_interface/openmdao.py

@@ -90,8 +90,8 @@ class SurrogateModelCompFD(om.ExplicitComponent):
         self.options.declare(
             "input_type",
             desc="""Type of the input.
-                                  - If `InputOutputType.JOINED` there will be only 1 input named `input_name`.
-                                  - If `InputOutputType.SPLIT` there will be 1 input per input channel. Their names will be taken from `model.input_names`.
+                                  - If `InputOutputType.JOINED` there will be only 1 input named `options["input_name"]`.
+                                  - If `InputOutputType.SPLIT` there will be 1 input per channel. Their names will be taken from `model.input_names`.
                                   """,
             check_valid=self._check_in_out_type,
         )
@@ -99,8 +99,8 @@ class SurrogateModelCompFD(om.ExplicitComponent):
         self.options.declare(
             "output_type",
             desc="""Type of the output.
-                               - If `InputOutputType.JOINED` there will be only 1 output named `output_name`.
-                               - If `InputOutputType.SPLIT` there will be 1 input per output channel. Their names will be taken from `model.output_names`.
+                               - If `InputOutputType.JOINED` there will be only 1 output named `options["output_name"]`.
+                               - If `InputOutputType.SPLIT` there will be 1 output per channel. Their names will be taken from `model.output_names`.
                                """,
             check_valid=self._check_in_out_type,
         )
@@ -150,13 +150,13 @@ class SurrogateModelCompFD(om.ExplicitComponent):
         ----------
         inputs : dict
             Inputs.
-              - If `input_type is InputOutputType.JOINED` we expect one input named `input_name` of shape `(n_points, n_inputs)`.
+              - If `input_type is InputOutputType.JOINED` we expect one input named `options["input_name"]` of shape `(n_points, n_inputs)`.
               - If `input_type is InputOutputType.SPLIT` we expect one input per feature of shape `(n_points,)`.
-                The inputs will be stacked according to `input_names`.
+                The inputs will be stacked according to `model.input_names`.
         outputs : dict
             Outputs.
-              - If `output_type is InputOutputType.JOINED` we expect one output named `output_name` of shape `(n_points, n_outputs)`.
-                The outputs will be stacked according to `output_names`.
+              - If `output_type is InputOutputType.JOINED` we expect one output named `options["output_name"]` of shape `(n_points, n_outputs)`.
+                The outputs will be stacked according to `model.output_names`.
               - If `output_type is InputOutputType.SPLIT` we expect one output per feature of shape `(n_points,)`.
 
         Returns
@@ -240,9 +240,9 @@ class SurrogateModelComp(SurrogateModelCompFD):
         ----------
         inputs : dict
             Inputs.
-              - If `input_type is InputOutputType.JOINED` we expect one input named `input_name` of shape `(n_points, n_inputs)`.
+              - If `input_type is InputOutputType.JOINED` we expect one input named `options["input_name"]` of shape `(n_points, n_inputs)`.
               - If `input_type is InputOutputType.SPLIT` we expect one input per feature of shape `(n_points,)`.
-                The inputs will be stacked according to `input_names`.
+                The inputs will be stacked according to `model.input_names`.
         partials : dict
             Jacobian.
               - If `output_type is InputOutputType.JOINED` we expect one Jacobian of shape `(n_points, n_outputs)`.

{surrogates_interface-4.1.0 → surrogates_interface-4.1.2}/surrogates_interface/surrogates.py

@@ -364,6 +364,10 @@ class SurrogateModel:
         .. math::
           \hat{y} =  g_1^{-1} \circ g_2^{-1} \circ \cdots \circ g_m^{-1} \circ \hat{\tilde{y}}
 
+        and by substitution we find
+
+        .. math::
+            \hat{y} =  g_1^{-1}(g_2^{-1}(g_m^{-1}(s(f_n(f_2(f_1(x)))))))
 
         Parameters
         ----------
@@ -419,9 +423,26 @@ class SurrogateModel:
         raise NotImplementedError()
 
     def predict_output_and_jacobian(self, x, *args, **kwargs):
-        """
+        r"""
         Predict the complete model output and Jacobian, including all input and output transformations.
 
+        Let's recall that the predicted output is given by
+        
+        .. math::
+            \hat{y} =  g_1^{-1}(g_2^{-1}(g_m^{-1}(s(f_n(f_2(f_1(x)))))))
+        
+        By indicating with :math:`J_h(z)` the Jacobian of :math:`h` evaluated at :math:`z`, we obtain
+        the Jacobian of the predicted output by applying the chain rule
+        
+        .. math::
+            J = &J_{g_1^{-1}}(g_2^{-1}(g_m^{-1}(s(f_n(f_2(f_1(x)))))))   \\
+                &J_{g_2^{-1}}(g_m^{-1}(s(f_n(f_2(f_1(x))))))   \\
+                &J_{g_m^{-1}}(s(f_n(f_2(f_1(x)))))   \\
+                &J_{s}(f_n(f_2(f_1(x))))   \\
+                &J_{f_n}(f_2(f_1(x)))
+                  J_{f_2}(f_1(x))
+                   J_{f_1}(x)
+
         Parameters
         ----------
         x : array-like of shape (n_points, n_inputs)
@@ -1030,48 +1051,51 @@ class SurrogateModelFamily:
 
 
 class PyTorchModel(SurrogateModel):
-    import torch
-    import torch._dynamo  # fmt: skip
-    torch._dynamo.config.suppress_errors = True
-    import torch.func as torch_func  # fmt: skip
+    """
+    Class that stores and evaluates an existing PyTorch model.
+    """
 
-    # from torch.func import jacfwd, jacrev, jvp, vjp, vmap  # fmt: skip
+    def __init__(self, *args, dtype=None, max_batch=50_000, **kwargs):
+        import torch
+        import torch._dynamo
 
-    def __init__(self, *args, dtype=torch.float16, max_batch=50_000, **kwargs):
+        torch._dynamo.config.suppress_errors = True
         super().__init__(*args, **kwargs)
         self.model.eval()
-        self.device = self.torch.device(
-            "cuda" if self.torch.cuda.is_available() else "cpu"
-        )
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
         self.model.to(self.device)
-        self.dtype = dtype
-        self.model.to(dtype)
+        self.dtype = torch.float16 if dtype is None else dtype
+        self.model.to(self.dtype)
         self.max_batch = max_batch
 
     def __to_numpy(self, _x):
+        import torch
+
         try:
             import cupy as cp
         except ImportError:  # pragma: no cover
             cp = np
-        lalib = (
-            cp if self.device == self.torch.device("cuda") else np
-        )  # pragma: no cover
+        lalib = cp if self.device == torch.device("cuda") else np  # pragma: no cover
         return lalib.asarray(_x).astype(lalib.float32)
 
     def __to_tensor(self, _x):
+        import torch
+
         if len(_x.shape) < 2:
             _x = _x.reshape(1, -1)
-        return self.torch.as_tensor(_x, device=self.device, dtype=self.dtype)
+        return torch.as_tensor(_x, device=self.device, dtype=self.dtype)
 
     def __record_in_dtype(self, _x):  # pragma: no cover
         # TODO: could be used to retain the input/output dtype the same
         self.in_dtype = _x.dtype
 
     def _predict_model_output(self, x):
+        import torch
+
         x = self.__to_tensor(x)
 
-        with self.torch.no_grad():
-            output = self.torch.zeros(
+        with torch.no_grad():
+            output = torch.zeros(
                 (x.shape[0], self.n_outputs),
                 device=self.device,
                 dtype=self.dtype,
@@ -1100,21 +1124,28 @@ class PyTorchModel(SurrogateModel):
         return self.__to_numpy(y)
 
     def _save_model(self, filepath):
-        self.torch.save(self.model.state_dict(), filepath)
+        import torch
+
+        torch.save(self.model.state_dict(), filepath)
 
     @staticmethod
     def _load_model(filepath, model_cls):
-        import torch  # fmt: skip
+        import torch
+
         model_cls.load_state_dict(torch.load(filepath, weights_only=True))
         return model_cls
 
     def _predict_model_jvp(self, x, dx):
+        import torch.func as torch_func
+
         if not hasattr(self, "batched_jvp_func"):
             def g(_x):  # fmt: skip
                 return self.model(_x)
-            def single_jvp(_x, _v):  # fmt: skip
-                return self.torch_func.jvp(g, (_x,), (_v,))
-            self.batched_jvp_func = self.torch_func.vmap(single_jvp)
+
+            def single_jvp(_x, _v):
+                return torch_func.jvp(g, (_x,), (_v,))
+
+            self.batched_jvp_func = torch_func.vmap(single_jvp)
 
         x = self.__to_tensor(x)
         dx = self.__to_tensor(dx)
@@ -1122,13 +1153,17 @@ class PyTorchModel(SurrogateModel):
         return self.__to_numpy(output.detach()), self.__to_numpy(jvp_res.detach())
 
     def _predict_model_vjp(self, x, dy):
+        import torch.func as torch_func
+
         if not hasattr(self, "batched_vjp_func"):
             def g(_x):  # fmt: skip
                 return self.model(_x)
-            def single_vjp(_x, _v):  # fmt: skip
-                out, f = self.torch_func.vjp(g, _x)
+
+            def single_vjp(_x, _v):
+                out, f = torch_func.vjp(g, _x)
                 return out, f(_v)
-            self.batched_vjp_func = self.torch_func.vmap(single_vjp)
+
+            self.batched_vjp_func = torch_func.vmap(single_vjp)
 
         x = self.__to_tensor(x)
         dy = self.__to_tensor(dy)
@@ -1136,49 +1171,50 @@ class PyTorchModel(SurrogateModel):
         return self.__to_numpy(output.detach()), self.__to_numpy(vjp_res[0].detach())
 
     def _predict_model_output_and_jacobian_fwd(self, x):
+        import torch.func as torch_func
+
         if not hasattr(self, "y_jac_fwd_func"):
             def g(_x):  # fmt: skip
                 result = self.model(_x)
                 return (result, result)
-            self.y_jac_fwd_func = self.torch_func.vmap(
-                self.torch_func.jacfwd(g, has_aux=True)
-            )
+            self.y_jac_fwd_func = torch_func.vmap(torch_func.jacfwd(g, has_aux=True))
 
         x = self.__to_tensor(x)
         jac, output = self.y_jac_fwd_func(x)
         return self.__to_numpy(output.detach()), self.__to_numpy(jac.detach())
 
     def _predict_model_output_and_jacobian_rev(self, x):
+        import torch.func as torch_func
+
         if not hasattr(self, "y_jac_rev_func"):
             def g(_x):  # fmt: skip
                 result = self.model(_x)
                 return (result, result)
-            self.y_jac_rev_func = self.torch_func.vmap(
-                self.torch_func.jacrev(g, has_aux=True)
-            )
+            self.y_jac_rev_func = torch_func.vmap(torch_func.jacrev(g, has_aux=True))
 
         x = self.__to_tensor(x)
         jac, output = self.y_jac_rev_func(x)
         return self.__to_numpy(output.detach()), self.__to_numpy(jac.detach())
 
     def _predict_model_jacobian_sbatch(self, x):  # pragma: no cover
-        """Not used for now, but left as a reference for future if GPU memory issues arise."""
+        # Not used for now, but left as a reference for future if GPU memory issues arise.
+        import torch
+        import torch.func as torch_func
+
         if not hasattr(self, "y_jac_func"):
             def g(_x):  # fmt: skip
                 result = self.model(_x)
                 return (result, result)
-            self.y_jac_func = self.torch_func.vmap(
-                self.torch_func.jacrev(g, has_aux=True)
-            )
+            self.y_jac_func = torch_func.vmap(torch_func.jacrev(g, has_aux=True))
 
         x = self.__to_tensor(x)
         batch_size = x.shape[0]
-        y = self.torch.zeros(
+        y = torch.zeros(
             (batch_size, self.n_outputs),
             device=self.device,
             dtype=self.dtype,
         )
-        jac = self.torch.zeros(
+        jac = torch.zeros(
             (batch_size, self.n_outputs, self.n_inputs),
             device=self.device,
             dtype=self.dtype,

{surrogates_interface-4.1.0 → surrogates_interface-4.1.2}/surrogates_interface/transformers.py

@@ -125,7 +125,7 @@ class GainOffsetScaler(Transformer):
         x : array-like of shape (n_points, n_features)
             Input data that will be transformed.
         inplace : bool
-            `True` if the transformation must happen inplace. Same behavior of the `copy` attribute in scikit-learn.
+            `True` if the transformation must happen inplace, which means that no additional memory is allocated.
 
         Returns
         -------
@@ -147,7 +147,7 @@ class GainOffsetScaler(Transformer):
         x : array-like of shape (n_points, n_features)
             Input data that will be transformed.
         inplace : bool
-            True if the transformation must happen inplace. Same behavior of the `copy` attribute in scikit-learn.
+            `True` if the transformation must happen inplace, which means that no additional memory is allocated.
 
         Returns
         -------
@@ -173,6 +173,7 @@ class GainOffsetScaler(Transformer):
         -------
         y : array-like of shape (n_points, n_features)
             Gradient of the direct transformation evaluated on the input data.
+            Since all features are independent, the gradient is stored in compact form.
             Warning: a read-only view is returned.
         """
         y = np.broadcast_to(self.gain_, x.shape)
@@ -190,6 +191,7 @@ class GainOffsetScaler(Transformer):
         -------
         y : array-like of shape (n_points, n_features)
             Gradient of the inverse transformation evaluated on the input data.
+            Since all features are independent, the gradient is stored in compact form.
             Warning: a read-only view is returned.
         """
         y = np.broadcast_to(self.inv_gain_, x.shape)
@@ -344,7 +346,7 @@ class PCA(Transformer):
         x : ndarray of shape (n_points, n_features)
             Input data that will be transformed.
         inplace : bool, optional
-            Must be `False`. Although it would be possible to to update the first `n_components` columns of `x`,
+            Must be `False`. Although it would be possible to update the first `n_components` columns of `x`,
             we choose to not do it, so that `predict_output()` can be supported more easily.
 
         Returns
@@ -527,7 +529,7 @@ class PowerTransformerYeoJohnson(Transformer):
         x : array-like of shape (n_points, n_features)
             Input data that will be transformed.
         inplace : bool
-            `True` if the transformation must happen inplace. Same behavior of the `copy` attribute in scikit-learn.
+            `True` if the transformation must happen inplace, which means that no additional memory is allocated.
 
         Returns
         -------
@@ -627,7 +629,7 @@ class PowerTransformerYeoJohnson(Transformer):
         x : array-like of shape (n_points, n_features)
             Input data that will be transformed.
         inplace : bool
-            True if the transformation must happen inplace. Same behavior of the `copy` attribute in scikit-learn.
+            `True` if the transformation must happen inplace, which means that no additional memory is allocated.
 
         Returns
         -------
@@ -726,6 +728,7 @@ class PowerTransformerYeoJohnson(Transformer):
         -------
         y : array-like of shape (n_points, n_features)
             Gradient of the transformation evaluated on the input data.
+            Since all features are independent, the gradient is stored in compact form.
         """
         y = np.zeros_like(x)
 
@@ -780,6 +783,7 @@ class PowerTransformerYeoJohnson(Transformer):
         -------
         y : array-like of shape (n_points, n_features)
             Gradient of the inverse transformation evaluated on the input data.
+            Since all features are independent, the gradient is stored in compact form.
         """
         y = np.zeros_like(x)
 
@@ -817,39 +821,50 @@ class PowerTransformerYeoJohnson(Transformer):
 
 
 class StandardScalerTorch(StandardScaler):
-    import torch
 
     def __init__(self, scale, mean):
+        import torch
+
         super().__init__(scale, mean)
-        device = self.torch.device("cuda" if self.torch.cuda.is_available() else "cpu")
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
         self.device = device
         def __np2torch(v):  # fmt: skip
-            return self.torch.as_tensor(v).to(device)
+            return torch.as_tensor(v).to(device)
         self.gain_ = __np2torch(self.gain_)
         self.inv_gain_ = __np2torch(self.inv_gain_)
         self.offset_ = __np2torch(self.offset_)
 
     def transform(self, x, inplace=True):
+        import torch
+
         if inplace:
             raise ValueError("No inplace...")
-        x = self.torch.as_tensor(x, device=self.device, dtype=self.torch.float32)
+        x = torch.as_tensor(x, device=self.device, dtype=torch.float32)
         return super().transform(x, inplace)
 
     def inverse_transform(self, x, inplace=True):
+        import torch
+
         if inplace:
             raise ValueError("No inplace...")
-        x = self.torch.as_tensor(x, device=self.device, dtype=self.torch.float32)
+        x = torch.as_tensor(x, device=self.device, dtype=torch.float32)
         return super().inverse_transform(x, inplace)
 
     def transform_gradient(self, x):
-        return self.torch.broadcast_to(self.gain_, x.shape).numpy()
+        import torch
+
+        return torch.broadcast_to(self.gain_, x.shape).numpy()
 
     def inverse_transform_gradient(self, x):
-        return self.torch.broadcast_to(self.inv_gain_, x.shape).numpy()
+        import torch
+
+        return torch.broadcast_to(self.inv_gain_, x.shape).numpy()
 
     def __eq__(self, other):
+        import torch
+
         if isinstance(other, self.__class__):
-            test_gain = self.torch.equal(self.gain_, other.gain_)
-            test_offset = self.torch.equal(self.offset_, other.offset_)
+            test_gain = torch.equal(self.gain_, other.gain_)
+            test_offset = torch.equal(self.offset_, other.offset_)
             return test_gain and test_offset
         return False