diff --git a/perceiverar/.typesafe b/perceiverar/.typesafe
new file mode 100644
index 0000000..e69de29
diff --git a/perceiverar/__init__.py b/perceiverar/__init__.py
new file mode 100644
index 0000000..b9e05a9
--- /dev/null
+++ b/perceiverar/__init__.py
@@ -0,0 +1,22 @@
+# Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License").
+# You may not use this file except in compliance with the License.
+# A copy of the License is located at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# or in the "license" file accompanying this file. This file is distributed
+# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+# express or implied. See the License for the specific language governing
+# permissions and limitations under the License.
+
+from .module import PerceiverARModel
+from .lightning_module import PerceiverARLightningModule
+from .estimator import PerceiverAREstimator
+
+__all__ = [
+    "PerceiverARModel",
+    "PerceiverARLightningModule",
+    "PerceiverAREstimator",
+]
diff --git a/perceiverar/estimator.py b/perceiverar/estimator.py
new file mode 100644
index 0000000..144512d
--- /dev/null
+++ b/perceiverar/estimator.py
@@ -0,0 +1,384 @@
+from typing import List, Optional, Iterable, Dict, Any
+
+import torch
+from torch.utils.data import DataLoader
+
+from gluonts.core.component import validated
+from gluonts.dataset.common import Dataset
+from gluonts.dataset.field_names import FieldName
+from gluonts.itertools import Cyclic, PseudoShuffled, IterableSlice
+from gluonts.time_feature import (
+    TimeFeature,
+    time_features_from_frequency_str,
+)
+from gluonts.torch.modules.loss import DistributionLoss, NegativeLogLikelihood
+from gluonts.transform import (
+    Transformation,
+    Chain,
+    RemoveFields,
+    SetField,
+    AsNumpyArray,
+    AddObservedValuesIndicator,
+    AddTimeFeatures,
+    AddAgeFeature,
+    VstackFeatures,
+    InstanceSplitter,
+    ValidationSplitSampler,
+    TestSplitSampler,
+    ExpectedNumInstanceSampler,
+    SelectFields,
+)
+from gluonts.torch.util import (
+    IterableDataset,
+)
+from gluonts.torch.model.estimator import PyTorchLightningEstimator
+from gluonts.torch.model.predictor import PyTorchPredictor
+from gluonts.torch.distributions import (
+    DistributionOutput,
+    StudentTOutput,
+)
+from gluonts.transform.sampler import InstanceSampler
+
+from module import PerceiverARModel
+from lightning_module import PerceiverARLightningModule
+
+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 PerceiverAREstimator(PyTorchLightningEstimator):
+    """
+    Estimator class to train a PerceiverAR model.
+
+    This class is uses the model defined in ``PerceiverARModel``, and wraps it
+    into a ``PerceiverARLightningModule`` for training purposes: training is
+    performed using PyTorch Lightning's ``pl.Trainer`` class.
+
+    Parameters
+    ----------
+    freq
+        Frequency of the data to train on and predict.
+    prediction_length
+        Length of the prediction horizon.
+    context_length
+        Number of steps to unroll the RNN for before computing predictions
+        (default: None, in which case context_length = prediction_length).
+    perceive_depth
+        Number of RNN layers (default: 2).
+    hidden_size
+        Number of RNN cells for each layer (default: 40).
+    dropout_rate
+        Dropout regularization parameter (default: 0.1).
+    num_feat_dynamic_real
+        Number of dynamic real features in the data (default: 0).
+    num_feat_static_real
+        Number of static real features in the data (default: 0).
+    num_feat_static_cat
+        Number of static categorical features in the data (default: 0).
+    cardinality
+        Number of values of each categorical feature.
+        This must be set if ``num_feat_static_cat > 0`` (default: None).
+    embedding_dimension
+        Dimension of the embeddings for categorical features
+        (default: ``[min(50, (cat+1)//2) for cat in cardinality]``).
+    distr_output
+        Distribution to use to evaluate observations and sample predictions
+        (default: StudentTOutput()).
+    loss
+        Loss to be optimized during training
+        (default: ``NegativeLogLikelihood()``).
+    scaling
+        Whether to automatically scale the target values (default: true).
+    lags_seq
+        Indices of the lagged target values to use as inputs of the RNN
+        (default: None, in which case these are automatically determined
+        based on freq).
+    time_features
+        List of time features, from :py:mod:`gluonts.time_feature`, to use as
+        inputs of the RNN in addition to the provided data (default: None,
+        in which case these are automatically determined based on freq).
+    num_parallel_samples
+        Number of samples per time series to that the resulting predictor
+        should produce (default: 100).
+    batch_size
+        The size of the batches to be used for training (default: 32).
+    num_batches_per_epoch
+        Number of batches to be processed in each training epoch
+        (default: 50).
+    trainer_kwargs
+        Additional arguments to provide to ``pl.Trainer`` for construction.
+    train_sampler
+        Controls the sampling of windows during training.
+    validation_sampler
+        Controls the sampling of windows during validation.
+    """
+
+    @validated()
+    def __init__(
+        self,
+        freq: str,
+        prediction_length: int,
+        depth: int,
+        context_length: Optional[int] = None,
+        perceive_depth: int = 1,
+        heads: int = 2,
+        hidden_size: int = 32,
+        dropout_rate: float = 0.1,
+        cross_attn_dropout: float = 0.1,
+        perceive_max_heads_process: int = 2,
+        ff_mult: int = 1,
+        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]] = None,
+        train_sampler: Optional[InstanceSampler] = None,
+        validation_sampler: Optional[InstanceSampler] = None,
+    ) -> None:
+        default_trainer_kwargs = {
+            "max_epochs": 100,
+            "gradient_clip_val": 10.0,
+        }
+        if trainer_kwargs is not None:
+            default_trainer_kwargs.update(trainer_kwargs)
+        super().__init__(trainer_kwargs=default_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.depth = depth
+        self.perceive_depth = perceive_depth
+        self.hidden_size = hidden_size
+        self.dropout_rate = dropout_rate
+        self.heads = heads
+        self.perceive_max_heads_process = perceive_max_heads_process
+        self.ff_mult = ff_mult
+        self.cross_attn_dropout = cross_attn_dropout
+        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: PerceiverARLightningModule, 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: PerceiverARLightningModule,
+        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: PerceiverARLightningModule,
+        **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_lightning_module(self) -> PerceiverARLightningModule:
+        model = PerceiverARModel(
+            freq=self.freq,
+            depth=self.depth,
+            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,
+            perceive_depth=self.perceive_depth,
+            heads=self.heads,
+            perceive_max_heads_process=self.perceive_max_heads_process,
+            ff_mult=self.ff_mult,
+            cross_attn_dropout=self.cross_attn_dropout,
+            hidden_size=self.hidden_size,
+            distr_output=self.distr_output,
+            dropout_rate=self.dropout_rate,
+            lags_seq=self.lags_seq,
+            scaling=self.scaling,
+            num_parallel_samples=self.num_parallel_samples,
+        )
+
+        return PerceiverARLightningModule(model=model, loss=self.loss)
+
+    def create_predictor(
+        self,
+        transformation: Transformation,
+        module: PerceiverARLightningModule,
+    ) -> 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,
+            prediction_length=self.prediction_length,
+            device=torch.device("cuda" if torch.cuda.is_available() else "cpu"),
+        )
diff --git a/perceiverar/lightning_module.py b/perceiverar/lightning_module.py
new file mode 100644
index 0000000..bbf828b
--- /dev/null
+++ b/perceiverar/lightning_module.py
@@ -0,0 +1,113 @@
+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 PerceiverARModel
+
+
+class PerceiverARLightningModule(pl.LightningModule):
+    """
+    A ``pl.LightningModule`` class that can be used to train a
+    ``PerceiverARModel`` with PyTorch Lightning.
+
+    This is a thin layer around a (wrapped) ``PerceiverARModel`` object,
+    that exposes the methods to evaluate training and validation loss.
+
+    Parameters
+    ----------
+    model
+        ``PerceiverARModel`` to be trained.
+    loss
+        Loss function to be used for training,
+        default: ``NegativeLogLikelihood()``.
+    lr
+        Learning rate, default: ``1e-3``.
+    weight_decay
+        Weight decay regularization parameter, default: ``1e-8``.
+    """
+
+    def __init__(
+        self,
+        model: PerceiverARModel,
+        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 _compute_loss(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"]
+
+        params, scale, _, _, _ = self.model.lagged_perciever(
+            feat_static_cat,
+            feat_static_real,
+            past_time_feat,
+            past_target,
+            past_observed_values,
+            future_time_feat,
+            future_target,
+        )
+        distr = self.model.output_distribution(params, scale)
+
+        # context_target = past_target[:, -self.model.context_length + 1 :]
+        # target = torch.cat(
+        #     (context_target, future_target),
+        #     dim=1,
+        # )
+        loss_values = self.loss(distr, future_target)
+
+        # context_observed = past_observed_values[:, -self.model.context_length + 1 :]
+        # observed_values = torch.cat((context_observed, future_observed_values), dim=1)
+
+        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)
+
+    def training_step(self, batch, batch_idx: int):  # type: ignore
+        """
+        Execute training step.
+        """
+        train_loss = self._compute_loss(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):  # type: ignore
+        """
+        Execute validation step.
+        """
+        val_loss = self._compute_loss(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,
+        )
diff --git a/perceiverar/module.py b/perceiverar/module.py
new file mode 100644
index 0000000..c9be3ae
--- /dev/null
+++ b/perceiverar/module.py
@@ -0,0 +1,568 @@
+from typing import List, Optional, Tuple
+
+import torch
+import torch.nn as nn
+from torch import einsum
+
+from einops import rearrange, repeat
+
+from gluonts.core.component import validated
+from gluonts.time_feature import get_lags_for_frequency
+from gluonts.torch.distributions import (
+    DistributionOutput,
+    StudentTOutput,
+)
+from gluonts.torch.modules.scaler import MeanScaler, NOPScaler
+from gluonts.torch.modules.feature import FeatureEmbedder
+from gluonts.torch.util import lagged_sequence_values
+
+# helper functions
+def exists(val):
+    return val is not None
+
+
+# feedforward
+def FeedForward(dim, mult=4, dropout=0.0):
+    hidden_dim = int(dim * mult)
+    return nn.Sequential(
+        nn.LayerNorm(dim),
+        nn.Linear(dim, hidden_dim, bias=False),
+        nn.GELU(),
+        nn.Dropout(dropout),
+        nn.Linear(hidden_dim, dim, bias=False),
+    )
+
+
+# attention
+class CausalAttention(nn.Module):
+    def __init__(self, *, dim, dim_head=64, heads=8, dropout=0.0):
+        super().__init__()
+        self.scale = dim_head**-0.5
+        self.heads = heads
+        inner_dim = heads * dim_head
+
+        self.norm = nn.LayerNorm(dim)
+        self.dropout = nn.Dropout(dropout)
+        self.to_qkv = nn.Linear(dim, inner_dim * 3, bias=False)
+        self.to_out = nn.Linear(inner_dim, dim, bias=False)
+
+    def forward(self, x):
+        x = self.norm(x)
+
+        q, k, v = self.to_qkv(x).chunk(3, dim=-1)
+        q, k, v = map(
+            lambda t: rearrange(t, "b n (h d) -> b h n d", h=self.heads), (q, k, v)
+        )
+
+        q = q * self.scale
+
+        sim = einsum("b h i d, b h j d -> b h i j", q, k)
+
+        i, j = sim.shape[-2:]
+        causal_mask = torch.ones((i, j), device=x.device, dtype=torch.bool).triu(
+            j - i + 1
+        )
+        sim = sim.masked_fill(causal_mask, -torch.finfo(sim.dtype).max)
+
+        attn = sim.softmax(dim=-1)
+        attn = self.dropout(attn)
+
+        out = einsum("b h i j, b h j d -> b h i d", attn, v)
+
+        out = rearrange(out, "b h n d -> b n (h d)")
+        return self.to_out(out)
+
+
+class CausalPrefixAttention(nn.Module):
+    def __init__(
+        self,
+        *,
+        dim,
+        dim_head=64,
+        heads=8,
+        max_heads_process=2,
+        dropout=0.0,
+        cross_attn_dropout=0.0
+    ):
+        super().__init__()
+        self.scale = dim_head**-0.5
+        self.heads = heads
+        self.max_heads_process = max_heads_process
+
+        inner_dim = heads * dim_head
+
+        self.norm = nn.LayerNorm(dim)
+        self.context_norm = nn.LayerNorm(dim)
+        self.dropout = nn.Dropout(dropout)
+
+        self.cross_attn_dropout = cross_attn_dropout  # they drop out a percentage of the prefix during training, shown to help prevent overfitting
+
+        self.to_q = nn.Linear(dim, inner_dim, bias=False)
+        self.to_kv = nn.Linear(dim, inner_dim * 2, bias=False)
+        self.to_out = nn.Linear(inner_dim, dim)
+
+    def forward(self, x, context, context_mask=None):
+        batch, context_len, device = x.shape[0], context.shape[-2], x.device
+
+        # take care of cross attention dropout
+        if self.training and self.cross_attn_dropout > 0.0:
+            rand = torch.zeros((batch, context_len), device=device).uniform_()
+            keep_context_len = context_len - int(context_len * self.cross_attn_dropout)
+            keep_indices = rand.topk(keep_context_len, dim=-1).indices
+            keep_mask = torch.zeros_like(rand).scatter_(1, keep_indices, 1).bool()
+
+            context = rearrange(context[keep_mask], "(b n) d -> b n d", b=batch)
+
+            if exists(context_mask):
+                context_mask = rearrange(
+                    context_mask[keep_mask], "(b n) -> b n", b=batch
+                )
+
+        # normalization
+        x = self.norm(x)
+        context = self.context_norm(context)
+
+        # derive queries, keys, values
+        q = self.to_q(x)
+
+        k_input, v_input = self.to_kv(x).chunk(2, dim=-1)
+        k_context, v_context = self.to_kv(context).chunk(2, dim=-1)
+
+        k = torch.cat((k_context, k_input), dim=1)
+        v = torch.cat((v_context, v_input), dim=1)
+
+        q, k, v = map(
+            lambda t: rearrange(t, "b n (h d) -> b h n d", h=self.heads), (q, k, v)
+        )
+        q = q * self.scale
+
+        # take care of masking
+        i, j = q.shape[-2], k.shape[-2]
+        mask_value = -torch.finfo(q.dtype).max
+
+        if exists(context_mask):
+            mask_len = context_mask.shape[-1]
+            context_mask = F.pad(context_mask, (0, max(j - mask_len, 0)), value=True)
+            context_mask = rearrange(context_mask, "b j -> b 1 1 j")
+
+        causal_mask = torch.ones((i, j), device=x.device, dtype=torch.bool).triu(
+            j - i + 1
+        )
+
+        # process in chunks of heads
+        out = []
+        max_heads = self.max_heads_process
+        for q_chunk, k_chunk, v_chunk in zip(
+            q.split(max_heads, dim=1),
+            k.split(max_heads, dim=1),
+            v.split(max_heads, dim=1),
+        ):
+            sim = einsum("b h i d, b h j d -> b h i j", q_chunk, k_chunk)
+
+            if exists(context_mask):
+                sim = sim.masked_fill(~context_mask, mask_value)
+
+            sim = sim.masked_fill(causal_mask, mask_value)
+
+            attn = sim.softmax(dim=-1)
+            attn = self.dropout(attn)
+
+            out_chunk = einsum("b h i j, b h j d -> b h i d", attn, v_chunk)
+            out.append(out_chunk)
+
+        # concat all the heads together
+        out = torch.cat(out, dim=1)
+
+        # merge heads and then combine with linear
+        out = rearrange(out, "b h n d -> b n (h d)")
+
+        return self.to_out(out)
+
+
+class PerceiverARModel(nn.Module):
+    """
+    Module implementing the PerceiverAR model.
+
+    Parameters
+    ----------
+    freq
+        String indicating the sampling frequency of the data to be processed.
+    context_length
+        Length of the RNN unrolling prior to the forecast date.
+    prediction_length
+        Number of time points to predict.
+    num_feat_dynamic_real
+        Number of dynamic real features that will be provided to ``forward``.
+    num_feat_static_real
+        Number of static real features that will be provided to ``forward``.
+    num_feat_static_cat
+        Number of static categorical features that will be provided to
+        ``forward``.
+    cardinality
+        List of cardinalities, one for each static categorical feature.
+    embedding_dimension
+        Dimension of the embedding space, one for each static categorical
+        feature.
+    num_layers
+        Number of layers in the RNN.
+    hidden_size
+        Size of the hidden layers in the RNN.
+    dropout_rate
+        Dropout rate to be applied at training time.
+    distr_output
+        Type of distribution to be output by the model at each time step
+    lags_seq
+        Indices of the lagged observations that the RNN takes as input. For
+        example, ``[1]`` indicates that the RNN only takes the observation at
+        time ``t-1`` to produce the output for time ``t``; instead,
+        ``[1, 25]`` indicates that the RNN takes observations at times ``t-1``
+        and ``t-25`` as input.
+    scaling
+        Whether to apply mean scaling to the observations (target).
+    num_parallel_samples
+        Number of samples to produce when unrolling the RNN in the prediction
+        time range.
+    """
+
+    @validated()
+    def __init__(
+        self,
+        freq: str,
+        depth: int,
+        context_length: int,
+        prediction_length: int,
+        num_feat_dynamic_real: int,
+        num_feat_static_real: int,
+        num_feat_static_cat: int,
+        cardinality: List[int],
+        embedding_dimension: Optional[List[int]] = None,
+        perceive_depth: int = 1,
+        heads: int = 2,
+        perceive_max_heads_process: int = 2,
+        ff_mult: int = 1,
+        hidden_size: int = 32,
+        dropout_rate: float = 0.1,
+        cross_attn_dropout: float = 0.1,
+        distr_output: DistributionOutput = StudentTOutput(),
+        lags_seq: Optional[List[int]] = None,
+        scaling: bool = True,
+        num_parallel_samples: int = 100,
+    ) -> None:
+        super().__init__()
+
+        self.context_length = context_length
+        self.prediction_length = prediction_length
+        self.distr_output = distr_output
+        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.past_length = self.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)
+
+        dim_head = len(self.lags_seq) + self._number_of_features
+
+        self.perceive_layers = nn.ModuleList([])
+        for _ in range(perceive_depth):
+            self.perceive_layers.append(
+                nn.ModuleList(
+                    [
+                        CausalPrefixAttention(
+                            dim=dim_head,
+                            dim_head=hidden_size,
+                            heads=heads,
+                            max_heads_process=perceive_max_heads_process,
+                            dropout=dropout_rate,
+                            cross_attn_dropout=cross_attn_dropout,
+                        ),
+                        FeedForward(dim_head, mult=ff_mult, dropout=dropout_rate),
+                    ]
+                )
+            )
+
+        self.layers = nn.ModuleList([])
+        for _ in range(depth):
+            self.layers.append(
+                nn.ModuleList(
+                    [
+                        CausalAttention(
+                            dim=dim_head, dim_head=hidden_size, heads=heads
+                        ),
+                        FeedForward(dim_head, mult=ff_mult, dropout=dropout_rate),
+                    ]
+                )
+            )
+
+        self.param_proj = distr_output.get_args_proj(dim_head)
+
+    @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 lagged_perciever(
+        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,
+    ) -> Tuple[
+        Tuple[torch.Tensor, ...],
+        torch.Tensor,
+        torch.Tensor,
+        torch.Tensor,
+        Tuple[torch.Tensor, torch.Tensor],
+    ]:
+        """
+        Applies the underlying RNN to the provided target data and covariates.
+
+        Parameters
+        ----------
+        feat_static_cat
+            Tensor of static categorical features,
+            shape: ``(batch_size, num_feat_static_cat)``.
+        feat_static_real
+            Tensor of static real features,
+            shape: ``(batch_size, num_feat_static_real)``.
+        past_time_feat
+            Tensor of dynamic real features in the past,
+            shape: ``(batch_size, past_length, num_feat_dynamic_real)``.
+        past_target
+            Tensor of past target values,
+            shape: ``(batch_size, past_length, *target_shape)``.
+        past_observed_values
+            Tensor of observed values indicators,
+            shape: ``(batch_size, past_length)``.
+        future_time_feat
+            (Optional) tensor of dynamic real features in the past,
+            shape: ``(batch_size, prediction_length, num_feat_dynamic_real)``.
+        future_target
+            (Optional) tensor of future target values,
+            shape: ``(batch_size, prediction_length, *target_shape)``.
+
+        Returns
+        -------
+        Tuple
+            A tuple containing, in this order:
+            - Parameters of the output distribution
+            - Scaling factor applied to the target
+            - Raw output of the RNN
+            - Static input to the RNN
+            - Output state from the RNN
+        """
+        context = past_target[:, -self.context_length :]
+        observed_context = past_observed_values[:, -self.context_length :]
+        _, scale = self.scaler(context, observed_context)
+
+        prior_input = past_target[:, : -self.context_length] / scale
+        input = (
+            torch.cat((context, future_target[:, :-1]), dim=1) / scale
+            if future_target is not None
+            else context / scale
+        )
+
+        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, input.shape[1], -1)
+
+        time_feat = (
+            torch.cat(
+                (
+                    past_time_feat[:, -self.context_length + 1 :, ...],
+                    future_time_feat,
+                ),
+                dim=1,
+            )
+            if future_time_feat is not None
+            else past_time_feat[:, -self.context_length + 1 :, ...]
+        )
+
+        features = torch.cat((expanded_static_feat, time_feat), dim=-1)
+        lags = lagged_sequence_values(self.lags_seq, prior_input, input)
+        perciever_input = torch.cat((lags, features), dim=-1)
+
+        prefix, x = (
+            perciever_input[:, : self.context_length - 1, ...],
+            perciever_input[:, self.context_length - 1 :, ...],
+        )
+
+        # initial perceiver attention and feedforward (one cross attention)
+        for cross_attn, ff in self.perceive_layers:
+            x = cross_attn(x, prefix) + x
+            x = ff(x) + x
+
+        # layers
+        for attn, ff in self.layers:
+            x = attn(x) + x
+            x = ff(x) + x
+
+        # output
+        params = self.param_proj(x)
+        return (
+            params,
+            scale,
+            static_feat,
+            perciever_input[:, : self.context_length - 1, ...],
+            perciever_input[:, self.context_length - 1 :, ...],
+        )
+
+    @torch.jit.ignore
+    def output_distribution(
+        self, params, scale=None, trailing_n=None
+    ) -> torch.distributions.Distribution:
+        """
+        Instantiate the output distribution
+
+        Parameters
+        ----------
+        params
+            Tuple of distribution parameters.
+        scale
+            (Optional) scale tensor.
+        trailing_n
+            If set, the output distribution is created only for the last
+            ``trailing_n`` time points.
+
+        Returns
+        -------
+        torch.distributions.Distribution
+            Output distribution from the model.
+        """
+        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)
+
+    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:
+        """
+        Invokes the model on input data, and produce outputs future samples.
+
+        Parameters
+        ----------
+        feat_static_cat
+            Tensor of static categorical features,
+            shape: ``(batch_size, num_feat_static_cat)``.
+        feat_static_real
+            Tensor of static real features,
+            shape: ``(batch_size, num_feat_static_real)``.
+        past_time_feat
+            Tensor of dynamic real features in the past,
+            shape: ``(batch_size, past_length, num_feat_dynamic_real)``.
+        past_target
+            Tensor of past target values,
+            shape: ``(batch_size, past_length, *target_shape)``.
+        past_observed_values
+            Tensor of observed values indicators,
+            shape: ``(batch_size, past_length)``.
+        future_time_feat
+            (Optional) tensor of dynamic real features in the past,
+            shape: ``(batch_size, prediction_length, num_feat_dynamic_real)``.
+        num_parallel_samples
+            How many future samples to produce.
+            By default, self.num_parallel_samples is used.
+        """
+        if num_parallel_samples is None:
+            num_parallel_samples = self.num_parallel_samples
+
+        params, scale, static_feat, prefix, x = self.lagged_perciever(
+            feat_static_cat,
+            feat_static_real,
+            past_time_feat,
+            past_target,
+            past_observed_values,
+            future_time_feat[:, :1],
+        )
+
+        repeated_scale = scale.repeat_interleave(repeats=num_parallel_samples, dim=0)
+        repeated_static_feat = static_feat.repeat_interleave(
+            repeats=num_parallel_samples, dim=0
+        ).unsqueeze(dim=1)
+        repeated_past_target = (
+            past_target.repeat_interleave(repeats=num_parallel_samples, dim=0)
+            / repeated_scale
+        )
+        repeated_time_feat = future_time_feat.repeat_interleave(
+            repeats=num_parallel_samples, dim=0
+        )
+        repeated_prefix = prefix.repeat_interleave(repeats=num_parallel_samples, dim=0)
+        repeated_x = x.repeat_interleave(repeats=num_parallel_samples, dim=0)
+        repeated_params = [
+            s.repeat_interleave(repeats=num_parallel_samples, dim=0) for s in params
+        ]
+        distr = self.output_distribution(
+            repeated_params, trailing_n=1, scale=repeated_scale
+        )
+        next_sample = distr.sample()
+        future_samples = [next_sample]
+
+        # greedy sampling
+        for k in range(1, self.prediction_length):
+            scaled_next_sample = next_sample / repeated_scale
+            next_features = torch.cat(
+                (repeated_static_feat, repeated_time_feat[:, k : k + 1]),
+                dim=-1,
+            )
+            next_lags = lagged_sequence_values(
+                self.lags_seq,
+                repeated_past_target,
+                scaled_next_sample,
+            )
+            perciever_input = torch.cat((next_lags, next_features), dim=-1)
+
+            repeated_x = torch.cat((repeated_x, perciever_input), dim=1)
+            x = repeated_x
+            for cross_attn, ff in self.perceive_layers:
+                x = cross_attn(x, repeated_prefix) + x
+                x = ff(x) + x
+
+            for attn, ff in self.layers:
+                x = attn(x) + x
+                x = ff(x) + x
+
+            params = self.param_proj(x[:, -1:])
+            distr = self.output_distribution(params, scale=repeated_scale)
+            next_sample = distr.sample()
+            future_samples.append(next_sample)
+
+        future_samples_concat = torch.cat(future_samples, dim=1)
+
+        return future_samples_concat.reshape(
+            (-1, num_parallel_samples, self.prediction_length) + self.target_shape,
+        )
diff --git a/perceiverar/perceiverar.ipynb b/perceiverar/perceiverar.ipynb
new file mode 100644
index 0000000..6d4f559
--- /dev/null
+++ b/perceiverar/perceiverar.ipynb
@@ -0,0 +1,334 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "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,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from gluonts.evaluation import make_evaluation_predictions, Evaluator\n",
+    "from gluonts.dataset.repository.datasets import get_dataset\n",
+    "\n",
+    "from estimator import PerceiverAREstimator"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dataset = get_dataset(\"electricity\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "estimator = PerceiverAREstimator(\n",
+    "    depth=2,\n",
+    "    freq=dataset.metadata.freq,\n",
+    "    prediction_length=dataset.metadata.prediction_length,\n",
+    "    context_length=dataset.metadata.prediction_length*10,\n",
+    "    num_feat_static_cat=1,\n",
+    "    cardinality=[321],\n",
+    "    embedding_dimension=[3],\n",
+    "\n",
+    "    batch_size=128,\n",
+    "    num_batches_per_epoch=100,\n",
+    "    trainer_kwargs=dict(max_epochs=20, accelerator='cpu'),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/opt/homebrew/lib/python3.9/site-packages/pytorch_lightning/utilities/parsing.py:261: 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",
+      "GPU available: True (mps), used: False\n",
+      "TPU available: False, using: 0 TPU cores\n",
+      "IPU available: False, using: 0 IPUs\n",
+      "HPU available: False, using: 0 HPUs\n",
+      "/opt/homebrew/lib/python3.9/site-packages/pytorch_lightning/trainer/trainer.py:1788: UserWarning: MPS available but not used. Set `accelerator` and `devices` using `Trainer(accelerator='mps', devices=1)`.\n",
+      "  rank_zero_warn(\n",
+      "/opt/homebrew/lib/python3.9/site-packages/pytorch_lightning/trainer/configuration_validator.py:117: PossibleUserWarning: You defined a `validation_step` but have no `val_dataloader`. Skipping val loop.\n",
+      "  rank_zero_warn(\n",
+      "\n",
+      "  | Name  | Type             | Params\n",
+      "-------------------------------------------\n",
+      "0 | model | PerceiverARModel | 55.3 K\n",
+      "-------------------------------------------\n",
+      "55.3 K    Trainable params\n",
+      "0         Non-trainable params\n",
+      "55.3 K    Total params\n",
+      "0.221     Total estimated model params size (MB)\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "58d0f0d6928843179f47158819b0373b",
+       "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.39245 (best 6.39245), saving model to '/Users/kashif/Documents/GitHub/pytorch-transformer-ts/perceiverar/lightning_logs/version_16/checkpoints/epoch=0-step=100.ckpt' as top 1\n",
+      "Epoch 1, global step 200: 'train_loss' reached 5.74574 (best 5.74574), saving model to '/Users/kashif/Documents/GitHub/pytorch-transformer-ts/perceiverar/lightning_logs/version_16/checkpoints/epoch=1-step=200.ckpt' as top 1\n",
+      "Epoch 2, global step 300: 'train_loss' reached 5.66502 (best 5.66502), saving model to '/Users/kashif/Documents/GitHub/pytorch-transformer-ts/perceiverar/lightning_logs/version_16/checkpoints/epoch=2-step=300.ckpt' as top 1\n",
+      "Epoch 3, global step 400: 'train_loss' was not in top 1\n",
+      "Epoch 4, global step 500: 'train_loss' was not in top 1\n",
+      "Epoch 5, global step 600: 'train_loss' reached 5.53011 (best 5.53011), saving model to '/Users/kashif/Documents/GitHub/pytorch-transformer-ts/perceiverar/lightning_logs/version_16/checkpoints/epoch=5-step=600.ckpt' as top 1\n",
+      "Epoch 6, global step 700: 'train_loss' reached 5.47067 (best 5.47067), saving model to '/Users/kashif/Documents/GitHub/pytorch-transformer-ts/perceiverar/lightning_logs/version_16/checkpoints/epoch=6-step=700.ckpt' as top 1\n",
+      "Epoch 7, global step 800: 'train_loss' reached 5.46909 (best 5.46909), saving model to '/Users/kashif/Documents/GitHub/pytorch-transformer-ts/perceiverar/lightning_logs/version_16/checkpoints/epoch=7-step=800.ckpt' as 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.40471 (best 5.40471), saving model to '/Users/kashif/Documents/GitHub/pytorch-transformer-ts/perceiverar/lightning_logs/version_16/checkpoints/epoch=9-step=1000.ckpt' as 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": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "forecast_it, ts_it = make_evaluation_predictions(\n",
+    "    dataset=dataset.test,\n",
+    "    predictor=predictor\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "forecasts = list(forecast_it)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tss = list(ts_it)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Running evaluation: 100%|██████████████████████████████████████████████████████████████████████████████████████████| 2247/2247 [00:00<00:00, 28388.12it/s]\n",
+      "/Users/kashif/Github/gluon-ts/src/gluonts/evaluation/_base.py:361: RuntimeWarning: divide by zero encountered in float_scalars\n",
+      "  metrics[\"ND\"] = cast(float, metrics[\"abs_error\"]) / cast(\n",
+      "/Users/kashif/Github/gluon-ts/src/gluonts/evaluation/_base.py:361: RuntimeWarning: divide by zero encountered in float_scalars\n",
+      "  metrics[\"ND\"] = cast(float, metrics[\"abs_error\"]) / cast(\n",
+      "/opt/homebrew/lib/python3.9/site-packages/pandas/core/dtypes/cast.py:1181: UserWarning: Warning: converting a masked element to nan.\n",
+      "  return arr.astype(dtype, copy=True)\n"
+     ]
+    }
+   ],
+   "source": [
+    "evaluator = Evaluator()\n",
+    "agg_metrics, ts_metrics = evaluator(iter(tss), iter(forecasts), num_series=len(dataset.test))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'MSE': 51121382.50806745,\n",
+       " 'abs_error': 45470724.97791672,\n",
+       " 'abs_target_sum': 128632956.0,\n",
+       " 'abs_target_mean': 2385.272140631954,\n",
+       " 'seasonal_error': 189.49338196116761,\n",
+       " 'MASE': 3.3772790741328946,\n",
+       " 'MAPE': 0.5094233835707134,\n",
+       " 'sMAPE': 0.34459815313825437,\n",
+       " 'MSIS': 61.44150428863099,\n",
+       " 'QuantileLoss[0.1]': 51517043.98430869,\n",
+       " 'Coverage[0.1]': 0.4415146120753597,\n",
+       " 'QuantileLoss[0.2]': 53234031.51177651,\n",
+       " 'Coverage[0.2]': 0.4857031597685803,\n",
+       " 'QuantileLoss[0.3]': 52016127.051792935,\n",
+       " 'Coverage[0.3]': 0.5158359293873312,\n",
+       " 'QuantileLoss[0.4]': 49268952.23515242,\n",
+       " 'Coverage[0.4]': 0.5437249666221629,\n",
+       " 'QuantileLoss[0.5]': 45470724.63391817,\n",
+       " 'Coverage[0.5]': 0.5712616822429907,\n",
+       " 'QuantileLoss[0.6]': 40701344.414245784,\n",
+       " 'Coverage[0.6]': 0.6007454383622608,\n",
+       " 'QuantileLoss[0.7]': 34925618.19069028,\n",
+       " 'Coverage[0.7]': 0.6430982050140928,\n",
+       " 'QuantileLoss[0.8]': 27873758.177450046,\n",
+       " 'Coverage[0.8]': 0.7015279632102063,\n",
+       " 'QuantileLoss[0.9]': 18876041.64433915,\n",
+       " 'Coverage[0.9]': 0.7819685506601394,\n",
+       " 'RMSE': 7149.921853283954,\n",
+       " 'NRMSE': 2.9975287647428166,\n",
+       " 'ND': 0.35349203183915573,\n",
+       " 'wQuantileLoss[0.1]': 0.4004964636302744,\n",
+       " 'wQuantileLoss[0.2]': 0.4138444234444593,\n",
+       " 'wQuantileLoss[0.3]': 0.40437636410837774,\n",
+       " 'wQuantileLoss[0.4]': 0.38301966904307494,\n",
+       " 'wQuantileLoss[0.5]': 0.35349202916489125,\n",
+       " 'wQuantileLoss[0.6]': 0.3164145929620539,\n",
+       " 'wQuantileLoss[0.7]': 0.2715137650314922,\n",
+       " 'wQuantileLoss[0.8]': 0.2166921996059085,\n",
+       " 'wQuantileLoss[0.9]': 0.14674343365271922,\n",
+       " 'mean_absolute_QuantileLoss': 41542626.871519335,\n",
+       " 'mean_wQuantileLoss': 0.32295477118258353,\n",
+       " 'MAE_Coverage': 0.14802122995269412,\n",
+       " 'OWA': nan}"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agg_metrics"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "ts_metrics.plot(x='MSIS', y='MASE', kind='scatter')\n",
+    "plt.grid(which=\"both\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "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",
+    "    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,
+   "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.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}