XLinear

XLinear is a MLP-based model for multivariate time series forecasting that uses gating mechanisms for temporal and cross-channel interactions. The architecture consists of temporal gating with a global token to capture global temporal patterns, followed by cross-channel gating to model dependencies between different time series. References

Xinyang, C., et al. “XLinear: A Lightweight and Accurate MLP-Based Model for Long-Term Time Series Forecasting with Exogenous Inputs”

Figure 1. Architecture of XLinear

`XLinear`

XLinear(
    h,
    input_size,
    n_series,
    stat_exog_list=None,
    hist_exog_list=None,
    futr_exog_list=None,
    exclude_insample_y=False,
    hidden_size=128,
    temporal_ff=256,
    channel_ff=8,
    temporal_dropout=0.0,
    channel_dropout=0.0,
    embed_dropout=0.0,
    head_dropout=0.0,
    use_norm=True,
    loss=MAE(),
    valid_loss=None,
    max_steps=1000,
    learning_rate=0.001,
    num_lr_decays=-1,
    early_stop_patience_steps=-1,
    val_check_steps=100,
    batch_size=32,
    valid_batch_size=None,
    windows_batch_size=32,
    inference_windows_batch_size=32,
    start_padding_enabled=False,
    training_data_availability_threshold=0.0,
    step_size=1,
    scaler_type="identity",
    random_seed=1,
    drop_last_loader=False,
    alias=None,
    optimizer=None,
    optimizer_kwargs=None,
    lr_scheduler=None,
    lr_scheduler_kwargs=None,
    dataloader_kwargs=None,
    **trainer_kwargs
)

Bases: BaseModel XLinear XLinear is a linear-based model for multivariate time series forecasting that uses gating mechanisms for temporal and cross-channel interactions. The architecture consists of temporal gating with a global token to capture global temporal patterns, followed by cross-channel gating to model dependencies between different time series. Parameters:

Name	Type	Description	Default
`h`	`int`	Forecast horizon.	required
`input_size`	`int`	Input size, y=[1,2,3,4] input_size=2 -> lags=[1,2].	required
`n_series`	`int`	Number of time series.	required
`stat_exog_list`	`str list`	Static exogenous columns.	`None`
`hist_exog_list`	`str list`	Historic exogenous columns.	`None`
`futr_exog_list`	`str list`	Future exogenous columns.	`None`
`hidden_size`	`int`	Dimension of the model embedding.	`128`
`temporal_ff`	`int`	Dimension of temporal feedforward layer in gating block.	`256`
`channel_ff`	`int`	Dimension of cross-channel feedforward layer in gating block.	`8`
`temporal_dropout`	`float`	Dropout rate for temporal gating.	`0.0`
`channel_dropout`	`float`	Dropout rate for cross-channel gating.	`0.0`
`embed_dropout`	`float`	Dropout rate for embedding projection.	`0.0`
`head_dropout`	`float`	Dropout rate for output head.	`0.0`
`use_norm`	`bool`	Whether to use RevIN normalization.	`True`
`loss`	`PyTorch module`	Instantiated train loss class from losses collection.	`MAE()`
`valid_loss`	`PyTorch module`	Instantiated valid loss class from losses collection.	`None`
`max_steps`	`int`	Maximum number of training steps.	`1000`
`learning_rate`	`float`	Learning rate between (0, 1).	`0.001`
`num_lr_decays`	`int`	Number of learning rate decays, evenly distributed across max_steps.	`-1`
`early_stop_patience_steps`	`int`	Number of validation iterations before early stopping.	`-1`
`val_check_steps`	`int`	Number of training steps between every validation loss check.	`100`
`batch_size`	`int`	Number of different series in each batch.	`32`
`valid_batch_size`	`int`	Number of different series in each validation and test batch, if None uses batch_size.	`None`
`windows_batch_size`	`int`	Number of windows to sample in each training batch.	`32`
`inference_windows_batch_size`	`int`	Number of windows to sample in each inference batch, -1 uses all.	`32`
`start_padding_enabled`	`bool`	If True, the model will pad the time series with zeros at the beginning.	`False`
`training_data_availability_threshold`	`Union[float, List[float]]`	minimum fraction of valid data points required for training windows. Single float applies to both insample and outsample; list of two floats specifies [insample_fraction, outsample_fraction]. Default 0.0 allows windows with only 1 valid data point (current behavior).	`0.0`
`step_size`	`int`	Step size between each window of temporal data.	`1`
`scaler_type`	`str`	type of scaler for temporal inputs normalization see temporal scalers.	`‘identity’`
`random_seed`	`int`	Random seed for pytorch initializer and numpy generators.	`1`
`drop_last_loader`	`bool`	If True, TimeSeriesDataLoader drops last non-full batch.	`False`
`alias`	`str`	Optional custom name of the model.	`None`
`optimizer`	`Subclass of ‘torch.optim.Optimizer’`	Optional user specified optimizer.	`None`
`optimizer_kwargs`	`dict`	Optional list of parameters used by the user specified optimizer.	`None`
`lr_scheduler`	`Subclass of ‘torch.optim.lr_scheduler.LRScheduler’`	Optional user specified lr_scheduler.	`None`
`lr_scheduler_kwargs`	`dict`	Optional list of parameters used by the user specified lr_scheduler.	`None`
`dataloader_kwargs`	`dict`	optional, list of parameters passed into the PyTorch Lightning dataloader by the `TimeSeriesDataLoader`.	`None`
`**trainer_kwargs`	`keyword`	trainer arguments inherited from PyTorch Lighning’s trainer.

