Two questions

• I tried training on BTC data but the model doesn't learn much (MSE=7233). Is there a fundamental mistake in my approach or is nhits not the right tool for this task? By comparison, LSTM achieved a MSE of 0.24655 on the same dataset.

• What does y_hat and y_true mean exactly and how are they calculated? What is their function since they always seem to have the same values?

Model is set to horizon=1 as we need to predict one t+1 interval, 5m interval in this case. I assume this is correct model = nf.auto.NHITS(horizon=1)

Here is the entire notebook with my code

I'm keen to use nueralforecast for my own work. I'm interested in anomaly detection which is slightly different to forecasting - generally trying to reconstruct a window rather than forecasting the next n points but I think I can make it work.

I'm a little confused around the TimeSeriesLoader though, I've been working through my own example but I'll refer to the getting started notebook to make it easier.

The WindowsDataset is indexed by the number of unique_ids in the original dataset.

train_dataset = nf.data.tsdataset.WindowsDataset(
    Y_df=Y_df_train, 
    X_df=X_df_train,
    f_cols=[f'ex_{i}' for i in range(1, 5)],
    input_size=input_size,
    output_size=output_size,
    mask_df=train_mask_df
)

So in this case there are 7 series, each containing 744 windows of length 144 i.e.

len(train_dataset) == 7
train_dataset[0]['Y'].shape == [774, 144]

Where I'm really confused is the TimeSeriesLoader, I assumed when you set the batch_size=32 then I expect 7 * 774 // 32 batches of data per epoch, each having shape [32,144] but no matter what parameters I try, I only seem to get a single batch that's either of size batch_size or n_windows, i.e.

train_loader = nf.data.tsloader.TimeSeriesLoader(train_dataset, batch_size=32, eq_batch_size=True, shuffle=True)
for batch in train_loader:
    print(batch['Y'].shape)

torch.Size([32, 144])

It only returns a single batch?

I'm expecting something like the following

import torch
from torch.utils.data import DataLoader, TensorDataset

# dummy tensor with fiorst dim being number of series x number of windows per series
train_dataset = TensorDataset(torch.zeros(size=(774*7,144)))
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)

for batch in train_loader:
    print(batch[0].shape)

torch.Size([32, 144]) torch.Size([32, 144]) torch.Size([32, 144]) ... torch.Size([32, 144])

Is there something wrong here, I want to train a model that has multiple long (1 year) series with 15T frequency and 1 day windows. I'm confused as to why the DataLoader only returns one batch per epoch?

Hello,

I'm trying to use the TFT model on my custom dataset. For that, I created a custom pytorch dataloader and when I try to call the fit method on it, it tells me that it got an unexpected type.

Here is the construction of my dataloader

class BSM2Dataset(Dataset):
  """BSM2 dataset."""

  def __init__(self):
    # self.landmarks_frame = pd.read_csv(csv_file)
    self.inf = pd.read_csv('/content/bsm2_influent.csv').values
    self.eff = pd.read_csv('/content/bsm2_effluent.csv').values
    self.X, self.Y = self.split_series(1, 1)

  def __len__(self):
    return len(self.inf)

  def split_series(self, n_past, n_future):
    X, y = list(), list()
    for window_start in range(len(self.inf)):
      past_end = window_start + n_past
      future_end = past_end + n_future
      if future_end > len(self.inf):
        break
      # slicing the past and future parts of the window
      past, future = self.inf[window_start:past_end, :], self.eff[past_end - 1:future_end -1, :]
      X.append(past)
      y.append(future)
    return np.array(X), np.array(y)

  def __getitem__(self, idx):
    if torch.is_tensor(idx):
      idx = idx.tolist()

    return self.X[idx], self.Y[idx]

Here the call to the fit method

foo = BSM2Dataset()
model = TFT(h=12,
                input_size=48,
                hidden_size=100,
                stat_exog_list=['airline1'],
                hist_exog_list=['y_[lag12]'],
                futr_exog_list=['trend'],
                max_epochs=300,
                learning_rate=0.01,
                scaler_type='robust',
                loss=MQLoss(level=[80, 90]),
                windows_batch_size=None,
                enable_progress_bar=True)
model.fit(foo)

