[BUG] Fix issue with plot_prediction_actual_by_variable unsupported operand type(s) for *: 'numpy.ndarray' and 'Tensor' (#1903)

fixes #1822

This PR fixes the issue with `plot_prediction_actual_by_variable` where
the input `np.ndarray` was being multiplied to `torch.Tensor` in
`TorchNormalizer` `__call__`

Author: fnhirwa

pytorch_forecasting/data/encoders.py

@@ -757,29 +757,33 @@ def transform(
         else:
             return y
 
-    def inverse_transform(self, y: torch.Tensor) -> torch.Tensor:
+    def inverse_transform(self, y: Union[torch.Tensor, np.ndarray]) -> torch.Tensor:
         """
         Inverse scale.
 
         Parameters
         ----------
-        y: torch.Tensor
+        y: Union[torch.Tensor, np.ndarray])
             scaled data
 
         Returns
         -------
         torch.Tensor
             de-scaled data
         """
+        if isinstance(y, np.ndarray):
+            y = torch.from_numpy(y)
         return self(dict(prediction=y, target_scale=self.get_parameters().unsqueeze(0)))
 
-    def __call__(self, data: dict[str, torch.Tensor]) -> torch.Tensor:
+    def __call__(
+        self, data: dict[str, Union[torch.Tensor, np.ndarray]]
+    ) -> torch.Tensor:
         """
         Inverse transformation but with network output as input.
 
         Parameters
         ----------
-        data: Dict[str, torch.Tensor]
+        data: dict[str, Union[torch.Tensor, np.ndarray]]
             Dictionary with entries
 
             * prediction: data to de-scale
@@ -795,24 +799,26 @@ def __call__(self, data: dict[str, torch.Tensor]) -> torch.Tensor:
         if isinstance(dtype, np.dtype):
             # convert the array into tensor if it is a numpy array
             data["prediction"] = torch.as_tensor(data["prediction"])
-            dtype = data["prediction"].dtype
+
+        prediction = data["prediction"]
 
         # inverse transformation with tensors
         norm = data["target_scale"]
-
+        if isinstance(norm, np.ndarray):
+            norm = torch.from_numpy(norm)
         # use correct shape for norm
-        if data["prediction"].ndim > norm.ndim:
+        if prediction.ndim > norm.ndim:
             norm = norm.unsqueeze(-1)
 
         # transform
-        y = data["prediction"] * norm[:, 1, None] + norm[:, 0, None]
+        y = prediction * norm[:, 1, None] + norm[:, 0, None]
 
         y = self.inverse_preprocess(y)
 
         # return correct shape
-        if data["prediction"].ndim == 1 and y.ndim > 1:
+        if prediction.ndim == 1 and y.ndim > 1:
             y = y.squeeze(0)
-        return y.type(dtype)
+        return y.type(prediction.dtype)
 
 
 class EncoderNormalizer(TorchNormalizer):

tests/test_data/test_encoders.py

@@ -62,41 +62,51 @@ def test_NaNLabelEncoder_add():
     [
         dict(method="robust"),
         dict(method="robust", method_kwargs=dict(upper=1.0, lower=0.0)),
-        dict(method="robust", data=np.random.randn(100)),
-        dict(data=np.random.randn(100)),
+        dict(method="robust"),
         dict(transformation="log"),
         dict(transformation="softplus"),
         dict(transformation="log1p"),
         dict(transformation="relu"),
         dict(method="identity"),
-        dict(method="identity", data=np.random.randn(100)),
+        dict(
+            method="identity",
+        ),
         dict(center=False),
         dict(max_length=5),
-        dict(data=pd.Series(np.random.randn(100))),
         dict(max_length=[1, 2]),
     ],
 )
-def test_EncoderNormalizer(kwargs):
+@pytest.mark.parametrize("data_type", ["torch", "numpy", "pandas"])
+def test_EncoderNormalizer(kwargs, data_type):
+    transformation = kwargs.get("transformation")
+
+    if transformation in ["log", "log1p", "softplus", "relu"]:
+        base_data = np.random.uniform(0.1, 10, size=100)  # strictly positive
+    else:
+        base_data = np.random.randn(100)
+
+    if data_type == "torch":
+        data = torch.tensor(base_data, dtype=torch.float32)
+    elif data_type == "numpy":
+        data = base_data.astype(np.float32)
+    elif data_type == "pandas":
+        data = pd.Series(base_data.astype(np.float32))
     kwargs.setdefault("method", "standard")
     kwargs.setdefault("center", True)
-    kwargs.setdefault("data", torch.rand(100))
-    data = kwargs.pop("data")
 
     normalizer = EncoderNormalizer(**kwargs)
+    transformed = normalizer.fit_transform(data)
+    inverse = normalizer.inverse_transform(torch.as_tensor(transformed))
 
     if kwargs.get("transformation") in ["relu", "softplus", "log1p"]:
         assert (
-            normalizer.inverse_transform(
-                torch.as_tensor(normalizer.fit_transform(data))
-            )
-            >= 0
+            inverse >= 0
         ).all(), "Inverse transform should yield only positive values"
     else:
+        expected = torch.as_tensor(data)
         assert torch.isclose(
-            normalizer.inverse_transform(
-                torch.as_tensor(normalizer.fit_transform(data))
-            ),
-            torch.as_tensor(data),
+            inverse,
+            expected,
             atol=1e-5,
         ).all(), "Inverse transform should reverse transform"