`XLinear.fit`

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. 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:

Name	Type	Description	Default
`dataset`	`TimeSeriesDataset`	NeuralForecast’s `TimeSeriesDataset`, see documentation.	required
`val_size`	`int`	Validation size for temporal cross-validation.	`0`
`random_seed`	`int`	Random seed for pytorch initializer and numpy generators, overwrites model.init’s.	`None`
`test_size`	`int`	Test size for temporal cross-validation.	`0`

Returns:

Type	Description
None

`XLinear.predict`

predict(
    dataset,
    test_size=None,
    step_size=1,
    random_seed=None,
    quantiles=None,
    h=None,
    explainer_config=None,
    **data_module_kwargs
)

Predict. Neural network prediction with PL’s Trainer execution of predict_step. Parameters:

Name	Type	Description	Default
`dataset`	`TimeSeriesDataset`	NeuralForecast’s `TimeSeriesDataset`, see documentation.	required
`test_size`	`int`	Test size for temporal cross-validation.	`None`
`step_size`	`int`	Step size between each window.	`1`
`random_seed`	`int`	Random seed for pytorch initializer and numpy generators, overwrites model.init’s.	`None`
`quantiles`	`list`	Target quantiles to predict.	`None`
`h`	`int`	Prediction horizon, if None, uses the model’s fitted horizon. Defaults to None.	`None`
`explainer_config`	`dict`	configuration for explanations.	`None`
`**data_module_kwargs`	`dict`	PL’s TimeSeriesDataModule args, see documentation.

Returns:

Type	Description
None

Usage Example

import pandas as pd
import matplotlib.pyplot as plt

from neuralforecast import NeuralForecast
from neuralforecast.models import XLinear
from neuralforecast.losses.pytorch import MAE
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 = XLinear(h=12, 
            input_size=24,
            n_series=2,
            stat_exog_list=['airline1'],
            hist_exog_list=["y_[lag12]"],
            futr_exog_list=['trend'],            
            loss = MAE(),
            scaler_type='robust',
            learning_rate=1e-3,
            max_steps=200,
            val_check_steps=10,
            early_stop_patience_steps=2)

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

# Plot predictions
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])

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['XLinear'], c='blue', label='median')
plt.grid()
plt.legend()
plt.plot()

​XLinear

​XLinear

​XLinear.fit

​XLinear.predict

​Usage Example

XLinear

`XLinear`

`XLinear.fit`

`XLinear.predict`

Usage Example