> ## Documentation Index
> Fetch the complete documentation index at: https://nixtla-old-docs.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# TimesNet

The TimesNet univariate model tackles the challenge of modeling multiple
intraperiod and interperiod temporal variations.

The architecture has the following distinctive features: - An embedding
layer that maps the input sequence into a latent space. - Transformation
of 1D time seires into 2D tensors, based on periods found by FFT. - A
convolutional Inception block that captures temporal variations at
different scales and between periods.

**References**<br /> - [Haixu Wu and Tengge Hu and Yong Liu and Hang Zhou
and Jianmin Wang and Mingsheng Long. TimesNet: Temporal 2D-Variation
Modeling for General Time Series
Analysis](https://openreview.net/pdf?id=ju_Uqw384Oq) - Based on the
implementation in [https://github.com/thuml/Time-Series-Library](https://github.com/thuml/Time-Series-Library) (license:
[https://github.com/thuml/Time-Series-Library/blob/main/LICENSE](https://github.com/thuml/Time-Series-Library/blob/main/LICENSE))

<figure>
  <img src="https://mintcdn.com/nixtla-old-docs/SxdTUKdxfJcIbFeU/neuralforecast/imgs_models/timesnet.png?fit=max&auto=format&n=SxdTUKdxfJcIbFeU&q=85&s=936a25ee5eb112ca3651611e18e9324a" alt="Figure 1. TimesNet Architecture." width="720" height="294" data-path="neuralforecast/imgs_models/timesnet.png" />

  <figcaption aria-hidden="true">Figure 1. TimesNet
  Architecture.</figcaption>
</figure>

## 1. Auxiliary Functions

***

<a href="https://github.com/Nixtla/neuralforecast/blob/main/neuralforecast/models/timesnet.py#L20" target="_blank" style={{ float: "right", fontSize: "smaller" }}>source</a>

### Inception\_Block\_V1

> ```text theme={null}
>  Inception_Block_V1 (in_channels, out_channels, num_kernels=6,
>                      init_weight=True)
> ```

*Inception\_Block\_V1*

***

<a href="https://github.com/Nixtla/neuralforecast/blob/main/neuralforecast/models/timesnet.py#L66" target="_blank" style={{ float: "right", fontSize: "smaller" }}>source</a>

### TimesBlock

> ```text theme={null}
>  TimesBlock (input_size, h, k, hidden_size, conv_hidden_size, num_kernels)
> ```

*TimesBlock*

***

<a href="https://github.com/Nixtla/neuralforecast/blob/main/neuralforecast/models/timesnet.py#L54" target="_blank" style={{ float: "right", fontSize: "smaller" }}>source</a>

### FFT\_for\_Period

> ```text theme={null}
>  FFT_for_Period (x, k=2)
> ```

## 2. TimesNet

***

<a href="https://github.com/Nixtla/neuralforecast/blob/main/neuralforecast/models/timesnet.py#L122" target="_blank" style={{ float: "right", fontSize: "smaller" }}>source</a>

### TimesNet

> ```text theme={null}
>  TimesNet (h:int, input_size:int, stat_exog_list=None,
>            hist_exog_list=None, futr_exog_list=None,
>            exclude_insample_y=False, hidden_size:int=64,
>            dropout:float=0.1, conv_hidden_size:int=64, top_k:int=5,
>            num_kernels:int=6, encoder_layers:int=2, loss=MAE(),
>            valid_loss=None, max_steps:int=1000,
>            learning_rate:float=0.0001, num_lr_decays:int=-1,
>            early_stop_patience_steps:int=-1, val_check_steps:int=100,
>            batch_size:int=32, valid_batch_size:Optional[int]=None,
>            windows_batch_size=64, inference_windows_batch_size=256,
>            start_padding_enabled=False, step_size:int=1,
>            scaler_type:str='standard', random_seed:int=1,
>            drop_last_loader:bool=False, alias:Optional[str]=None,
>            optimizer=None, optimizer_kwargs=None, lr_scheduler=None,
>            lr_scheduler_kwargs=None, dataloader_kwargs=None,
>            **trainer_kwargs)
> ```

\*TimesNet

The TimesNet univariate model tackles the challenge of modeling multiple
intraperiod and interperiod temporal variations.

**Parameters**<br /> `h` : int, Forecast horizon.<br /> `input_size` : int,
Length of input window (lags).<br /> `stat_exog_list` : list of str,
optional (default=None), Static exogenous columns.<br /> `hist_exog_list`
: list of str, optional (default=None), Historic exogenous columns.<br />
`futr_exog_list` : list of str, optional (default=None), Future
exogenous columns.<br /> `exclude_insample_y` : bool (default=False), The
model skips the autoregressive features y\[t-input\_size:t] if True.<br />
`hidden_size` : int (default=64), Size of embedding for embedding and
encoders.<br /> `dropout` : float between \[0, 1) (default=0.1), Dropout
for embeddings.<br /> `conv_hidden_size`: int (default=64), Channels of
the Inception block.<br /> `top_k`: int (default=5), Number of
periods.<br /> `num_kernels`: int (default=6), Number of kernels for the
Inception block.<br /> `encoder_layers` : int, (default=2), Number of
encoder layers.<br /> `loss`: PyTorch module (default=MAE()), Instantiated
train loss class from [losses
collection](https://nixtla.github.io/neuralforecast/losses.pytorch.html).
`valid_loss`: PyTorch module (default=None, uses loss), Instantiated
validation loss class from [losses
collection](https://nixtla.github.io/neuralforecast/losses.pytorch.html).<br />
`max_steps`: int (default=1000), Maximum number of training steps.<br />
`learning_rate` : float (default=1e-4), Learning rate.<br />
`num_lr_decays`: int (default=-1), Number of learning rate decays,
evenly distributed across max\_steps. If -1, no learning rate decay is
performed.<br /> `early_stop_patience_steps` : int (default=-1), Number of
validation iterations before early stopping. If -1, no early stopping is
performed.<br /> `val_check_steps` : int (default=100), Number of training
steps between every validation loss check.<br /> `batch_size` : int
(default=32), Number of different series in each batch.<br />
`valid_batch_size` : int (default=None), Number of different series in
each validation and test batch, if None uses batch\_size.<br />
`windows_batch_size` : int (default=64), Number of windows to sample in
each training batch.<br /> `inference_windows_batch_size` : int
(default=256), Number of windows to sample in each inference batch.<br />
`start_padding_enabled` : bool (default=False), If True, the model will
pad the time series with zeros at the beginning by input size.<br />
`step_size` : int (default=1), Step size between each window of temporal
data.<br /> `scaler_type` : str (default=‘standard’), Type of scaler for
temporal inputs normalization see [temporal
scalers](https://nixtla.github.io/neuralforecast/common.scalers.html).<br />
`random_seed` : int (default=1), Random\_seed for pytorch initializer and
numpy generators.<br /> `drop_last_loader` : bool (default=False), If True
`TimeSeriesDataLoader` drops last non-full batch.<br /> `alias` : str,
optional (default=None), Custom name of the model.<br /> `optimizer`:
Subclass of ‘torch.optim.Optimizer’, optional (default=None), User
specified optimizer instead of the default choice (Adam).<br />
`optimizer_kwargs`: dict, optional (defualt=None), List of parameters
used by the user specified `optimizer`.<br /> `lr_scheduler`: Subclass of
‘torch.optim.lr\_scheduler.LRScheduler’, optional, user specified
lr\_scheduler instead of the default choice (StepLR).<br />
`lr_scheduler_kwargs`: dict, optional, list of parameters used by the
user specified `lr_scheduler`.<br />\
`dataloader_kwargs`: dict, optional (default=None), List of parameters
passed into the PyTorch Lightning dataloader by the
`TimeSeriesDataLoader`. <br /> `**trainer_kwargs`: Keyword trainer
arguments inherited from [PyTorch Lighning’s
trainer](https://pytorch-lightning.readthedocs.io/en/stable/api/pytorch_lightning.trainer.trainer.Trainer.html?highlight=trainer)\*

***

### TimesNet.fit

> ```text theme={null}
>  TimesNet.fit (dataset, val_size=0, test_size=0, random_seed=None,
>                distributed_config=None)
> ```

\*Fit.

The `fit` method, optimizes the neural network’s weights using the
initialization parameters (`learning_rate`, `windows_batch_size`, …) and
the `loss` function as defined during the initialization. Within `fit`
we use a PyTorch Lightning `Trainer` that inherits the initialization’s
`self.trainer_kwargs`, to customize its inputs, see [PL’s trainer
arguments](https://pytorch-lightning.readthedocs.io/en/stable/api/pytorch_lightning.trainer.trainer.Trainer.html?highlight=trainer).

The method is designed to be compatible with SKLearn-like classes and in
particular to be compatible with the StatsForecast library.

By default the `model` is not saving training checkpoints to protect
disk memory, to get them change `enable_checkpointing=True` in
`__init__`.

**Parameters:**<br /> `dataset`: NeuralForecast’s
[`TimeSeriesDataset`](https://nixtlaverse.nixtla.io/neuralforecast/tsdataset.html#timeseriesdataset),
see
[documentation](https://nixtla.github.io/neuralforecast/tsdataset.html).<br />
`val_size`: int, validation size for temporal cross-validation.<br />
`random_seed`: int=None, random\_seed for pytorch initializer and numpy
generators, overwrites model.\_\_init\_\_’s.<br /> `test_size`: int, test
size for temporal cross-validation.<br />\*

***

### TimesNet.predict

> ```text theme={null}
>  TimesNet.predict (dataset, test_size=None, step_size=1, random_seed=None,
>                    quantiles=None, **data_module_kwargs)
> ```

\*Predict.

Neural network prediction with PL’s `Trainer` execution of
`predict_step`.

**Parameters:**<br /> `dataset`: NeuralForecast’s
[`TimeSeriesDataset`](https://nixtlaverse.nixtla.io/neuralforecast/tsdataset.html#timeseriesdataset),
see
[documentation](https://nixtla.github.io/neuralforecast/tsdataset.html).<br />
`test_size`: int=None, test size for temporal cross-validation.<br />
`step_size`: int=1, Step size between each window.<br /> `random_seed`:
int=None, random\_seed for pytorch initializer and numpy generators,
overwrites model.\_\_init\_\_’s.<br /> `quantiles`: list of floats,
optional (default=None), target quantiles to predict. <br />
`**data_module_kwargs`: PL’s TimeSeriesDataModule args, see
[documentation](https://pytorch-lightning.readthedocs.io/en/1.6.1/extensions/datamodules.html#using-a-datamodule).\*

## Usage Example

```python theme={null}
import pandas as pd
import matplotlib.pyplot as plt

from neuralforecast import NeuralForecast
from neuralforecast.losses.pytorch import DistributionLoss
from neuralforecast.utils import AirPassengersPanel, AirPassengersStatic

Y_train_df = AirPassengersPanel[AirPassengersPanel.ds<AirPassengersPanel['ds'].values[-12]] # 132 train
Y_test_df = AirPassengersPanel[AirPassengersPanel.ds>=AirPassengersPanel['ds'].values[-12]].reset_index(drop=True) # 12 test

model = TimesNet(h=12,
                 input_size=24,
                 hidden_size = 16,
                 conv_hidden_size = 32,
                 loss=DistributionLoss(distribution='Normal', level=[80, 90]),
                 scaler_type='standard',
                 learning_rate=1e-3,
                 max_steps=100,
                 val_check_steps=50,
                 early_stop_patience_steps=2)

nf = NeuralForecast(
    models=[model],
    freq='ME'
)
nf.fit(df=Y_train_df, static_df=AirPassengersStatic, val_size=12)
forecasts = nf.predict(futr_df=Y_test_df)

Y_hat_df = forecasts.reset_index(drop=False).drop(columns=['unique_id','ds'])
plot_df = pd.concat([Y_test_df, Y_hat_df], axis=1)
plot_df = pd.concat([Y_train_df, plot_df])

if model.loss.is_distribution_output:
    plot_df = plot_df[plot_df.unique_id=='Airline1'].drop('unique_id', axis=1)
    plt.plot(plot_df['ds'], plot_df['y'], c='black', label='True')
    plt.plot(plot_df['ds'], plot_df['TimesNet-median'], c='blue', label='median')
    plt.fill_between(x=plot_df['ds'][-12:], 
                    y1=plot_df['TimesNet-lo-90'][-12:].values, 
                    y2=plot_df['TimesNet-hi-90'][-12:].values,
                    alpha=0.4, label='level 90')
    plt.grid()
    plt.legend()
    plt.plot()
else:
    plot_df = plot_df[plot_df.unique_id=='Airline1'].drop('unique_id', axis=1)
    plt.plot(plot_df['ds'], plot_df['y'], c='black', label='True')
    plt.plot(plot_df['ds'], plot_df['TimesNet'], c='blue', label='Forecast')
    plt.legend()
    plt.grid()
```