From 38882af8aa85cc4ba8208321f6d6b126b4999b1a Mon Sep 17 00:00:00 2001
From: Kashif Rasul <kashif.rasul@gmail.com>
Date: Thu, 7 Apr 2022 13:29:50 +0200
Subject: [PATCH] added ETSFormer

---
 etsformer/.typesafe           |   0
 etsformer/__init__.py         |   9 +
 etsformer/estimator.py        | 307 +++++++++++++++++++++
 etsformer/etsformer.ipynb     | 494 ++++++++++++++++++++++++++++++++++
 etsformer/lightning_module.py |  80 ++++++
 etsformer/module.py           | 286 ++++++++++++++++++++
 requirements.txt              |   1 +
 7 files changed, 1177 insertions(+)
 create mode 100644 etsformer/.typesafe
 create mode 100644 etsformer/__init__.py
 create mode 100644 etsformer/estimator.py
 create mode 100644 etsformer/etsformer.ipynb
 create mode 100644 etsformer/lightning_module.py
 create mode 100644 etsformer/module.py

diff --git a/etsformer/.typesafe b/etsformer/.typesafe
new file mode 100644
index 0000000..e69de29
diff --git a/etsformer/__init__.py b/etsformer/__init__.py
new file mode 100644
index 0000000..67f0a4e
--- /dev/null
+++ b/etsformer/__init__.py
@@ -0,0 +1,9 @@
+from .estimator import ETSformerEstimator
+from .lightning_module import ETSformerLightningModule
+from .module import ETSformerModel
+
+__all__ = [
+    "ETSformerModel",
+    "ETSformerLightningModule",
+    "ETSformerEstimator",
+]
diff --git a/etsformer/estimator.py b/etsformer/estimator.py
new file mode 100644
index 0000000..f50f11c
--- /dev/null
+++ b/etsformer/estimator.py
@@ -0,0 +1,307 @@
+from typing import Any, Dict, Iterable, List, Optional
+
+import torch
+from gluonts.core.component import validated
+from gluonts.dataset.common import Dataset
+from gluonts.dataset.field_names import FieldName
+from gluonts.itertools import Cyclic, IterableSlice, PseudoShuffled
+from gluonts.time_feature import TimeFeature, time_features_from_frequency_str
+from gluonts.torch.model.estimator import PyTorchLightningEstimator
+from gluonts.torch.model.predictor import PyTorchPredictor
+from gluonts.torch.modules.distribution_output import DistributionOutput, StudentTOutput
+from gluonts.torch.modules.loss import DistributionLoss, NegativeLogLikelihood
+from gluonts.torch.util import IterableDataset
+from gluonts.transform import (
+    AddAgeFeature,
+    AddObservedValuesIndicator,
+    AddTimeFeatures,
+    AsNumpyArray,
+    Chain,
+    ExpectedNumInstanceSampler,
+    InstanceSplitter,
+    RemoveFields,
+    SelectFields,
+    SetField,
+    TestSplitSampler,
+    Transformation,
+    ValidationSplitSampler,
+    VstackFeatures,
+)
+from gluonts.transform.sampler import InstanceSampler
+from torch.utils.data import DataLoader
+
+from lightning_module import ETSformerLightningModule
+from module import ETSformerModel
+
+PREDICTION_INPUT_NAMES = [
+    "feat_static_cat",
+    "feat_static_real",
+    "past_time_feat",
+    "past_target",
+    "past_observed_values",
+    "future_time_feat",
+]
+
+TRAINING_INPUT_NAMES = PREDICTION_INPUT_NAMES + [
+    "future_target",
+    "future_observed_values",
+]
+
+
+class ETSformerEstimator(PyTorchLightningEstimator):
+    @validated()
+    def __init__(
+        self,
+        freq: str,
+        prediction_length: int,
+        # ETSformer arguments
+        nhead: int,
+        num_layers: int = 2,
+        k_largest_amplitudes: int = 4,
+        embed_kernel_size: int = 3,
+        input_size: int = 1,
+        dropout: float = 0.1,
+        context_length: Optional[int] = None,
+        num_feat_dynamic_real: int = 0,
+        num_feat_static_cat: int = 0,
+        num_feat_static_real: int = 0,
+        cardinality: Optional[List[int]] = None,
+        embedding_dimension: Optional[List[int]] = None,
+        distr_output: DistributionOutput = StudentTOutput(),
+        loss: DistributionLoss = NegativeLogLikelihood(),
+        scaling: bool = True,
+        lags_seq: Optional[List[int]] = None,
+        time_features: Optional[List[TimeFeature]] = None,
+        num_parallel_samples: int = 100,
+        batch_size: int = 32,
+        num_batches_per_epoch: int = 50,
+        trainer_kwargs: Optional[Dict[str, Any]] = dict(),
+        train_sampler: Optional[InstanceSampler] = None,
+        validation_sampler: Optional[InstanceSampler] = None,
+    ) -> None:
+        trainer_kwargs = {
+            "max_epochs": 100,
+            **trainer_kwargs,
+        }
+        super().__init__(trainer_kwargs=trainer_kwargs)
+
+        self.freq = freq
+        self.context_length = (
+            context_length if context_length is not None else prediction_length
+        )
+        self.prediction_length = prediction_length
+        self.distr_output = distr_output
+        self.loss = loss
+
+        self.input_size = input_size
+        self.nhead = nhead
+        self.num_layers = num_layers
+        self.k_largest_amplitudes = k_largest_amplitudes
+        self.dropout = dropout
+        self.embed_kernel_size = embed_kernel_size
+
+        self.num_feat_dynamic_real = num_feat_dynamic_real
+        self.num_feat_static_cat = num_feat_static_cat
+        self.num_feat_static_real = num_feat_static_real
+        self.cardinality = (
+            cardinality if cardinality and num_feat_static_cat > 0 else [1]
+        )
+        self.embedding_dimension = embedding_dimension
+        self.scaling = scaling
+        self.lags_seq = lags_seq
+        self.time_features = (
+            time_features
+            if time_features is not None
+            else time_features_from_frequency_str(self.freq)
+        )
+
+        self.num_parallel_samples = num_parallel_samples
+        self.batch_size = batch_size
+        self.num_batches_per_epoch = num_batches_per_epoch
+
+        self.train_sampler = train_sampler or ExpectedNumInstanceSampler(
+            num_instances=1.0, min_future=prediction_length
+        )
+        self.validation_sampler = validation_sampler or ValidationSplitSampler(
+            min_future=prediction_length
+        )
+
+    def create_transformation(self) -> Transformation:
+        remove_field_names = []
+        if self.num_feat_static_real == 0:
+            remove_field_names.append(FieldName.FEAT_STATIC_REAL)
+        if self.num_feat_dynamic_real == 0:
+            remove_field_names.append(FieldName.FEAT_DYNAMIC_REAL)
+
+        return Chain(
+            [RemoveFields(field_names=remove_field_names)]
+            + (
+                [SetField(output_field=FieldName.FEAT_STATIC_CAT, value=[0])]
+                if not self.num_feat_static_cat > 0
+                else []
+            )
+            + (
+                [SetField(output_field=FieldName.FEAT_STATIC_REAL, value=[0.0])]
+                if not self.num_feat_static_real > 0
+                else []
+            )
+            + [
+                AsNumpyArray(
+                    field=FieldName.FEAT_STATIC_CAT,
+                    expected_ndim=1,
+                    dtype=int,
+                ),
+                AsNumpyArray(
+                    field=FieldName.FEAT_STATIC_REAL,
+                    expected_ndim=1,
+                ),
+                AsNumpyArray(
+                    field=FieldName.TARGET,
+                    # in the following line, we add 1 for the time dimension
+                    expected_ndim=1 + len(self.distr_output.event_shape),
+                ),
+                AddObservedValuesIndicator(
+                    target_field=FieldName.TARGET,
+                    output_field=FieldName.OBSERVED_VALUES,
+                ),
+                AddTimeFeatures(
+                    start_field=FieldName.START,
+                    target_field=FieldName.TARGET,
+                    output_field=FieldName.FEAT_TIME,
+                    time_features=self.time_features,
+                    pred_length=self.prediction_length,
+                ),
+                AddAgeFeature(
+                    target_field=FieldName.TARGET,
+                    output_field=FieldName.FEAT_AGE,
+                    pred_length=self.prediction_length,
+                    log_scale=True,
+                ),
+                VstackFeatures(
+                    output_field=FieldName.FEAT_TIME,
+                    input_fields=[FieldName.FEAT_TIME, FieldName.FEAT_AGE]
+                    + (
+                        [FieldName.FEAT_DYNAMIC_REAL]
+                        if self.num_feat_dynamic_real > 0
+                        else []
+                    ),
+                ),
+            ]
+        )
+
+    def _create_instance_splitter(self, module: ETSformerLightningModule, mode: str):
+        assert mode in ["training", "validation", "test"]
+
+        instance_sampler = {
+            "training": self.train_sampler,
+            "validation": self.validation_sampler,
+            "test": TestSplitSampler(),
+        }[mode]
+
+        return InstanceSplitter(
+            target_field=FieldName.TARGET,
+            is_pad_field=FieldName.IS_PAD,
+            start_field=FieldName.START,
+            forecast_start_field=FieldName.FORECAST_START,
+            instance_sampler=instance_sampler,
+            past_length=module.model._past_length,
+            future_length=self.prediction_length,
+            time_series_fields=[
+                FieldName.FEAT_TIME,
+                FieldName.OBSERVED_VALUES,
+            ],
+            dummy_value=self.distr_output.value_in_support,
+        )
+
+    def create_training_data_loader(
+        self,
+        data: Dataset,
+        module: ETSformerLightningModule,
+        shuffle_buffer_length: Optional[int] = None,
+        **kwargs,
+    ) -> Iterable:
+        transformation = self._create_instance_splitter(
+            module, "training"
+        ) + SelectFields(TRAINING_INPUT_NAMES)
+
+        training_instances = transformation.apply(
+            Cyclic(data)
+            if shuffle_buffer_length is None
+            else PseudoShuffled(
+                Cyclic(data), shuffle_buffer_length=shuffle_buffer_length
+            )
+        )
+
+        return IterableSlice(
+            iter(
+                DataLoader(
+                    IterableDataset(training_instances),
+                    batch_size=self.batch_size,
+                    **kwargs,
+                )
+            ),
+            self.num_batches_per_epoch,
+        )
+
+    def create_validation_data_loader(
+        self,
+        data: Dataset,
+        module: ETSformerLightningModule,
+        **kwargs,
+    ) -> Iterable:
+        transformation = self._create_instance_splitter(
+            module, "validation"
+        ) + SelectFields(TRAINING_INPUT_NAMES)
+
+        validation_instances = transformation.apply(data)
+
+        return DataLoader(
+            IterableDataset(validation_instances),
+            batch_size=self.batch_size,
+            **kwargs,
+        )
+
+    def create_predictor(
+        self,
+        transformation: Transformation,
+        module: ETSformerLightningModule,
+    ) -> PyTorchPredictor:
+        prediction_splitter = self._create_instance_splitter(module, "test")
+
+        return PyTorchPredictor(
+            input_transform=transformation + prediction_splitter,
+            input_names=PREDICTION_INPUT_NAMES,
+            prediction_net=module.model,
+            batch_size=self.batch_size,
+            freq=self.freq,
+            prediction_length=self.prediction_length,
+            device=torch.device("cuda" if torch.cuda.is_available() else "cpu"),
+        )
+
+    def create_lightning_module(self) -> ETSformerLightningModule:
+        model = ETSformerModel(
+            freq=self.freq,
+            context_length=self.context_length,
+            prediction_length=self.prediction_length,
+            num_feat_dynamic_real=1
+            + self.num_feat_dynamic_real
+            + len(self.time_features),
+            num_feat_static_real=max(1, self.num_feat_static_real),
+            num_feat_static_cat=max(1, self.num_feat_static_cat),
+            cardinality=self.cardinality,
+            embedding_dimension=self.embedding_dimension,
+            # ETSformer arguments
+            nhead=self.nhead,
+            num_layers=self.num_layers,
+            dropout=self.dropout,
+            k_largest_amplitudes=self.k_largest_amplitudes,
+            embed_kernel_size=self.embed_kernel_size,
+            # univariate input
+            input_size=self.input_size,
+            distr_output=self.distr_output,
+            lags_seq=self.lags_seq,
+            scaling=self.scaling,
+            num_parallel_samples=self.num_parallel_samples,
+        )
+
+        return ETSformerLightningModule(model=model, loss=self.loss)
diff --git a/etsformer/etsformer.ipynb b/etsformer/etsformer.ipynb
new file mode 100644
index 0000000..cc72ec6
--- /dev/null
+++ b/etsformer/etsformer.ipynb
@@ -0,0 +1,494 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "420561b7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline\n",
+    "from matplotlib import pyplot as plt\n",
+    "import matplotlib.dates as mdates\n",
+    "\n",
+    "from itertools import islice"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "b10c3dd3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/kashif/.env/pytorch/lib/python3.8/site-packages/xgboost/compat.py:36: FutureWarning: pandas.Int64Index is deprecated and will be removed from pandas in a future version. Use pandas.Index with the appropriate dtype instead.\n",
+      "  from pandas import MultiIndex, Int64Index\n"
+     ]
+    }
+   ],
+   "source": [
+    "from gluonts.evaluation import make_evaluation_predictions, Evaluator\n",
+    "from gluonts.dataset.repository.datasets import get_dataset\n",
+    "\n",
+    "from estimator import ETSformerEstimator"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "d018b7fb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dataset = get_dataset(\"electricity\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "e772234f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "estimator = ETSformerEstimator(\n",
+    "    freq=dataset.metadata.freq,\n",
+    "    prediction_length=dataset.metadata.prediction_length,\n",
+    "    context_length=dataset.metadata.prediction_length*2,\n",
+    "    \n",
+    "    # \n",
+    "    num_feat_static_cat=1,\n",
+    "    cardinality=[321],\n",
+    "    embedding_dimension=[3],\n",
+    "    \n",
+    "    # attention hyper-params\n",
+    "    nhead=2,\n",
+    "\n",
+    "    \n",
+    "    # training params\n",
+    "    batch_size=128,\n",
+    "    num_batches_per_epoch=100,\n",
+    "    trainer_kwargs=dict(max_epochs=50, accelerator='gpu', gpus=1),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "22d804e4",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/kashif/.env/pytorch/lib/python3.8/site-packages/pytorch_lightning/utilities/parsing.py:244: UserWarning: Attribute 'model' is an instance of `nn.Module` and is already saved during checkpointing. It is recommended to ignore them using `self.save_hyperparameters(ignore=['model'])`.\n",
+      "  rank_zero_warn(\n",
+      "/home/kashif/.env/pytorch/lib/python3.8/site-packages/pytorch_lightning/utilities/parsing.py:244: UserWarning: Attribute 'loss' is an instance of `nn.Module` and is already saved during checkpointing. It is recommended to ignore them using `self.save_hyperparameters(ignore=['loss'])`.\n",
+      "  rank_zero_warn(\n",
+      "GPU available: True, used: True\n",
+      "TPU available: False, using: 0 TPU cores\n",
+      "IPU available: False, using: 0 IPUs\n",
+      "HPU available: False, using: 0 HPUs\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  self._freq_base = start.freq.base\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  return _shift_timestamp_helper(ts, ts.freq, offset)\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  self._freq_base = start.freq.base\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  self._freq_base = start.freq.base\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  return _shift_timestamp_helper(ts, ts.freq, offset)\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  return _shift_timestamp_helper(ts, ts.freq, offset)\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  self._freq_base = start.freq.base\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  return _shift_timestamp_helper(ts, ts.freq, offset)\n",
+      "/home/kashif/.env/pytorch/lib/python3.8/site-packages/pytorch_lightning/trainer/configuration_validator.py:133: UserWarning: You defined a `validation_step` but have no `val_dataloader`. Skipping val loop.\n",
+      "  rank_zero_warn(\"You defined a `validation_step` but have no `val_dataloader`. Skipping val loop.\")\n",
+      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
+      "\n",
+      "  | Name  | Type                  | Params\n",
+      "------------------------------------------------\n",
+      "0 | model | ETSformerModel        | 52.2 K\n",
+      "1 | loss  | NegativeLogLikelihood | 0     \n",
+      "------------------------------------------------\n",
+      "52.2 K    Trainable params\n",
+      "0         Non-trainable params\n",
+      "52.2 K    Total params\n",
+      "0.209     Total estimated model params size (MB)\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  self._freq_base = start.freq.base\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  return _shift_timestamp_helper(ts, ts.freq, offset)\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  self._freq_base = start.freq.base\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  return _shift_timestamp_helper(ts, ts.freq, offset)\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  ..., i0 : i0 + length * start.freq.n : start.freq.n\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  self._freq_base = start.freq.base\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  return _shift_timestamp_helper(ts, ts.freq, offset)\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  self._freq_base is None or self._freq_base == start.freq.base\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  ..., i0 : i0 + length * start.freq.n : start.freq.n\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  ..., i0 : i0 + length * start.freq.n : start.freq.n\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  ..., i0 : i0 + length * start.freq.n : start.freq.n\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  self._freq_base = start.freq.base\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  return _shift_timestamp_helper(ts, ts.freq, offset)\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  ..., i0 : i0 + length * start.freq.n : start.freq.n\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  ..., i0 : i0 + length * start.freq.n : start.freq.n\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  self._freq_base is None or self._freq_base == start.freq.base\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  self._freq_base is None or self._freq_base == start.freq.base\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  self._freq_base is None or self._freq_base == start.freq.base\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  ..., i0 : i0 + length * start.freq.n : start.freq.n\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  self._freq_base is None or self._freq_base == start.freq.base\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  self._freq_base is None or self._freq_base == start.freq.base\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  ..., i0 : i0 + length * start.freq.n : start.freq.n\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  self._freq_base is None or self._freq_base == start.freq.base\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  self._freq_base is None or self._freq_base == start.freq.base\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "6392f69ecca64a4f9cf30fa5d58337a1",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Training: 0it [00:00, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0, global step 100: 'train_loss' reached 6.83650 (best 6.83650), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/etsformer/lightning_logs/version_3/checkpoints/epoch=0-step=100.ckpt' as top 1\n",
+      "Epoch 1, global step 200: 'train_loss' reached 6.16099 (best 6.16099), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/etsformer/lightning_logs/version_3/checkpoints/epoch=1-step=200.ckpt' as top 1\n",
+      "Epoch 2, global step 300: 'train_loss' reached 6.03977 (best 6.03977), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/etsformer/lightning_logs/version_3/checkpoints/epoch=2-step=300.ckpt' as top 1\n",
+      "Epoch 3, global step 400: 'train_loss' reached 5.96518 (best 5.96518), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/etsformer/lightning_logs/version_3/checkpoints/epoch=3-step=400.ckpt' as top 1\n",
+      "Epoch 4, global step 500: 'train_loss' reached 5.92151 (best 5.92151), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/etsformer/lightning_logs/version_3/checkpoints/epoch=4-step=500.ckpt' as top 1\n",
+      "Epoch 5, global step 600: 'train_loss' reached 5.88383 (best 5.88383), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/etsformer/lightning_logs/version_3/checkpoints/epoch=5-step=600.ckpt' as top 1\n",
+      "Epoch 6, global step 700: 'train_loss' reached 5.84047 (best 5.84047), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/etsformer/lightning_logs/version_3/checkpoints/epoch=6-step=700.ckpt' as top 1\n",
+      "Epoch 7, global step 800: 'train_loss' was not in top 1\n",
+      "Epoch 8, global step 900: 'train_loss' was not in top 1\n",
+      "Epoch 9, global step 1000: 'train_loss' reached 5.83049 (best 5.83049), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/etsformer/lightning_logs/version_3/checkpoints/epoch=9-step=1000.ckpt' as top 1\n",
+      "Epoch 10, global step 1100: 'train_loss' reached 5.80265 (best 5.80265), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/etsformer/lightning_logs/version_3/checkpoints/epoch=10-step=1100.ckpt' as top 1\n",
+      "Epoch 11, global step 1200: 'train_loss' was not in top 1\n",
+      "Epoch 12, global step 1300: 'train_loss' reached 5.78531 (best 5.78531), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/etsformer/lightning_logs/version_3/checkpoints/epoch=12-step=1300.ckpt' as top 1\n",
+      "Epoch 13, global step 1400: 'train_loss' reached 5.77739 (best 5.77739), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/etsformer/lightning_logs/version_3/checkpoints/epoch=13-step=1400.ckpt' as top 1\n",
+      "Epoch 14, global step 1500: 'train_loss' was not in top 1\n",
+      "Epoch 15, global step 1600: 'train_loss' reached 5.73936 (best 5.73936), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/etsformer/lightning_logs/version_3/checkpoints/epoch=15-step=1600.ckpt' as top 1\n",
+      "Epoch 16, global step 1700: 'train_loss' was not in top 1\n",
+      "Epoch 17, global step 1800: 'train_loss' was not in top 1\n",
+      "Epoch 18, global step 1900: 'train_loss' was not in top 1\n",
+      "Epoch 19, global step 2000: 'train_loss' reached 5.71629 (best 5.71629), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/etsformer/lightning_logs/version_3/checkpoints/epoch=19-step=2000.ckpt' as top 1\n",
+      "Epoch 20, global step 2100: 'train_loss' was not in top 1\n",
+      "Epoch 21, global step 2200: 'train_loss' was not in top 1\n",
+      "Epoch 22, global step 2300: 'train_loss' was not in top 1\n",
+      "Epoch 23, global step 2400: 'train_loss' reached 5.70743 (best 5.70743), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/etsformer/lightning_logs/version_3/checkpoints/epoch=23-step=2400.ckpt' as top 1\n",
+      "Epoch 24, global step 2500: 'train_loss' was not in top 1\n",
+      "Epoch 25, global step 2600: 'train_loss' was not in top 1\n",
+      "Epoch 26, global step 2700: 'train_loss' reached 5.70683 (best 5.70683), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/etsformer/lightning_logs/version_3/checkpoints/epoch=26-step=2700.ckpt' as top 1\n",
+      "Epoch 27, global step 2800: 'train_loss' reached 5.68871 (best 5.68871), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/etsformer/lightning_logs/version_3/checkpoints/epoch=27-step=2800.ckpt' as top 1\n",
+      "Epoch 28, global step 2900: 'train_loss' reached 5.68410 (best 5.68410), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/etsformer/lightning_logs/version_3/checkpoints/epoch=28-step=2900.ckpt' as top 1\n",
+      "Epoch 29, global step 3000: 'train_loss' was not in top 1\n",
+      "Epoch 30, global step 3100: 'train_loss' reached 5.67481 (best 5.67481), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/etsformer/lightning_logs/version_3/checkpoints/epoch=30-step=3100.ckpt' as top 1\n",
+      "Epoch 31, global step 3200: 'train_loss' reached 5.65723 (best 5.65723), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/etsformer/lightning_logs/version_3/checkpoints/epoch=31-step=3200.ckpt' as top 1\n",
+      "Epoch 32, global step 3300: 'train_loss' was not in top 1\n",
+      "Epoch 33, global step 3400: 'train_loss' was not in top 1\n",
+      "Epoch 34, global step 3500: 'train_loss' was not in top 1\n",
+      "Epoch 35, global step 3600: 'train_loss' was not in top 1\n",
+      "Epoch 36, global step 3700: 'train_loss' was not in top 1\n",
+      "Epoch 37, global step 3800: 'train_loss' was not in top 1\n",
+      "Epoch 38, global step 3900: 'train_loss' was not in top 1\n",
+      "Epoch 39, global step 4000: 'train_loss' was not in top 1\n",
+      "Epoch 40, global step 4100: 'train_loss' was not in top 1\n",
+      "Epoch 41, global step 4200: 'train_loss' was not in top 1\n",
+      "Epoch 42, global step 4300: 'train_loss' was not in top 1\n",
+      "Epoch 43, global step 4400: 'train_loss' was not in top 1\n",
+      "Epoch 44, global step 4500: 'train_loss' was not in top 1\n",
+      "Epoch 45, global step 4600: 'train_loss' reached 5.65159 (best 5.65159), saving model to '/mnt/scratch/kashif/pytorch-transformer-ts/etsformer/lightning_logs/version_3/checkpoints/epoch=45-step=4600.ckpt' as top 1\n",
+      "Epoch 46, global step 4700: 'train_loss' was not in top 1\n",
+      "Epoch 47, global step 4800: 'train_loss' was not in top 1\n",
+      "Epoch 48, global step 4900: 'train_loss' was not in top 1\n",
+      "Epoch 49, global step 5000: 'train_loss' was not in top 1\n"
+     ]
+    }
+   ],
+   "source": [
+    "predictor = estimator.train(\n",
+    "    training_data=dataset.train,\n",
+    "    num_workers=8,\n",
+    "    shuffle_buffer_length=1024\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "11a47d5a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "forecast_it, ts_it = make_evaluation_predictions(\n",
+    "    dataset=dataset.test, \n",
+    "    predictor=predictor\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "e4e94932",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  self._freq_base = start.freq.base\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  return _shift_timestamp_helper(ts, ts.freq, offset)\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  ..., i0 : i0 + length * start.freq.n : start.freq.n\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  self._freq_base is None or self._freq_base == start.freq.base\n"
+     ]
+    }
+   ],
+   "source": [
+    "forecasts = list(forecast_it)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "17c5e570",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tss = list(ts_it)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "9985be71",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "evaluator = Evaluator()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "cca60b1e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Running evaluation: 2247it [00:00, 4924.54it/s]/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  date_before_forecast = forecast.index[0] - forecast.index[0].freq\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  date_before_forecast = forecast.index[0] - forecast.index[0].freq\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  date_before_forecast = forecast.index[0] - forecast.index[0].freq\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  date_before_forecast = forecast.index[0] - forecast.index[0].freq\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  date_before_forecast = forecast.index[0] - forecast.index[0].freq\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  date_before_forecast = forecast.index[0] - forecast.index[0].freq\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  date_before_forecast = forecast.index[0] - forecast.index[0].freq\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  date_before_forecast = forecast.index[0] - forecast.index[0].freq\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  date_before_forecast = forecast.index[0] - forecast.index[0].freq\n",
+      "\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  date_before_forecast = forecast.index[0] - forecast.index[0].freq\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  date_before_forecast = forecast.index[0] - forecast.index[0].freq\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  date_before_forecast = forecast.index[0] - forecast.index[0].freq\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  date_before_forecast = forecast.index[0] - forecast.index[0].freq\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  date_before_forecast = forecast.index[0] - forecast.index[0].freq\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  date_before_forecast = forecast.index[0] - forecast.index[0].freq\n",
+      "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n",
+      "  date_before_forecast = forecast.index[0] - forecast.index[0].freq\n",
+      "/home/kashif/.env/pytorch/lib/python3.8/site-packages/pandas/core/construction.py:781: UserWarning: Warning: converting a masked element to nan.\n",
+      "  subarr = np.array(arr, dtype=dtype, copy=copy)\n"
+     ]
+    }
+   ],
+   "source": [
+    "agg_metrics, ts_metrics = evaluator(iter(tss), iter(forecasts))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "92389256",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'MSE': 2405696.9162869295,\n",
+       " 'abs_error': 10426922.300764084,\n",
+       " 'abs_target_sum': 128632956.0,\n",
+       " 'abs_target_mean': 2385.272140631954,\n",
+       " 'seasonal_error': 189.49338196116761,\n",
+       " 'MASE': 0.9046918475206022,\n",
+       " 'MAPE': 0.13628862122431049,\n",
+       " 'sMAPE': 0.12878806848051888,\n",
+       " 'MSIS': 8.437463235791425,\n",
+       " 'QuantileLoss[0.1]': 3981099.9491350194,\n",
+       " 'Coverage[0.1]': 0.07975448746476783,\n",
+       " 'QuantileLoss[0.2]': 6389192.250024781,\n",
+       " 'Coverage[0.2]': 0.13746105919003115,\n",
+       " 'QuantileLoss[0.3]': 8211433.885405607,\n",
+       " 'Coverage[0.3]': 0.1896417445482866,\n",
+       " 'QuantileLoss[0.4]': 9542885.989697104,\n",
+       " 'Coverage[0.4]': 0.2402462542649458,\n",
+       " 'QuantileLoss[0.5]': 10426922.319201306,\n",
+       " 'Coverage[0.5]': 0.2942256341789052,\n",
+       " 'QuantileLoss[0.6]': 10963723.530763008,\n",
+       " 'Coverage[0.6]': 0.35145008159026847,\n",
+       " 'QuantileLoss[0.7]': 10917687.92765279,\n",
+       " 'Coverage[0.7]': 0.42515947188844383,\n",
+       " 'QuantileLoss[0.8]': 10156566.021311926,\n",
+       " 'Coverage[0.8]': 0.5211763833259161,\n",
+       " 'QuantileLoss[0.9]': 8273664.033297701,\n",
+       " 'Coverage[0.9]': 0.658989764129951,\n",
+       " 'RMSE': 1551.0309204806103,\n",
+       " 'NRMSE': 0.6502532327693562,\n",
+       " 'ND': 0.08105949381093353,\n",
+       " 'wQuantileLoss[0.1]': 0.030949300031129032,\n",
+       " 'wQuantileLoss[0.2]': 0.04966994811209019,\n",
+       " 'wQuantileLoss[0.3]': 0.0638361594162977,\n",
+       " 'wQuantileLoss[0.4]': 0.07418694467145033,\n",
+       " 'wQuantileLoss[0.5]': 0.08105949395426554,\n",
+       " 'wQuantileLoss[0.6]': 0.08523261745429381,\n",
+       " 'wQuantileLoss[0.7]': 0.08487473402735757,\n",
+       " 'wQuantileLoss[0.8]': 0.07895772854129175,\n",
+       " 'wQuantileLoss[0.9]': 0.06431994016601547,\n",
+       " 'mean_absolute_QuantileLoss': 8762575.100721026,\n",
+       " 'mean_wQuantileLoss': 0.0681207629304657,\n",
+       " 'MAE_Coverage': 0.1779883466020538,\n",
+       " 'OWA': nan}"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agg_metrics"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "23878611",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x1080 with 9 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(20, 15))\n",
+    "date_formater = mdates.DateFormatter('%b, %d')\n",
+    "plt.rcParams.update({'font.size': 15})\n",
+    "\n",
+    "for idx, (forecast, ts) in islice(enumerate(zip(forecasts, tss)), 9):\n",
+    "    ax = plt.subplot(3, 3, idx+1)\n",
+    "\n",
+    "    plt.plot(ts[-4 * dataset.metadata.prediction_length:], label=\"target\", )\n",
+    "    forecast.plot( color='g')\n",
+    "    plt.xticks(rotation=60)\n",
+    "    plt.title(forecast.item_id)\n",
+    "    ax.xaxis.set_major_formatter(date_formater)\n",
+    "\n",
+    "plt.gcf().tight_layout()\n",
+    "plt.legend()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f34e7aa7",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/etsformer/lightning_module.py b/etsformer/lightning_module.py
new file mode 100644
index 0000000..184d406
--- /dev/null
+++ b/etsformer/lightning_module.py
@@ -0,0 +1,80 @@
+import pytorch_lightning as pl
+import torch
+from gluonts.torch.modules.loss import DistributionLoss, NegativeLogLikelihood
+from gluonts.torch.util import weighted_average
+
+from module import ETSformerModel
+
+
+class ETSformerLightningModule(pl.LightningModule):
+    def __init__(
+        self,
+        model: ETSformerModel,
+        loss: DistributionLoss = NegativeLogLikelihood(),
+        lr: float = 1e-3,
+        weight_decay: float = 1e-8,
+    ) -> None:
+        super().__init__()
+        self.save_hyperparameters()
+        self.model = model
+        self.loss = loss
+        self.lr = lr
+        self.weight_decay = weight_decay
+
+    def training_step(self, batch, batch_idx: int):
+        """Execute training step"""
+        train_loss = self(batch)
+        self.log(
+            "train_loss",
+            train_loss,
+            on_epoch=True,
+            on_step=False,
+            prog_bar=True,
+        )
+        return train_loss
+
+    def validation_step(self, batch, batch_idx: int):
+        """Execute validation step"""
+        with torch.inference_mode():
+            val_loss = self(batch)
+        self.log("val_loss", val_loss, on_epoch=True, on_step=False, prog_bar=True)
+        return val_loss
+
+    def configure_optimizers(self):
+        """Returns the optimizer to use"""
+        return torch.optim.Adam(
+            self.model.parameters(),
+            lr=self.lr,
+            weight_decay=self.weight_decay,
+        )
+
+    def forward(self, batch):
+        feat_static_cat = batch["feat_static_cat"]
+        feat_static_real = batch["feat_static_real"]
+        past_time_feat = batch["past_time_feat"]
+        past_target = batch["past_target"]
+        future_time_feat = batch["future_time_feat"]
+        future_target = batch["future_target"]
+        past_observed_values = batch["past_observed_values"]
+        future_observed_values = batch["future_observed_values"]
+
+        etsformer_inputs, scale, _ = self.model.create_network_inputs(
+            feat_static_cat,
+            feat_static_real,
+            past_time_feat,
+            past_target,
+            past_observed_values,
+            future_time_feat,
+            future_target,
+        )
+        params = self.model.output_params(etsformer_inputs)
+        distr = self.model.output_distribution(params, scale)
+
+        loss_values = self.loss(distr, future_target)
+
+        if len(self.model.target_shape) == 0:
+            loss_weights = future_observed_values
+        else:
+            loss_weights = future_observed_values.min(dim=-1, keepdim=False)
+
+        return weighted_average(loss_values, weights=loss_weights)
diff --git a/etsformer/module.py b/etsformer/module.py
new file mode 100644
index 0000000..36337f6
--- /dev/null
+++ b/etsformer/module.py
@@ -0,0 +1,286 @@
+from typing import List, Optional
+
+import torch
+import torch.nn as nn
+from etsformer_pytorch import ETSFormer
+from gluonts.core.component import validated
+from gluonts.time_feature import get_lags_for_frequency
+from gluonts.torch.modules.distribution_output import DistributionOutput, StudentTOutput
+from gluonts.torch.modules.feature import FeatureEmbedder
+from gluonts.torch.modules.scaler import MeanScaler, NOPScaler
+
+
+class ETSformerModel(nn.Module):
+    @validated()
+    def __init__(
+        self,
+        freq: str,
+        context_length: int,
+        prediction_length: int,
+        num_feat_dynamic_real: int,
+        num_feat_static_real: int,
+        num_feat_static_cat: int,
+        cardinality: List[int],
+        # ETSformer arguments
+        k_largest_amplitudes: int,
+        embed_kernel_size: int,
+        nhead: int,
+        num_layers: int,
+        dropout: float = 0.1,
+        # univariate input
+        input_size: int = 1,
+        embedding_dimension: Optional[List[int]] = None,
+        distr_output: DistributionOutput = StudentTOutput(),
+        lags_seq: Optional[List[int]] = None,
+        scaling: bool = True,
+        num_parallel_samples: int = 100,
+    ) -> None:
+        super().__init__()
+
+        self.input_size = input_size
+
+        self.target_shape = distr_output.event_shape
+        self.num_feat_dynamic_real = num_feat_dynamic_real
+        self.num_feat_static_cat = num_feat_static_cat
+        self.num_feat_static_real = num_feat_static_real
+        self.embedding_dimension = (
+            embedding_dimension
+            if embedding_dimension is not None or cardinality is None
+            else [min(50, (cat + 1) // 2) for cat in cardinality]
+        )
+        self.lags_seq = lags_seq or get_lags_for_frequency(freq_str=freq)
+        self.num_parallel_samples = num_parallel_samples
+        self.history_length = context_length + max(self.lags_seq)
+        self.embedder = FeatureEmbedder(
+            cardinalities=cardinality,
+            embedding_dims=self.embedding_dimension,
+        )
+        if scaling:
+            self.scaler = MeanScaler(dim=1, keepdim=True)
+        else:
+            self.scaler = NOPScaler(dim=1, keepdim=True)
+
+        # total feature size
+        d_model = self.input_size * len(self.lags_seq) + self._number_of_features
+
+        self.context_length = context_length
+        self.prediction_length = prediction_length
+        self.distr_output = distr_output
+        self.param_proj = distr_output.get_args_proj(d_model)
+
+        # ETSformer enc-decoder
+        self.etsformer = ETSFormer(
+            time_features=d_model,
+            model_dim=d_model,
+            embed_kernel_size=embed_kernel_size,
+            K=k_largest_amplitudes,
+            layers=num_layers,
+            heads=nhead,
+            dropout=dropout,
+        )
+
+    @property
+    def _number_of_features(self) -> int:
+        return (
+            sum(self.embedding_dimension)
+            + self.num_feat_dynamic_real
+            + self.num_feat_static_real
+            + 1  # the log(scale)
+        )
+
+    @property
+    def _past_length(self) -> int:
+        return self.context_length + max(self.lags_seq)
+
+    def get_lagged_subsequences(
+        self, sequence: torch.Tensor, subsequences_length: int, shift: int = 0
+    ) -> torch.Tensor:
+        """
+        Returns lagged subsequences of a given sequence.
+        Parameters
+        ----------
+        sequence : Tensor
+            the sequence from which lagged subsequences should be extracted.
+            Shape: (N, T, C).
+        subsequences_length : int
+            length of the subsequences to be extracted.
+        shift: int
+            shift the lags by this amount back.
+        Returns
+        --------
+        lagged : Tensor
+            a tensor of shape (N, S, C, I), where S = subsequences_length and
+            I = len(indices), containing lagged subsequences. Specifically,
+            lagged[i, j, :, k] = sequence[i, -indices[k]-S+j, :].
+        """
+        sequence_length = sequence.shape[1]
+        indices = [lag - shift for lag in self.lags_seq]
+
+        assert max(indices) + subsequences_length <= sequence_length, (
+            f"lags cannot go further than history length, found lag {max(indices)} "
+            f"while history length is only {sequence_length}"
+        )
+
+        lagged_values = []
+        for lag_index in indices:
+            begin_index = -lag_index - subsequences_length
+            end_index = -lag_index if lag_index > 0 else None
+            lagged_values.append(sequence[:, begin_index:end_index, ...])
+        return torch.stack(lagged_values, dim=-1)
+
+    def _check_shapes(
+        self,
+        prior_input: torch.Tensor,
+        inputs: torch.Tensor,
+        features: Optional[torch.Tensor],
+    ) -> None:
+        assert len(prior_input.shape) == len(inputs.shape)
+        assert (
+            len(prior_input.shape) == 2 and self.input_size == 1
+        ) or prior_input.shape[2] == self.input_size
+        assert (len(inputs.shape) == 2 and self.input_size == 1) or inputs.shape[
+            -1
+        ] == self.input_size
+        assert (
+            features is None or features.shape[2] == self._number_of_features
+        ), f"{features.shape[2]}, expected {self._number_of_features}"
+
+    def create_network_inputs(
+        self,
+        feat_static_cat: torch.Tensor,
+        feat_static_real: torch.Tensor,
+        past_time_feat: torch.Tensor,
+        past_target: torch.Tensor,
+        past_observed_values: torch.Tensor,
+        future_time_feat: Optional[torch.Tensor] = None,
+        future_target: Optional[torch.Tensor] = None,
+    ):
+        # time feature
+        time_feat = (
+            torch.cat(
+                (
+                    past_time_feat[:, self._past_length - self.context_length :, ...],
+                    future_time_feat,
+                ),
+                dim=1,
+            )
+            if future_target is not None
+            else past_time_feat[:, self._past_length - self.context_length :, ...]
+        )
+
+        # target
+        context = past_target[:, -self.context_length :]
+        observed_context = past_observed_values[:, -self.context_length :]
+        _, scale = self.scaler(context, observed_context)
+
+        inputs = (
+            torch.cat((past_target, future_target), dim=1) / scale
+            if future_target is not None
+            else past_target / scale
+        )
+
+        inputs_length = (
+            self._past_length + self.prediction_length
+            if future_target is not None
+            else self._past_length
+        )
+        assert inputs.shape[1] == inputs_length
+
+        subsequences_length = (
+            self.context_length + self.prediction_length
+            if future_target is not None
+            else self.context_length
+        )
+
+        # embeddings
+        embedded_cat = self.embedder(feat_static_cat)
+        static_feat = torch.cat(
+            (embedded_cat, feat_static_real, scale.log()),
+            dim=1,
+        )
+        expanded_static_feat = static_feat.unsqueeze(1).expand(
+            -1, time_feat.shape[1], -1
+        )
+
+        features = torch.cat((expanded_static_feat, time_feat), dim=-1)
+
+        # self._check_shapes(prior_input, inputs, features)
+
+        # sequence = torch.cat((prior_input, inputs), dim=1)
+        lagged_sequence = self.get_lagged_subsequences(
+            sequence=inputs,
+            subsequences_length=subsequences_length,
+        )
+
+        lags_shape = lagged_sequence.shape
+        reshaped_lagged_sequence = lagged_sequence.reshape(
+            lags_shape[0], lags_shape[1], -1
+        )
+
+        transformer_inputs = torch.cat((reshaped_lagged_sequence, features), dim=-1)
+
+        return transformer_inputs, scale, static_feat
+
+    def output_params(self, transformer_inputs):
+        enc_input = transformer_inputs[:, : self.context_length, ...]
+
+        dec_output = self.etsformer(
+            enc_input, num_steps_forecast=self.prediction_length
+        )
+
+        return self.param_proj(dec_output)
+
+    @torch.jit.ignore
+    def output_distribution(
+        self, params, scale=None, trailing_n=None
+    ) -> torch.distributions.Distribution:
+        sliced_params = params
+        if trailing_n is not None:
+            sliced_params = [p[:, -trailing_n:] for p in params]
+        return self.distr_output.distribution(sliced_params, scale=scale)
+
+    # for prediction
+    def forward(
+        self,
+        feat_static_cat: torch.Tensor,
+        feat_static_real: torch.Tensor,
+        past_time_feat: torch.Tensor,
+        past_target: torch.Tensor,
+        past_observed_values: torch.Tensor,
+        future_time_feat: torch.Tensor,
+        num_parallel_samples: Optional[int] = None,
+    ) -> torch.Tensor:
+
+        if num_parallel_samples is None:
+            num_parallel_samples = self.num_parallel_samples
+
+        encoder_inputs, scale, _ = self.create_network_inputs(
+            feat_static_cat,
+            feat_static_real,
+            past_time_feat,
+            past_target,
+            past_observed_values,
+        )
+
+        dec_out = self.etsformer(
+            encoder_inputs, num_steps_forecast=self.prediction_length
+        )
+        params = self.param_proj(dec_out)
+
+        repeated_params = [
+            s.repeat_interleave(repeats=self.num_parallel_samples, dim=0)
+            for s in params
+        ]
+
+        repeated_scale = scale.repeat_interleave(
+            repeats=self.num_parallel_samples, dim=0
+        )
+
+        distr = self.output_distribution(repeated_params, scale=repeated_scale)
+
+        # Future samples
+        samples = distr.sample()
+
+        return samples.reshape(
+            (-1, self.num_parallel_samples, self.prediction_length) + self.target_shape,
+        )
diff --git a/requirements.txt b/requirements.txt
index 6b8d7a6..ce127cb 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -4,3 +4,4 @@ pytorch-lightning
 datasets
 xformers
 https://github.com/ml-jku/hopfield-layers
+etsformer-pytorch