The call fails and here is the entire stacktrace

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
[<ipython-input-14-a8a91adbe35a>](https://localhost:8080/#) in <module>
----> 1 model.fit(foo)

18 frames
[/usr/local/lib/python3.7/dist-packages/neuralforecast/common/_base_windows.py](https://localhost:8080/#) in fit(self, dataset, val_size, test_size)
    399 
    400         trainer = pl.Trainer(**self.trainer_kwargs)
--> 401         trainer.fit(self, datamodule=datamodule)
    402 
    403     def predict(self, dataset, test_size=None, step_size=1, **data_module_kwargs):

[/usr/local/lib/python3.7/dist-packages/pytorch_lightning/trainer/trainer.py](https://localhost:8080/#) in fit(self, model, train_dataloaders, val_dataloaders, datamodule, ckpt_path)
    769         self.strategy.model = model
    770         self._call_and_handle_interrupt(
--> 771             self._fit_impl, model, train_dataloaders, val_dataloaders, datamodule, ckpt_path
    772         )
    773 

[/usr/local/lib/python3.7/dist-packages/pytorch_lightning/trainer/trainer.py](https://localhost:8080/#) in _call_and_handle_interrupt(self, trainer_fn, *args, **kwargs)
    721                 return self.strategy.launcher.launch(trainer_fn, *args, trainer=self, **kwargs)
    722             else:
--> 723                 return trainer_fn(*args, **kwargs)
    724         # TODO: treat KeyboardInterrupt as BaseException (delete the code below) in v1.7
    725         except KeyboardInterrupt as exception:

[/usr/local/lib/python3.7/dist-packages/pytorch_lightning/trainer/trainer.py](https://localhost:8080/#) in _fit_impl(self, model, train_dataloaders, val_dataloaders, datamodule, ckpt_path)
    809             ckpt_path, model_provided=True, model_connected=self.lightning_module is not None
    810         )
--> 811         results = self._run(model, ckpt_path=self.ckpt_path)
    812 
    813         assert self.state.stopped

[/usr/local/lib/python3.7/dist-packages/pytorch_lightning/trainer/trainer.py](https://localhost:8080/#) in _run(self, model, ckpt_path)
   1234         self._checkpoint_connector.resume_end()
   1235 
-> 1236         results = self._run_stage()
   1237 
   1238         log.detail(f"{self.__class__.__name__}: trainer tearing down")

[/usr/local/lib/python3.7/dist-packages/pytorch_lightning/trainer/trainer.py](https://localhost:8080/#) in _run_stage(self)
   1321         if self.predicting:
   1322             return self._run_predict()
-> 1323         return self._run_train()
   1324 
   1325     def _pre_training_routine(self):

[/usr/local/lib/python3.7/dist-packages/pytorch_lightning/trainer/trainer.py](https://localhost:8080/#) in _run_train(self)
   1343 
   1344         with isolate_rng():
-> 1345             self._run_sanity_check()
   1346 
   1347         # enable train mode

[/usr/local/lib/python3.7/dist-packages/pytorch_lightning/trainer/trainer.py](https://localhost:8080/#) in _run_sanity_check(self)
   1411             # run eval step
   1412             with torch.no_grad():
-> 1413                 val_loop.run()
   1414 
   1415             self._call_callback_hooks("on_sanity_check_end")

[/usr/local/lib/python3.7/dist-packages/pytorch_lightning/loops/base.py](https://localhost:8080/#) in run(self, *args, **kwargs)
    202             try:
    203                 self.on_advance_start(*args, **kwargs)
--> 204                 self.advance(*args, **kwargs)
    205                 self.on_advance_end()
    206                 self._restarting = False

[/usr/local/lib/python3.7/dist-packages/pytorch_lightning/loops/dataloader/evaluation_loop.py](https://localhost:8080/#) in advance(self, *args, **kwargs)
    153         if self.num_dataloaders > 1:
    154             kwargs["dataloader_idx"] = dataloader_idx
--> 155         dl_outputs = self.epoch_loop.run(self._data_fetcher, dl_max_batches, kwargs)
    156 
    157         # store batch level output per dataloader

[/usr/local/lib/python3.7/dist-packages/pytorch_lightning/loops/base.py](https://localhost:8080/#) in run(self, *args, **kwargs)
    202             try:
    203                 self.on_advance_start(*args, **kwargs)
--> 204                 self.advance(*args, **kwargs)
    205                 self.on_advance_end()
    206                 self._restarting = False

[/usr/local/lib/python3.7/dist-packages/pytorch_lightning/loops/epoch/evaluation_epoch_loop.py](https://localhost:8080/#) in advance(self, data_fetcher, dl_max_batches, kwargs)
    110         if not isinstance(data_fetcher, DataLoaderIterDataFetcher):
    111             batch_idx = self.batch_progress.current.ready
--> 112             batch = next(data_fetcher)
    113         else:
    114             batch_idx, batch = next(data_fetcher)

[/usr/local/lib/python3.7/dist-packages/pytorch_lightning/utilities/fetching.py](https://localhost:8080/#) in __next__(self)
    182 
    183     def __next__(self) -> Any:
--> 184         return self.fetching_function()
    185 
    186     def reset(self) -> None:

[/usr/local/lib/python3.7/dist-packages/pytorch_lightning/utilities/fetching.py](https://localhost:8080/#) in fetching_function(self)
    257             # this will run only when no pre-fetching was done.
    258             try:
--> 259                 self._fetch_next_batch(self.dataloader_iter)
    260                 # consume the batch we just fetched
    261                 batch = self.batches.pop(0)

[/usr/local/lib/python3.7/dist-packages/pytorch_lightning/utilities/fetching.py](https://localhost:8080/#) in _fetch_next_batch(self, iterator)
    271     def _fetch_next_batch(self, iterator: Iterator) -> None:
    272         start_output = self.on_fetch_start()
--> 273         batch = next(iterator)
    274         self.fetched += 1
    275         if not self.prefetch_batches and self._has_len:

[/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py](https://localhost:8080/#) in __next__(self)
    679                 # TODO(https://github.com/pytorch/pytorch/issues/76750)
    680                 self._reset()  # type: ignore[call-arg]
--> 681             data = self._next_data()
    682             self._num_yielded += 1
    683             if self._dataset_kind == _DatasetKind.Iterable and \

[/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py](https://localhost:8080/#) in _next_data(self)
    719     def _next_data(self):
    720         index = self._next_index()  # may raise StopIteration
--> 721         data = self._dataset_fetcher.fetch(index)  # may raise StopIteration
    722         if self._pin_memory:
    723             data = _utils.pin_memory.pin_memory(data, self._pin_memory_device)

[/usr/local/lib/python3.7/dist-packages/torch/utils/data/_utils/fetch.py](https://localhost:8080/#) in fetch(self, possibly_batched_index)
     50         else:
     51             data = self.dataset[possibly_batched_index]
---> 52         return self.collate_fn(data)

[/usr/local/lib/python3.7/dist-packages/neuralforecast/tsdataset.py](https://localhost:8080/#) in _collate_fn(self, batch)
     61                         temporal_cols = elem['temporal_cols'])
     62 
---> 63         raise TypeError(f'Unknown {elem_type}')
     64 
     65 # %% ../nbs/tsdataset.ipynb 7

TypeError: Unknown <class 'tuple'>

I tried searching on the site and I couldn't find an example of the TimeSeriesDataset being used as an example. Would it possible to have a tutorial nb which shows how to do this?

Thanks!

Hi, any idea to solve this issue. I used custom dataset and tried to mimic this code but it return error as follow. this is the data

---------------------------------------------------------------------------
AssertionError                            Traceback (most recent call last)
Input In [20], in <cell line: 2>()
      1 model.return_decomposition = False
----> 2 forecast_df = model.forecast(Y_df=Y_forecast_df, X_df=X_forecast_df, S_df=S_df, batch_size=2)
      3 forecast_df

Input In [10], in forecast(self, Y_df, X_df, S_df, batch_size, trainer, verbose)
     39 Y_df = Y_df.append(forecast_df).sort_values(['unique_id','ds']).reset_index(drop=True)
     41 # Dataset, loader and trainer
---> 42 dataset = WindowsDataset(S_df=S_df, Y_df=Y_df, X_df=X_df,
     43                             mask_df=None, f_cols=[],
     44                             input_size=self.n_time_in,
     45                             output_size=self.n_time_out,
     46                             sample_freq=1,
     47                             complete_windows=True,
     48                             ds_in_test=self.n_time_out,
     49                             is_test=True,
     50                             verbose=verbose)
     52 loader = TimeSeriesLoader(dataset=dataset,
     53                             batch_size=batch_size,
     54                             shuffle=False)
     56 if trainer is None:

File ~\Anaconda3\envs\SiT\lib\site-packages\neuralforecast\data\tsdataset.py:636, in WindowsDataset.__init__(self, Y_df, input_size, output_size, X_df, S_df, f_cols, mask_df, ds_in_test, is_test, sample_freq, complete_windows, last_window, verbose)
    590 def __init__(self,
    591              Y_df: pd.DataFrame,
    592              input_size: int,
   (...)
    602              last_window: bool = False,
    603              verbose: bool = False) -> 'TimeSeriesDataset':
    604     """
    605     Parameters
    606     ----------
   (...)
    634         Wheter or not log outputs.
    635     """
--> 636     super(WindowsDataset, self).__init__(Y_df=Y_df, input_size=input_size,
    637                                          output_size=output_size,
    638                                          X_df=X_df, S_df=S_df, f_cols=f_cols,
    639                                          mask_df=mask_df, ds_in_test=ds_in_test,
    640                                          is_test=is_test, complete_windows=complete_windows,
    641                                          verbose=verbose)
    642     # WindowsDataset parameters
    643     self.windows_size = self.input_size + self.output_size

File ~\Anaconda3\envs\SiT\lib\site-packages\neuralforecast\data\tsdataset.py:110, in BaseDataset.__init__(self, Y_df, X_df, S_df, f_cols, mask_df, ds_in_test, is_test, input_size, output_size, complete_windows, verbose)
    106     dataset_info += f'Outsample percentage={out_prc}, \t{n_out} time stamps \n'
    107     logging.info(dataset_info)
    109 self.ts_data, self.s_matrix, self.meta_data, self.t_cols, self.s_cols \
--> 110                  = self._df_to_lists(Y_df=Y_df, S_df=S_df, X_df=X_df, mask_df=mask_df)
    112 # Dataset attributes
    113 self.n_series = len(self.ts_data)

File ~\Anaconda3\envs\SiT\lib\site-packages\neuralforecast\data\tsdataset.py:201, in _df_to_lists(self, S_df, Y_df, X_df, mask_df)
    198 M = mask_df.sort_values(by=['unique_id', 'ds'], ignore_index=True).copy()
    200 assert np.array_equal(X.unique_id.values, Y.unique_id.values), f'Mismatch in X, Y unique_ids'
--> 201 assert np.array_equal(X.ds.values, Y.ds.values), f'Mismatch in X, Y ds'
    202 assert np.array_equal(M.unique_id.values, Y.unique_id.values), f'Mismatch in M, Y unique_ids'
    203 assert np.array_equal(M.ds.values, Y.ds.values), f'Mismatch in M, Y ds'

AssertionError: Mismatch in X, Y ds

Hi, I need to forecast a target variable and I have two time series variable as continuous exog variables that can be used to forecast target series for multistep ahead. I can access the future values of exog variable and for production purpose I would like to simulate the impact of exog variable in the future to the forecasted target. So, I need to use exog at time t+1 to forecast target at time t+1 and so on. can I do that?

thank you

TFT-GMM is listed as a hierarchical methodology in the documentation, though I don't see a summation matrix parameter as in Hierarchical DeepVAR. I assume that it's not hierarchical then in the sense of learning hierarchical reconciliation as in Hierarchical DeepVAR?

Cheers, Eric

Hello,

I was trying to try the demo code for the Temporal Fusion Transformer and the example given in the docs is broken.

1. There is a missing import from neuralforecast.models import TFT
2. I'm unable to call the fit method as the function does take the static_df argument. I checked the source code to see if the argument was renamed, but unfortunately that isn't the case.

Thanks!

The simple NBEATS model has already its Auto version. The NBEATSx model is missing one.

For the moment one can recover the AutoNBEATSx behavior through AutoNHITS by setting n_freq_downsample to a list of ones.

StatsForecast core class has a very useful .forecast method: https://nixtla.github.io/statsforecast/core.html

Currently NeuralForecast core class can mimic its behavior by calling .predict method without additional arguments.

It would be convenient to homogenize the methods and add a NeuralForecast.forecast method too.

It seems that a naive conda installation on top of a server with CUDA pre-installed fails to locate its path correctly.

conda env create -f environment.yml

Previous manual installations like this https://github.com/cchallu/nbeatsx/blob/main/setup.sh Correctly installs PyTorch with CUDA dependencies.

The following installation works correctly with CUDA pre-installed

pip install neuralforecast

A careful look into environment.yml is needed.

I have a use case wherein I need to take multi-variate time-series data as input, find correlations, and predict an output. In my particular case, I only need the output to be a 0 or 1. 0 meaning down, and 1 meaning up.

NeuralForecast models appear to be designed to forecast an unbounded value(s). Instead of having a fixed label applied to each observation in the dataset, the horizon parameter is used to determine the x-shift to produce the y labels at runtime.

Is it possible to update the output so that it gives a value between 0 and 1, or each predicted time period?

Thank you for your time! NeuralForecast is an excellent package

After declaring and fitting a NeuralForecast method with exogenous variables, during predict if the exogenous variables are not send as input. The method returns nans.

We need to add a RaiseException that checks the inputs of the models. Maybe even an exception that checks for nans the input pandas dataframes.