Merge branch 'main' into kan-nbeats

Author: Sohaib-Ahmed21

pytorch_forecasting/data/timeseries/_timeseries.py

@@ -1430,25 +1430,34 @@ def _data_to_tensors(self, data: pd.DataFrame) -> dict[str, torch.Tensor]:
             time index
         """
 
-        def _to_tensor(cols, long=True) -> torch.Tensor:
+        def _to_tensor(cols, long=True, real=False) -> torch.Tensor:
             """Convert data[cols] to torch tensor.
 
             Converts sub-frames to numpy and then to torch tensor.
             Makes the following choices for types:
 
-            * float columns are converted to torch.float
-            * integer columns are converted to torch.int64 or torch.long,
-              depending on the long argument
+            - real is True:
+                * the sub-frame is converted to a torch.float32 tensor
+            - long is True (and real is False):
+                * the sub-frame is converted to a torch.long tensor
+            - real is False and long is False:
+                * if all columns are integer or boolean, the sub-frame is
+                  converted to a torch.int64 tensor
+                * if one column is a float, the sub-frame is converted to
+                  a torch.float32 tensor
             """
             if not isinstance(cols, list) and cols not in data.columns:
                 return None
             if isinstance(cols, list) and len(cols) == 0:
                 dtypekind = "f"
             elif isinstance(cols, list):  # and len(cols) > 0
-                dtypekind = data.dtypes[cols[0]].kind
+                # dtypekind = data.dtypes[cols[0]].kind
+                dtypekind = np.result_type(*data[cols].dtypes.to_list()).kind
             else:
                 dtypekind = data.dtypes[cols].kind
-            if not long:
+            if real:
+                return torch.tensor(data[cols].to_numpy(np.float64), dtype=torch.float)
+            elif not long:
                 return torch.tensor(data[cols].to_numpy(np.int64), dtype=torch.int64)
             elif dtypekind in "bi":
                 return torch.tensor(data[cols].to_numpy(np.int64), dtype=torch.long)

pytorch_forecasting/tests/test_doctest.py

@@ -0,0 +1,111 @@
+# copyright: pytorch-forecasting developers, BSD-3-Clause License (see LICENSE file)
+# copy of the sktime utility of the same name (BSD-3)
+"""Doctest checks directed through pytest with conditional skipping."""
+
+from functools import lru_cache
+import importlib
+import inspect
+import pkgutil
+
+EXCLUDE_MODULES_STARTING_WITH = ("all", "test")
+
+
+def _all_functions(module_name):
+    """Get all functions from a module, including submodules.
+
+    Excludes:
+
+    * modules starting with 'all' or 'test'.
+    * if the flag ``ONLY_CHANGED_MODULES`` is set, modules that have not changed,
+      compared to the ``main`` branch.
+
+    Parameters
+    ----------
+    module_name : str
+        Name of the module.
+
+    Returns
+    -------
+    functions_list : list
+        List of tuples (function_name, function_object).
+    """
+    res = _all_functions_cached(module_name)
+    # copy the result to avoid modifying the cached result
+    return res.copy()
+
+
+@lru_cache
+def _all_functions_cached(module_name, only_changed_modules=False):
+    """Get all functions from a module, including submodules.
+
+    Excludes:
+
+    * modules starting with 'all' or 'test'.
+    * if ``only_changed_modules`` is ``True``, modules that have not changed,
+      compared to the ``main`` branch.
+
+    Parameters
+    ----------
+    module_name : str
+        Name of the module.
+    only_changed_modules : bool, optional (default=False)
+        If True, only functions from modules that have changed are returned.
+
+    Returns
+    -------
+    functions_list : list
+        List of tuples (function_name, function_object).
+    """
+    # Import the package
+    package = importlib.import_module(module_name)
+
+    # Initialize an empty list to hold all functions
+    functions_list = []
+
+    # Walk through the package's modules
+    package_path = package.__path__[0]
+    for _, modname, _ in pkgutil.walk_packages(
+        path=[package_path], prefix=package.__name__ + "."
+    ):
+        # Skip modules starting with 'all' or 'test'
+        if modname.split(".")[-1].startswith(EXCLUDE_MODULES_STARTING_WITH):
+            continue
+
+        # Import the module
+        module = importlib.import_module(modname)
+
+        # Get all functions from the module
+        for name, obj in inspect.getmembers(module, inspect.isfunction):
+            # if function is imported from another module, skip it
+            if obj.__module__ != module.__name__:
+                continue
+            # add the function to the list
+            functions_list.append((name, obj))
+
+    return functions_list
+
+
+def pytest_generate_tests(metafunc):
+    """Test parameterization routine for pytest.
+
+    Fixtures parameterized
+    ----------------------
+    func : all functions from sktime, as returned by _all_functions
+        if ONLY_CHANGED_MODULES is set, only functions from modules that have changed
+    """
+    # we assume all four arguments are present in the test below
+    funcs_and_names = _all_functions("pytorch_forecasting")
+
+    if len(funcs_and_names) > 0:
+        names, funcs = zip(*funcs_and_names)
+
+        metafunc.parametrize("func", funcs, ids=names)
+    else:
+        metafunc.parametrize("func", [])
+
+
+def test_all_functions_doctest(func):
+    """Run doctest for all functions in pytorch-forecasting."""
+    from skbase.utils.doctest_run import run_doctest
+
+    run_doctest(func, name=f"function {func.__name__}")

pytorch_forecasting/utils/_dependencies/_safe_import.py

@@ -59,7 +59,7 @@ def _safe_import(import_path, pkg_name=None):
 
     Examples
     --------
-    >>> from pytorch_forecasting.utils.dependencies._safe_import import _safe_import
+    >>> from pytorch_forecasting.utils._dependencies._safe_import import _safe_import
 
     >>> # Import a top-level module
     >>> torch = _safe_import("torch")

tests/test_data/test_timeseries.py

@@ -678,3 +678,41 @@ def distance_to_weights(dist):
         if idx > 100:
             break
     print(a)
+
+
+def test_correct_dtype_inference():
+    # Create a small dataset
+    data = pd.DataFrame(
+        {
+            "time_idx": np.arange(30),
+            "value": np.sin(np.arange(30) / 5) + np.random.normal(scale=1, size=30),
+            "group": ["A"] * 30,
+        }
+    )
+
+    # Define the dataset
+    dataset = TimeSeriesDataSet(
+        data.copy(),
+        time_idx="time_idx",
+        target="value",
+        group_ids=["group"],
+        static_categoricals=["group"],
+        max_encoder_length=4,
+        max_prediction_length=2,
+        time_varying_unknown_reals=["value"],
+        target_normalizer=None,
+        # WATCH THIS
+        time_varying_known_reals=["time_idx"],
+        scalers=dict(time_idx=None),
+    )
+
+    # and the dataloader
+    dataloader = dataset.to_dataloader(batch_size=8)
+
+    x, y = next(iter(dataset))
+    # real features must be real
+    assert x["x_cont"].dtype is torch.float
+
+    x, y = next(iter(dataloader))
+    # real features must be real
+    assert x["encoder_cont"].dtype is torch.float