Is your feature request related to a problem? Please describe.
The nhits' forecast method needs pandas to run properly. I think this is a silent bug because in the nbs , pandas is imported to test the method but it is not exported.

Describe the solution you'd like
Importing pandas from the beginning should solve the problem.

The notebooks generate heterogeneous testing data folders.
I suggest we unify them into the nbs/data folder by default.

The .gitignore file already contemplates the nbs/data folder.

The get_default_mask function from the data.tsdataset module returns a dataframe with a different index than the original Y_df. I think the index should be the same.

There is a difference in the anti-nan protection for the MASE Loss function used by ElementAI and the one we are using:

ElementAI only uses the divide_no_nan function over the scale factor (https://github.com/ElementAI/N-BEATS/blob/04f56c4ca4c144071b94089f7195b1dd606072b0/common/torch/losses.py#L61):

masep = t.mean(t.abs(insample[:, freq:] - insample[:, :-freq]), dim=1)
masked_masep_inv = divide_no_nan(mask, masep[:, None]) <--- Anti-nan protection only used over the scale factor
return t.mean(t.abs(target - forecast) * masked_masep_inv) <--- No anti-nan protection for the forecast

Our MASELoss function is hiding the nans from the forecast (https://github.com/Nixtla/nixtlats/blob/a3c7442a4c16c255685e158c9347d045f87ffa3b/nixtlats/losses/pytorch.py#L160):

delta_y = t.abs(y - y_hat)
scale = t.mean(t.abs(y_insample[:, seasonality:] -
y_insample[:, :-seasonality]), axis=1)
mase = divide_no_nan(delta_y, scale[:, None]) <--- Anti-nan protection masks nans coming from the scale and the forecast
mase = mase * mask
mase = t.mean(mase)

This difference causes a silent bug by setting the loss to zero during training/validation when the forecasts are meaningless.

It seems that some Linux versions have problems with the unrar dependency.
A potential solution is to change the link to a previously unzipped dataset.

It seems convenient to use sklearn built-in functions to declare the static variables on all the datasets.
Time considerations and code convenience should be taken into account.

**Is your feature request related to a problem? Please describe.
The nhits' forecast method needs TimeSeriesLoader to run properly. I think this is a silent bug because in the nbs , TimeSeriesLoader is imported to test the method but it is not exported.

**Describe the solution you'd like
Importing needed imports from the beginning should solve the problem.

Related to #134.

Recently, we found a couple of tricks to speed up the training processes:

• Data Parallelism: torch.nn.DataParallel(module) (https://pytorch.org/docs/stable/generated/torch.nn.DataParallel.html). This function automatically splits the input in the forward pass among the available GPUs and automatically collects and adds up the gradients in the backward pass.
• Automatic Mixed Precision: torch.cuda.amp (https://pytorch.org/docs/stable/generated/torch.nn.DataParallel.html). This package provides functions to automatically cast the datatype of the tensors to optimize the threshold between precision and computing speed.

I think it would be extremely handy to have a simple evaluation example for the dataset tasks within the notebook.
Where we import the respective metric and try a simple benchmark, the measurement could be the one at the bottom of the evaluation table in each dataset.

Open AI gym library has a tiny wiki for each RL where they explicitly state what is to "solve" a task.
Example https://github.com/openai/gym/wiki/BipedalWalker-v2.

It seems that fastai has some dependency problems from the nbconvert library from jupyter
downgrading nbconvert solved the issue, seems to me yaml environment needs version protections.
https://forums.fast.ai/t/htmlexporter-object-has-no-attribute-template-path/80775/15

downgrading the nbconvert library solved the issue
conda install nbconvert=5.6.1

Missing sample_submission.csv from raw data
Missing reference to original drive link and Kaggle competition.

The reason why we used to have the numpy validation loss was to deal with the zeros in the mask.
In the numpy loss zeros are not counted as zero they are just excluded, while the pytorch loss just masks the gradients by multiplying the entries.

what should be the format of the exogenous variables using the forecast method? does the method use the future?

To avoid making a very complex environment, we could try to keep only the needed dependencies.
The openpyxl seems more complete to deal with excel sheets we could avoid xlrd.

Should we check the preprocessing scalers to see if we can use the predefined sklearn class and inherit it?

Pytorch and pytorch lightning downloads take a lot of time depending on the download channel, and some HTTP issues arise:

1. Pytorch: CondaHTTPError: HTTP 000 CONNECTION FAILED for URL https://conda.anaconda.org/pytorch/linux-64/pytorch-1.10.2-py3.7_cuda11.3_cudnn8.2.0_0.tar.bz2
2. Pytorch lightning: socket.timeout: The read operation timed out

In the case of pytorch, specifying the channel (-pytorch::pytorch, -pytorch::torchvision, etc.) solved the problem; with pytorch lightning, setting the timeout to a large number (pip install -U --timeout 2000 pytorch-lightning) did the trick.

The forward method from the NBEATS model (https://github.com/Nixtla/nixtlats/blob/a3c7442a4c16c255685e158c9347d045f87ffa3b/nixtlats/models/nbeats/nbeats.py#L402) is returning all-nan forecast tensors. The real issue comes from the forecast method (https://github.com/Nixtla/nixtlats/blob/a3c7442a4c16c255685e158c9347d045f87ffa3b/nixtlats/models/nbeats/nbeats.py#L431) when the argument return_decomposition is set to False. (https://github.com/Nixtla/nixtlats/blob/a3c7442a4c16c255685e158c9347d045f87ffa3b/nixtlats/models/nbeats/nbeats.py#L424)

This issue has only been detected when using MASE Loss as the training loss function.

The method get_filtered_ts_tensor from the class TimeSeriesDataset is not tested.

Feather is more than 10 times faster at loading than csvs.

Is your feature request related to a problem? Please describe.
Right now the forecast method assumes:

• All series end with the same timestamp.
• The datestamp column (ds) of the input dataframe (Y_df) is a well-formatted string.

To train a model these assumptions are not necessary. (A user can train using ints or floats as the ds column).

Describe the solution you'd like
Consider these scenarios in the forecast method.

ESRNN and RNNs, in general, need a warmup period before sample_mask==1.

The predictions should filter using the sample_mask ex-post. Dataloader should send all the windows so that all sampleable_mask gets predictions.

Is your feature request related to a problem? Please describe.
Missing forecast function for transformer-based models.

Describe the solution you'd like
A forecast function for transformer-based models.

Rather than having the autocorrelation test on the Naive2 model, it would be convenient to declare a test folder and specialized notebooks.

Is your feature request related to a problem? Please describe.
The TCN model should be listed under model the docs.

Describe the solution you'd like
A clear and concise description of what you want to happen.

Describe alternatives you've considered
A clear and concise description of any alternative solutions or features you've considered.

Additional context
Add any other context or screenshots about the feature request here.

From the experience of the other ESRNN repo, a test for the dataframe balance can save users a lot of debugging efforts.

The logs printed by M4.load claim an error, but the downloaded data is correct.

When instantiating a Nbeats model, the init() argument 'n_hidden' must be a list of lists, one per 'stack_type,' so each corresponding set of NBeatsBlock is initialized passing a list as the 'theta_n_hidden' argument.

An assert statement in Nbeats.init() would help the user identify if this argument is properly stated, particularly when running grid routines (hyper optimization or ensembling), as the 'n_hidden' item in the grid needs to be defined as a list of lists of lists.

During hyperopt evaluation breaks with:
np.average weights sum to zero can't be normalized

The error does not seem to come from a mask full of zeros.

Similar issue as the issue from the original NBEATSx repo:
cchallu/nbeatsx#1
The PyTorch default seems to be uniform and not LeCun normal.

Is your feature request related to a problem? Please describe.
A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]

Describe the solution you'd like
A clear and concise description of what you want to happen.

Describe alternatives you've considered
A clear and concise description of any alternative solutions or features you've considered.

Additional context
Add any other context or screenshots about the feature request here.

Is your feature request related to a problem? Please describe.
I see some cool work here, but it's hard to understand how to use the project without some examples.

Describe the solution you'd like
Add some example notebooks showing off how to use the different features in the project.

Describe alternatives you've considered
any other form of documentation

Additional context

All datasets should give Y_df, X_df, S_df

batch_size depends on the windows available at each time series, which makes it unstable:
e.g. if series per batch is 1 and one time series is of lenght 19 or 12 each batch size will have
19 or 12 gradient signals.

Is your feature request related to a problem? Please describe.
add logSparse attention as an option for the informer model. I've experienced improved results over prob attention. It's a drop-in replacement

Describe the solution you'd like

class LogSparseAttention(nn.Module):
""" https://arxiv.org/abs/1907.00235
"""
    def __init__(self, mask_flag=True, factor=5, scale=None, attention_dropout=0.1, output_attention=False):
        super(LogSparceAttention, self).__init__()
        self.scale = scale
        self.mask_flag = mask_flag
        self.output_attention = output_attention
        self.dropout = nn.Dropout(attention_dropout)

    def log_mask(self, win_len, sub_len):
        mask = torch.zeros((win_len, win_len), dtype=torch.float)
        for i in range(win_len):
            mask[i] = self.row_mask(i, sub_len, win_len)
        return mask.view(1, 1, mask.size(0), mask.size(1))

    def row_mask(self, index, sub_len, win_len):
        log_l = math.ceil(np.log2(sub_len))

        mask = torch.zeros((win_len), dtype=torch.float)
        if((win_len // sub_len) * 2 * (log_l) > index):
            mask[:(index + 1)] = 1
        else:
            while(index >= 0):
                if((index - log_l + 1) < 0):
                    mask[:index] = 1
                    break
                mask[index - log_l + 1:(index + 1)] = 1  # Local attention
                for i in range(0, log_l):
                    new_index = index - log_l + 1 - 2**i
                    if((index - new_index) <= sub_len and new_index >= 0):
                        mask[new_index] = 1
                index -= sub_len
        return mask

    def forward(self, queries, keys, values, attn_mask):
        B, L, H, E = queries.shape
        _, S, _, D = values.shape
        scale = self.scale or 1./sqrt(E)

        scores = torch.einsum("blhe,bshe->bhls", queries, keys)
    
        mask = self.log_mask(L, S)
        mask_tri = mask[:, :, :scores.size(-2), :scores.size(-1)]
        scores = scores.to(queries.device)
        mask_tri = mask_tri.to(queries.device)
        scores = scores * mask_tri + -1e9 * (1 - mask_tri)

        A = self.dropout(torch.softmax(scale * scores, dim=-1))
        V = torch.einsum("bhls,bshd->blhd", A, values)

        if self.output_attention:
            return (V.contiguous(), A)
        else:
            return (V.contiguous(), None)

Describe alternatives you've considered

Additional context
https://arxiv.org/abs/1907.00235
Li, S., Jin, X., Xuan, Y., Zhou, X., Chen, W., Wang, Y. X., & Yan, X. (2019). Enhancing the locality and breaking the memory bottleneck of transformer on time series forecasting. arXiv preprint arXiv:1907.00235.

Partial work was done on unbalanced panels and protections of the dataloader with the available_mask
It would be beneficial to finish the experiment utility to balance the panel and make the needed tests of the available_mask use within the dataloader.

Due PyTorch being a requirement, I had to downgrade out of python3.10 somehow, so I tried with conda

I tried this to no avail:

conda create -n nixtla python=3.7  # And also 3.6
conda activate nixtla
conda install -c nixtla neuralforecast

getting library errors such as:

This can take several minutes.  Press CTRL-C to abort.
failed

UnsatisfiableError: The following specifications were found to be incompatible with each other:

Output in format: Requested package -> Available versions

I finally was able to install it after using python=3.7.11 as shown in the documentation (not generic 3.7 as shown above)

Is your feature request related to a problem? Please describe.
It would be a great feature to have gpu usage in inference/forecast phase to reduce processing time in production

Describe the solution you'd like
I think a possible solution could be:

@patch
def forecast(self: model, Y_df, X_df, S_df, batch_size, **trainer_kwargs):
       ...
       trainer = pl.Trainer(**trainer_kwargs)
       ....

So the user could simply use:

model.forecast(Y_df, X_df, S_df, batch_size, gpus=4)

When running data_datasets__gefcom2012.ipynb and data_datasets__gefcom2014.ipynb following error appear.
When downloading gefcom2012 dataset this error occured.

When downloading gefcom2014 dataset this error occured.

I'm using python in anaconda enviroment on Windows.

Mode will either return the full series, or single windows.
mode==single: returns single windows
mode==full: returns the whole series

The 'full' current mode is not intelligent, as it only breaks if window_size inputs are not satisfied.
NLP datasets have a long tradition of intelligently wrangling the time series.

Is your feature request related to a problem? Please describe.
Even if you don't use temporal exogenous variables and static variables you need to declare them as None in the model.forecast method.

Describe the solution you'd like
I think it would be good set the default to None.

The current logos are the default from FastAI.
Changes are needed in docs/images/company_logo_big.png and docs/images/company_logo.png

Trying tu run mqesrnn using GPU the following error appears,

The predict method uses seasonality from future observations if seasonality<n_out
For example: if predictions for 2 weeks, seasonality 7 will look at the Friday of last week (that comes from the future).

The solution is to add Naive2 values for seasonality in the prediction method.

When the n_input < n_output, the _NBEATS forward does incorrect wrangling of the outsample_mask, the dimensions of outsample_y and outsample_mask don't match.

I think it might be helpful to have a How to contribute document, particularly working with nbdev.

When running test function test_batch_construction_windows in data__tsdataset.ipynb notebook folowing error appears.

I'm using python enviroment in anaconda3 on Windows.

The len_sample_chunk and mode parameters are redundant with the complete_input condition + input_size parameter

The input_size parameter is confusing, as users may think it refers to the input_size of the model (it does not).

• We could rather define new window_size to guarantee that the rolled windows will be of window_size
• output_size will be only be needed for protection purposes and sampleable_conditions

The only thing that len_sample_chunk is doing is padding in a different way, (0s or input + output).