diff --git a/experiments/hierarchical_baselines/nbs/run_favorita_baselines.ipynb b/experiments/hierarchical_baselines/nbs/run_favorita_baselines.ipynb
index b360a73a..8d28c5a1 100644
--- a/experiments/hierarchical_baselines/nbs/run_favorita_baselines.ipynb
+++ b/experiments/hierarchical_baselines/nbs/run_favorita_baselines.ipynb
@@ -20,16 +20,7 @@
    "cell_type": "code",
    "execution_count": 1,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/kin/anaconda3/envs/hierarchical_baselines/lib/python3.10/site-packages/statsforecast/core.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
-      "  from tqdm.autonotebook import tqdm\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import os\n",
     "import argparse\n",
@@ -41,21 +32,30 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
     "# %%capture\n",
     "# !pip install statsforecast\n",
     "# !pip install hierarchicalforecast\n",
-    "# !pip install git+https://github.com/Nixtla/datasetsforecast@feat/favorita_dataset.git"
+    "# !pip install git+https://github.com/Nixtla/datasetsforecast.git@feat/favorita_dataset"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/kin/anaconda3/envs/hierarchical_baselines/lib/python3.10/site-packages/statsforecast/core.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from tqdm.autonotebook import tqdm\n"
+     ]
+    }
+   ],
    "source": [
     "from statsforecast.core import StatsForecast\n",
     "from statsforecast.models import AutoARIMA, Naive\n",
@@ -77,7 +77,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -166,16 +166,50 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 5,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 930M/930M [00:21<00:00, 43.4MiB/s] \n",
+      "INFO:datasetsforecast.utils:Successfully downloaded favorita-grocery-sales-forecasting2.zip, 930159981, bytes.\n",
+      "INFO:datasetsforecast.utils:Decompressing zip file...\n",
+      "INFO:datasetsforecast.utils:Successfully decompressed data/favorita/favorita-grocery-sales-forecasting2.zip\n",
+      "INFO:datasetsforecast.utils:Decompressing zip file...\n",
+      "INFO:datasetsforecast.utils:Successfully decompressed data/favorita/holidays_events.csv.zip\n",
+      "INFO:datasetsforecast.utils:Decompressing zip file...\n",
+      "INFO:datasetsforecast.utils:Successfully decompressed data/favorita/items.csv.zip\n",
+      "INFO:datasetsforecast.utils:Decompressing zip file...\n",
+      "INFO:datasetsforecast.utils:Successfully decompressed data/favorita/oil.csv.zip\n",
+      "INFO:datasetsforecast.utils:Decompressing zip file...\n",
+      "INFO:datasetsforecast.utils:Successfully decompressed data/favorita/sample_submission.csv.zip\n",
+      "INFO:datasetsforecast.utils:Decompressing zip file...\n",
+      "INFO:datasetsforecast.utils:Successfully decompressed data/favorita/stores.csv.zip\n",
+      "INFO:datasetsforecast.utils:Decompressing zip file...\n",
+      "INFO:datasetsforecast.utils:Successfully decompressed data/favorita/test.csv.zip\n",
+      "INFO:datasetsforecast.utils:Decompressing zip file...\n",
+      "INFO:datasetsforecast.utils:Successfully decompressed data/favorita/train.csv.zip\n",
+      "INFO:datasetsforecast.utils:Decompressing zip file...\n",
+      "INFO:datasetsforecast.utils:Successfully decompressed data/favorita/transactions.csv.zip\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "saved train.csv to train.feather for fast access\n"
+     ]
+    }
+   ],
    "source": [
     "data = FavoritaHierarchicalDataset.load_item_data(item_id=1916577, directory = './data/favorita', dataset='Favorita200')"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -280,7 +314,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
@@ -293,16 +327,16 @@
       "\n",
       "Favorita200 item_id=112830, h=34 n_series=93, n_bottom=54 \n",
       "test ds=[(Timestamp('2017-07-13 00:00:00'), Timestamp('2017-08-15 00:00:00'))] \n",
-      "Code block 'Read and Parse data   ' took:\t0.56446 seconds\n",
-      "Code block 'Fit/Predict Model\t  ' took:\t0.13728 seconds\n",
-      "Code block 'Reconcile Predictions ' took:\t35.96450 seconds\n",
+      "Code block 'Read and Parse data   ' took:\t0.60365 seconds\n",
+      "Code block 'Fit/Predict Model\t  ' took:\t30.04792 seconds\n",
+      "Code block 'Reconcile Predictions ' took:\t38.54011 seconds\n",
       "\n",
       "\n",
       "Favorita200 item_id=1916577, h=34 n_series=93, n_bottom=54 \n",
       "test ds=[(Timestamp('2017-07-13 00:00:00'), Timestamp('2017-08-15 00:00:00'))] \n",
-      "Code block 'Read and Parse data   ' took:\t0.58135 seconds\n",
-      "Code block 'Fit/Predict Model\t  ' took:\t0.12099 seconds\n",
-      "Code block 'Reconcile Predictions ' took:\t35.64888 seconds\n",
+      "Code block 'Read and Parse data   ' took:\t0.61150 seconds\n",
+      "Code block 'Fit/Predict Model\t  ' took:\t29.67945 seconds\n",
+      "Code block 'Reconcile Predictions ' took:\t38.78811 seconds\n",
       "\n",
       "\n"
      ]
diff --git a/experiments/hierarchical_baselines/nbs/run_favorita_hiere2e.ipynb b/experiments/hierarchical_baselines/nbs/run_favorita_hiere2e.ipynb
new file mode 100644
index 00000000..9e56c03f
--- /dev/null
+++ b/experiments/hierarchical_baselines/nbs/run_favorita_hiere2e.ipynb
@@ -0,0 +1,836 @@
+{
+  "cells": [
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "OwEmMBAeZsYA"
+      },
+      "source": [
+        "# HierE2E Favorita Baseline\n",
+        "\n",
+        "This notebook runs and evaluates HierE2E's baseline method predictions for the Favorita dataset.\n",
+        "\n",
+        "- It reads a preprocessed Favorita dataset.\n",
+        "- It fits a HierE2E's model.\n",
+        "- It evaluates HierE2E forecasts' sCRPS and MSSE.\n",
+        "\n",
+        "## References\n",
+        "- [GluonTS, DeepVARHierarchicalEstimator](https://ts.gluon.ai/stable/api/gluonts/gluonts.mx.model.deepvar_hierarchical.html?highlight=deepvarhierarchicalestimator#gluonts.mx.model.deepvar_hierarchical.DeepVARHierarchicalEstimator)\n",
+        "- [Syama Sundar Rangapuram, Lucien D Werner, Konstantinos Benidis, Pedro Mercado, Jan Gasthaus, Tim Januschowski. (2021). End-to-End Learning of Coherent Probabilistic Forecasts for Hierarchical Time Series. Proceedings of the 38th International Conference on Machine Learning (ICML).](https://proceedings.mlr.press/v139/rangapuram21a.html)\n",
+        "\n",
+        "\n",
+        "<br>\n",
+        "You can run these experiments using GPU with Google Colab.\n",
+        "\n",
+        "<a href=\"https://colab.research.google.com/github/Nixtla/hierarchicalforecast/blob/main/experiments/hierarchical_baselines/nbs/run_favorita_hiere2e.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "id": "RA9WuY6Sa3nr"
+      },
+      "outputs": [],
+      "source": [
+        "%%capture\n",
+        "!pip install mxnet-cu112"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 2,
+      "metadata": {
+        "id": "iQ3oRjlQa5zE"
+      },
+      "outputs": [],
+      "source": [
+        "import mxnet as mx\n",
+        "\n",
+        "assert mx.context.num_gpus()>0"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "metadata": {
+        "id": "wQrFyxlqa66R"
+      },
+      "outputs": [],
+      "source": [
+        "%%capture\n",
+        "!pip install \"gluonts[mxnet,pro]\"\n",
+        "!pip install git+https://github.com/Nixtla/hierarchicalforecast.git\n",
+        "!pip install git+https://github.com/Nixtla/datasetsforecast.git@feat/favorita_dataset"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "metadata": {
+        "id": "wziHeOxZgXWf"
+      },
+      "outputs": [],
+      "source": [
+        "import numpy as np\n",
+        "import pandas as pd\n",
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "from gluonts.mx.trainer import Trainer\n",
+        "from gluonts.dataset.hierarchical import HierarchicalTimeSeries\n",
+        "from gluonts.dataset.common import Dataset, ListDataset\n",
+        "from gluonts.mx.model.deepvar_hierarchical import DeepVARHierarchicalEstimator\n",
+        "\n",
+        "from hierarchicalforecast.evaluation import scaled_crps, rel_mse, msse\n",
+        "from datasetsforecast.favorita import FavoritaData, FavoritaInfo\n",
+        "\n",
+        "import warnings\n",
+        "# Avoid pandas fragmentation warning and positive definite warning\n",
+        "warnings.filterwarnings(\"ignore\")"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "9fIQgmvXd_OA"
+      },
+      "source": [
+        "## Auxiliary Functions"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 12,
+      "metadata": {
+        "id": "g6QsJ4wB7p1P"
+      },
+      "outputs": [],
+      "source": [
+        "# Slight modifications of evaluation metrics to operate with tensors\n",
+        "# https://github.com/Nixtla/hierarchicalforecast/blob/main/hierarchicalforecast/evaluation.py\n",
+        "from typing import Optional, Union\n",
+        "\n",
+        "def _metric_protections(y: np.ndarray, y_hat: np.ndarray,\n",
+        "                        weights: Optional[np.ndarray]) -> None:\n",
+        "    if not ((weights is None) or (np.sum(weights) > 0)):\n",
+        "        raise Exception('Sum of `weights` cannot be 0')\n",
+        "    if not ((weights is None) or (weights.shape == y.shape)):\n",
+        "        raise Exception(\n",
+        "        f'Wrong weight dimension weights.shape {weights.shape}, y.shape {y.shape}')\n",
+        "\n",
+        "def mse(y: np.ndarray, y_hat: np.ndarray,\n",
+        "        weights: Optional[np.ndarray] = None,\n",
+        "        axis: Optional[int] = None) -> Union[float, np.ndarray]:\n",
+        "    _metric_protections(y, y_hat, weights)\n",
+        "\n",
+        "    delta_y = np.square(y - y_hat)\n",
+        "    if weights is not None:\n",
+        "        mse = np.average(delta_y[~np.isnan(delta_y)],\n",
+        "                         weights=weights[~np.isnan(delta_y)],\n",
+        "                         axis=axis)\n",
+        "    else:\n",
+        "        mse = np.nanmean(delta_y, axis=axis)\n",
+        "    return mse\n",
+        "\n",
+        "def rel_mse(y, y_hat, y_train, mask=None):\n",
+        "    if mask is None:\n",
+        "       mask = np.ones_like(y)\n",
+        "    n_series, n_hier, horizon = y.shape\n",
+        "\n",
+        "    eps = np.finfo(float).eps\n",
+        "    y_naive = np.repeat(y_train[:,:,[-1]], horizon, axis=2)\n",
+        "    norm = mse(y=y, y_hat=y_naive)\n",
+        "    loss = mse(y=y, y_hat=y_hat, weights=mask)\n",
+        "    loss = loss / (norm + eps)\n",
+        "    return loss\n",
+        "\n",
+        "# %% ../nbs/evaluation.ipynb 11\n",
+        "def msse(y, y_hat, y_train, mask=None):\n",
+        "    if mask is None:\n",
+        "       mask = np.ones_like(y)\n",
+        "    n_series, n_hier, horizon = y.shape\n",
+        "\n",
+        "    eps = np.finfo(float).eps\n",
+        "    y_in_sample_naive = y_train[:, :, :-1]\n",
+        "    y_in_sample_true = y_train[:, :, 1:]\n",
+        "    norm = mse(y=y_in_sample_true, y_hat=y_in_sample_naive)\n",
+        "    loss = mse(y=y, y_hat=y_hat, weights=mask)\n",
+        "    loss = loss / (norm + eps)\n",
+        "    return loss"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 6,
+      "metadata": {
+        "id": "7DBVhznZZsYE"
+      },
+      "outputs": [],
+      "source": [
+        "class FavoritaHierarchicalDataset(object):\n",
+        "    # Class with loading, processing and\n",
+        "    # prediction evaluation methods for hierarchical data\n",
+        "\n",
+        "    available_datasets = ['Favorita200', 'Favorita500', 'FavoritaComplete']\n",
+        "\n",
+        "    @staticmethod\n",
+        "    def _get_hierarchical_scrps(hier_idxs, Y, Yq_hat, q_to_pred):\n",
+        "        # We use the indexes obtained from the aggregation tags\n",
+        "        # to compute scaled CRPS across the hierarchy levels\n",
+        "        # # [n_items, n_stores, n_time, n_quants]\n",
+        "        scrps_list = []\n",
+        "        for idxs in hier_idxs:\n",
+        "            y      = Y[:, idxs, :]\n",
+        "            yq_hat = Yq_hat[:, idxs, :, :]\n",
+        "            scrps  = scaled_crps(y, yq_hat, q_to_pred)\n",
+        "            scrps_list.append(scrps)\n",
+        "        return scrps_list\n",
+        "\n",
+        "    @staticmethod\n",
+        "    def _get_hierarchical_msse(hier_idxs, Y, Y_hat, Y_train):\n",
+        "        # We use the indexes obtained from the aggregation tags\n",
+        "        # to compute scaled CRPS across the hierarchy levels\n",
+        "        msse_list = []\n",
+        "        for idxs in hier_idxs:\n",
+        "            y       = Y[:, idxs, :]\n",
+        "            y_hat   = Y_hat[:, idxs, :]\n",
+        "            y_train = Y_train[:, idxs, :]\n",
+        "            crps    = msse(y, y_hat, y_train)\n",
+        "            msse_list.append(crps)\n",
+        "        return msse_list\n",
+        "\n",
+        "    @staticmethod\n",
+        "    def _get_hierarchical_rel_mse(hier_idxs, Y, Y_hat, Y_train):\n",
+        "        # We use the indexes obtained from the aggregation tags\n",
+        "        # to compute relative MSE across the hierarchy levels\n",
+        "        rel_mse_list = []\n",
+        "        for idxs in hier_idxs:\n",
+        "            y       = Y[:,idxs, :]\n",
+        "            y_hat   = Y_hat[:,idxs, :]\n",
+        "            y_train = Y_train[:,idxs, :]\n",
+        "            level_rel_mse = rel_mse(y, y_hat, y_train)\n",
+        "            rel_mse_list.append(level_rel_mse)\n",
+        "        return rel_mse_list\n",
+        "\n",
+        "    @staticmethod\n",
+        "    def _sort_hier_df(Y_df, S_df):\n",
+        "        # NeuralForecast core, sorts unique_id lexicographically\n",
+        "        # deviating from S_df, this class matches S_df and Y_hat_df order.\n",
+        "        Y_df.unique_id = Y_df.unique_id.astype('category')\n",
+        "        Y_df.unique_id = Y_df.unique_id.cat.set_categories(S_df.index)\n",
+        "        Y_df = Y_df.sort_values(by=['unique_id', 'ds'])\n",
+        "        return Y_df\n",
+        "\n",
+        "    @staticmethod\n",
+        "    def _nonzero_indexes_by_row(M):\n",
+        "        return [np.nonzero(M[row,:])[0] for row in range(len(M))]\n",
+        "\n",
+        "    @staticmethod\n",
+        "    def load_item_data(item_id, dataset='Favorita200', directory='./data'):\n",
+        "        # Load data\n",
+        "        data_info = FavoritaInfo[dataset]\n",
+        "        Y_df, S_df, tags = FavoritaData.load(directory=directory,\n",
+        "                                             group=dataset)\n",
+        "\n",
+        "        # Parse and augment data\n",
+        "        # + hack geographic hier_id to treat it as unique_id\n",
+        "        Y_df['ds'] = pd.to_datetime(Y_df['ds'])\n",
+        "        Y_df = Y_df[Y_df.item_id==item_id]\n",
+        "        Y_df = Y_df.rename(columns={'hier_id': 'unique_id'})\n",
+        "        Y_df = FavoritaHierarchicalDataset._sort_hier_df(Y_df=Y_df, S_df=S_df)\n",
+        "\n",
+        "        # Obtain indexes for plots and evaluation\n",
+        "        hier_levels = ['Overall'] + list(tags.keys())\n",
+        "        hier_idxs = [np.arange(len(S_df))] +\\\n",
+        "            [S_df.index.get_indexer(tags[level]) for level in list(tags.keys())]\n",
+        "        hier_linked_idxs = FavoritaHierarchicalDataset._nonzero_indexes_by_row(S_df.values.T)\n",
+        "\n",
+        "        # MinT along other methods require a positive definite covariance matrix\n",
+        "        # for the residuals, when dealing with 0s as residuals the methods break\n",
+        "        # data is augmented with minimal normal noise to avoid this error.\n",
+        "        Y_df['y'] = Y_df['y'] + np.random.normal(loc=0.0, scale=0.01, size=len(Y_df))\n",
+        "\n",
+        "        # Final output\n",
+        "        data = dict(Y_df=Y_df, S_df=S_df, tags=tags,\n",
+        "                    # Hierarchical idxs\n",
+        "                    hier_idxs=hier_idxs,\n",
+        "                    hier_levels=hier_levels,\n",
+        "                    hier_linked_idxs=hier_linked_idxs,\n",
+        "                    # Dataset Properties\n",
+        "                    horizon=data_info.horizon,\n",
+        "                    freq=data_info.freq,\n",
+        "                    seasonality=data_info.seasonality)\n",
+        "        return data\n",
+        "\n",
+        "    @staticmethod\n",
+        "    def load_process_data(dataset='Favorita200', directory='./data',\n",
+        "                          is_validation=False):\n",
+        "        # Load data\n",
+        "        data_info = FavoritaInfo[dataset]\n",
+        "        Y_df, S_df, tags = FavoritaData.load(directory='./data/favorita',\n",
+        "                                             group=dataset)\n",
+        "\n",
+        "        # Obtain indexes for plots and evaluation\n",
+        "        hier_levels = ['Overall'] + list(tags.keys())\n",
+        "        hier_idxs = [np.arange(len(S_df))] +\\\n",
+        "            [S_df.index.get_indexer(tags[level]) for level in list(tags.keys())]\n",
+        "        hier_linked_idxs = \\\n",
+        "            FavoritaHierarchicalDataset._nonzero_indexes_by_row(S_df.values.T)\n",
+        "\n",
+        "        # Parse data\n",
+        "        Y_df['unique_id'] = Y_df['hier_id'] + '_' + Y_df['item_id'].astype(str)\n",
+        "        dates = Y_df.ds.unique() # already sorted\n",
+        "        n_items = len(Y_df.item_id.unique())\n",
+        "        n_hier  = len(Y_df.hier_id.unique())\n",
+        "        n_dates = len(Y_df.ds.unique())\n",
+        "\n",
+        "        Y_hier = np.reshape(Y_df.y.values, (n_items, n_hier, n_dates))\n",
+        "\n",
+        "        # Declare GluonTS dataloaders.\n",
+        "        horizon = data_info.horizon\n",
+        "        freq = data_info.freq\n",
+        "\n",
+        "        if is_validation:\n",
+        "            target_train = Y_hier[:, :, :len(dates) - 2 * horizon]\n",
+        "            target_test = Y_hier[:, :, :len(dates) - horizon]\n",
+        "            valid_plus_test_length = 2 * horizon\n",
+        "            valid_length = horizon\n",
+        "        else:\n",
+        "            target_train = Y_hier[:, :, :len(dates) - horizon]\n",
+        "            target_test = Y_hier\n",
+        "            valid_plus_test_length = horizon\n",
+        "            valid_length = 0\n",
+        "\n",
+        "        training_data = ListDataset(\n",
+        "            [{\"start\":dates[0], \"item_id\": \"all_items\", \\\n",
+        "              \"target\": target_train[idx,:,:]} for idx in range(n_items)],\n",
+        "            freq=freq,\n",
+        "            one_dim_target=False\n",
+        "        )\n",
+        "        testing_data = ListDataset(\n",
+        "            [{\"start\": dates[0], \"item_id\": \"all_items\", \\\n",
+        "              \"target\": target_test[idx,:,:]} for idx in range(n_items)],\n",
+        "            freq=freq,\n",
+        "            one_dim_target=False\n",
+        "        )\n",
+        "\n",
+        "        # Final output\n",
+        "        data = dict(Y_df=Y_df, S_df=S_df, tags=tags,\n",
+        "                    Y_hier=Y_hier,\n",
+        "                    training_data=training_data, testing_data=testing_data,\n",
+        "                    # Hierarchical idxs\n",
+        "                    hier_idxs=hier_idxs,\n",
+        "                    hier_levels=hier_levels,\n",
+        "                    hier_linked_idxs=hier_linked_idxs,\n",
+        "                    # Dataset Properties\n",
+        "                    horizon=data_info.horizon,\n",
+        "                    freq=data_info.freq,\n",
+        "                    seasonality=data_info.seasonality)\n",
+        "        return data"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 7,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 577
+        },
+        "id": "bZgfuf9BfQGO",
+        "outputId": "48297d80-e3e2-451a-d03d-1caed09de808"
+      },
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "100%|██████████| 930M/930M [00:31<00:00, 29.7MiB/s]\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "saved train.csv to train.feather for fast access\n"
+          ]
+        },
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 700x600 with 4 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "# Testing load and plotting series\n",
+        "data = FavoritaHierarchicalDataset.load_process_data(directory='./data/favorita',\n",
+        "                                                 dataset='Favorita200',\n",
+        "                                                 is_validation=False)\n",
+        "\n",
+        "item_idx = 0\n",
+        "store_idx = 39\n",
+        "Y_plot = data['Y_hier'][item_idx,:,:]\n",
+        "hier_idxs = data['hier_linked_idxs'][store_idx]\n",
+        "\n",
+        "fig, axs = plt.subplots(nrows=4, figsize=(7, 6))\n",
+        "for i, hier_idx in enumerate(hier_idxs):\n",
+        "    axs[i].plot(Y_plot[hier_idx, -60:])\n",
+        "    axs[i].set_ylabel(data['S_df'].index[hier_idx])\n",
+        "    axs[i].grid()\n",
+        "axs[i].set_xlabel('Date')\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "qS7gDbY_d4Uk"
+      },
+      "source": [
+        "## Fit/Predict HierE2E"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 8,
+      "metadata": {
+        "id": "ZilLdARtobmS"
+      },
+      "outputs": [],
+      "source": [
+        "def run_hiere2e(config, data):\n",
+        "\n",
+        "    estimator = DeepVARHierarchicalEstimator(\n",
+        "        freq=data['freq'],\n",
+        "        prediction_length=data['horizon'],\n",
+        "        target_dim=len(data['S_df']),\n",
+        "        S=data['S_df'].values,\n",
+        "        trainer=Trainer(ctx = mx.context.gpu(),\n",
+        "                        epochs=config['epochs'],\n",
+        "                        num_batches_per_epoch=config['num_batches_per_epoch'],\n",
+        "                        hybridize=config['hybridize'],\n",
+        "                        learning_rate=config['learning_rate']),\n",
+        "        scaling=config['scaling'],\n",
+        "        pick_incomplete=config['pick_incomplete'],\n",
+        "        batch_size=config['batch_size'],\n",
+        "        num_parallel_samples=config['num_parallel_samples'],\n",
+        "        context_length=config['context_length'],\n",
+        "        num_layers=config['num_layers'],\n",
+        "        num_cells=config['num_cells'],\n",
+        "        coherent_train_samples=config['coherent_train_samples'],\n",
+        "        coherent_pred_samples=config['coherent_pred_samples'],\n",
+        "        likelihood_weight=config['likelihood_weight'],\n",
+        "        CRPS_weight=config['CRPS_weight'],\n",
+        "        num_samples_for_loss=config['num_samples_for_loss'],\n",
+        "        sample_LH=config['sample_LH'],\n",
+        "        seq_axis=config['seq_axis'],\n",
+        "        warmstart_epoch_frac = config['warmstart_epoch_frac'],\n",
+        "    )\n",
+        "\n",
+        "    predictor = estimator.train(training_data=data['training_data'])\n",
+        "    forecast_it = predictor.predict(dataset=data['training_data'])\n",
+        "\n",
+        "    # Generate samples for empirical quantiles\n",
+        "    samples_list = []\n",
+        "    for step in forecast_it:\n",
+        "        samples = step.samples\n",
+        "        samples_list.append(samples[None,:,:,:])\n",
+        "\n",
+        "    # [n_items, n_samples, horizon, n_hier] 0,1,2,3\n",
+        "    # -> [n_items, n_hier, horizon, n_samples] 0,3,2,1\n",
+        "    samples = np.concatenate(samples_list, axis=0)\n",
+        "    samples = np.transpose(samples, (0,3,2,1))\n",
+        "\n",
+        "    Y_hat  = np.mean(samples, axis=3)\n",
+        "    Yq_hat = np.quantile(samples, q=QUANTILES, axis=3)\n",
+        "    Yq_hat = np.transpose(Yq_hat, (1,2,3,0))\n",
+        "\n",
+        "    Y_test = data['Y_hier'][:,:,-data['horizon']:]\n",
+        "    Y_train = data['Y_hier'][:,:,:-data['horizon']]\n",
+        "\n",
+        "    print('\\n')\n",
+        "    print('Yq_hat.shape: \\t', Yq_hat.shape)\n",
+        "    print('Y_hat.shape: \\t', Y_hat.shape)\n",
+        "    print('Y_test.shape: \\t', Y_test.shape)\n",
+        "    print('Y_train.shape: \\t', Y_train.shape)\n",
+        "\n",
+        "    return Yq_hat, Y_hat, Y_test, Y_train"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 28,
+      "metadata": {
+        "id": "SpVvuFVZdzz4"
+      },
+      "outputs": [],
+      "source": [
+        "# Optimal parameters reported from IJF 2023 code\n",
+        "# hyperopt hyperparameter selection previously performed over:\n",
+        "# learning rate hp.loguniform('learning_rate', np.log(5e-5), np.log(0.001))\n",
+        "# epochs scope.int(hp.quniform('epochs', 10, 25, 5))\n",
+        "config = dict(epochs=25,\n",
+        "              num_batches_per_epoch=50,\n",
+        "              scaling=True,\n",
+        "              pick_incomplete=False,\n",
+        "              batch_size=32,\n",
+        "              num_parallel_samples=200,\n",
+        "              hybridize=False,\n",
+        "              learning_rate=0.0005, # 0.0005 0.64\n",
+        "              context_length=24,\n",
+        "              rank=4,\n",
+        "              assert_reconciliation=False,\n",
+        "              num_deep_models=1,\n",
+        "              num_layers=2,\n",
+        "              num_cells=40,\n",
+        "              coherent_train_samples=True,\n",
+        "              coherent_pred_samples=True,\n",
+        "              likelihood_weight=0.0,       # Likelihood training is unstable\n",
+        "              CRPS_weight=1.0,             # CRPS training is stable\n",
+        "              num_samples_for_loss=50,     # Reduce for speed boost\n",
+        "              sample_LH=True,\n",
+        "              seq_axis=[1],\n",
+        "              warmstart_epoch_frac=0.1\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 29,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "pgJnLKglwL_Q",
+        "outputId": "900f6575-2c3a-486e-f2e4-a4744eccdc1f"
+      },
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "100%|██████████| 50/50 [00:17<00:00,  2.81it/s, epoch=1/25, avg_epoch_loss=1.03e+4]\n",
+            "100%|██████████| 50/50 [00:17<00:00,  2.88it/s, epoch=2/25, avg_epoch_loss=8.52e+3]\n",
+            "100%|██████████| 50/50 [00:18<00:00,  2.64it/s, epoch=3/25, avg_epoch_loss=7.52e+3]\n",
+            "100%|██████████| 50/50 [00:20<00:00,  2.45it/s, epoch=4/25, avg_epoch_loss=7.5e+3] \n",
+            "100%|██████████| 50/50 [00:19<00:00,  2.60it/s, epoch=5/25, avg_epoch_loss=6.76e+3]\n",
+            "100%|██████████| 50/50 [00:19<00:00,  2.60it/s, epoch=6/25, avg_epoch_loss=7.34e+3]\n",
+            "100%|██████████| 50/50 [00:19<00:00,  2.62it/s, epoch=7/25, avg_epoch_loss=6.89e+3]\n",
+            "100%|██████████| 50/50 [00:19<00:00,  2.60it/s, epoch=8/25, avg_epoch_loss=6.78e+3]\n",
+            "100%|██████████| 50/50 [00:19<00:00,  2.62it/s, epoch=9/25, avg_epoch_loss=6.64e+3]\n",
+            "100%|██████████| 50/50 [00:19<00:00,  2.58it/s, epoch=10/25, avg_epoch_loss=6.96e+3]\n",
+            "100%|██████████| 50/50 [00:19<00:00,  2.59it/s, epoch=11/25, avg_epoch_loss=6.51e+3]\n",
+            "100%|██████████| 50/50 [00:19<00:00,  2.59it/s, epoch=12/25, avg_epoch_loss=6.44e+3]\n",
+            "100%|██████████| 50/50 [00:19<00:00,  2.57it/s, epoch=13/25, avg_epoch_loss=6.26e+3]\n",
+            "100%|██████████| 50/50 [00:18<00:00,  2.64it/s, epoch=14/25, avg_epoch_loss=6.07e+3]\n",
+            "100%|██████████| 50/50 [00:19<00:00,  2.62it/s, epoch=15/25, avg_epoch_loss=6.3e+3] \n",
+            "100%|██████████| 50/50 [00:19<00:00,  2.59it/s, epoch=16/25, avg_epoch_loss=5.95e+3]\n",
+            "100%|██████████| 50/50 [00:18<00:00,  2.64it/s, epoch=17/25, avg_epoch_loss=5.91e+3]\n",
+            "100%|██████████| 50/50 [00:19<00:00,  2.60it/s, epoch=18/25, avg_epoch_loss=6.23e+3]\n",
+            "100%|██████████| 50/50 [00:19<00:00,  2.61it/s, epoch=19/25, avg_epoch_loss=5.96e+3]\n",
+            "100%|██████████| 50/50 [00:19<00:00,  2.58it/s, epoch=20/25, avg_epoch_loss=6.05e+3]\n",
+            "100%|██████████| 50/50 [00:18<00:00,  2.65it/s, epoch=21/25, avg_epoch_loss=5.74e+3]\n",
+            "100%|██████████| 50/50 [00:19<00:00,  2.59it/s, epoch=22/25, avg_epoch_loss=5.95e+3]\n",
+            "100%|██████████| 50/50 [00:18<00:00,  2.64it/s, epoch=23/25, avg_epoch_loss=5.75e+3]\n",
+            "100%|██████████| 50/50 [00:19<00:00,  2.62it/s, epoch=24/25, avg_epoch_loss=5.7e+3]\n",
+            "100%|██████████| 50/50 [00:19<00:00,  2.58it/s, epoch=25/25, avg_epoch_loss=5.96e+3]\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Yq_hat.shape: \t (200, 93, 34, 100)\n",
+            "Y_hat.shape: \t (200, 93, 34)\n",
+            "Y_test.shape: \t (200, 93, 34)\n",
+            "Y_train.shape: \t (200, 93, 193)\n"
+          ]
+        }
+      ],
+      "source": [
+        "DATASET = 'Favorita200' # 'Favorita500', 'FavoritaComplete'\n",
+        "is_validation = False\n",
+        "\n",
+        "LEVEL = np.arange(0, 100, 2)\n",
+        "qs = [[50-lv/2, 50+lv/2] for lv in LEVEL]\n",
+        "QUANTILES = np.sort(np.concatenate(qs)/100)\n",
+        "\n",
+        "data = FavoritaHierarchicalDataset.load_process_data(directory='./data/favorita',\n",
+        "                                                 dataset=DATASET,\n",
+        "                                                 is_validation=is_validation)\n",
+        "\n",
+        "Yq_hat, Y_hat, Y_test, Y_train = run_hiere2e(config=config, data=data)"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "lh1mI-NjfGqj"
+      },
+      "source": [
+        "## Evaluate HierE2E\n",
+        "\n",
+        "To evaluate we use the following metrics:\n",
+        "\n",
+        "A scaled variation of the CRPS, as proposed by Rangapuram (2021), to measure the accuracy of predicted quantiles `y_hat` compared to the observation `y`.\n",
+        "\n",
+        "$$ \\mathrm{sCRPS}(\\hat{F}_{\\tau}, \\mathbf{y}_{\\tau}) = \\frac{2}{N} \\sum_{i}\n",
+        "\\int^{1}_{0}\n",
+        "\\frac{\\mathrm{QL}(\\hat{F}_{i,\\tau}, y_{i,\\tau})_{q}}{\\sum_{i} | y_{i,\\tau} |} dq $$\n",
+        "\n",
+        "\n",
+        "Relative mean squared error (RelMSE), as proposed by Hyndman & Koehler (2006) and used in Olivares (2023).\n",
+        "\n",
+        "$$ \\mathrm{RelMSE}(\\mathbf{y}, \\mathbf{\\hat{y}}, \\mathbf{\\hat{y}}^{naive1}) =\n",
+        "\\frac{\\mathrm{MSE}(\\mathbf{y}, \\mathbf{\\hat{y}})}{\\mathrm{MSE}(\\mathbf{y}, \\mathbf{\\hat{y}}^{naive1})} $$\n",
+        "\n",
+        "Mean squared scaled error (MSSE), as proposed by Hyndman & Koehler (2006).\n",
+        "\n",
+        "$$ \\mathrm{MSSE}(\\mathbf{y}, \\mathbf{\\hat{y}}, \\mathbf{y}^{in-sample}) =\n",
+        "\\frac{\\frac{1}{h} \\sum^{t+h}_{\\tau=t+1} (y_{\\tau} - \\hat{y}_{\\tau})^2}{\\frac{1}{t-1} \\sum^{t}_{\\tau=2} (y_{\\tau} - y_{\\tau-1})^2}\n",
+        "$$"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 30,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 206
+        },
+        "id": "7qA9OP-fZdoS",
+        "outputId": "3adf1ab8-4dcb-41e8-d32d-139e71de0da9"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/html": [
+              "\n",
+              "  <div id=\"df-0c922021-6270-4dd5-beb0-8053eddbf984\">\n",
+              "    <div class=\"colab-df-container\">\n",
+              "      <div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>level</th>\n",
+              "      <th>scrps</th>\n",
+              "      <th>rel_mse</th>\n",
+              "      <th>msse</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td>Overall</td>\n",
+              "      <td>0.575938</td>\n",
+              "      <td>1.495924</td>\n",
+              "      <td>2.446064</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>Country</td>\n",
+              "      <td>0.378334</td>\n",
+              "      <td>1.381576</td>\n",
+              "      <td>2.849082</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2</th>\n",
+              "      <td>Country/State</td>\n",
+              "      <td>0.535384</td>\n",
+              "      <td>1.572350</td>\n",
+              "      <td>2.126266</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>3</th>\n",
+              "      <td>Country/State/City</td>\n",
+              "      <td>0.605753</td>\n",
+              "      <td>1.710439</td>\n",
+              "      <td>2.282271</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>4</th>\n",
+              "      <td>Country/State/City/Store</td>\n",
+              "      <td>0.784278</td>\n",
+              "      <td>1.425993</td>\n",
+              "      <td>1.959518</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>\n",
+              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-0c922021-6270-4dd5-beb0-8053eddbf984')\"\n",
+              "              title=\"Convert this dataframe to an interactive table.\"\n",
+              "              style=\"display:none;\">\n",
+              "        \n",
+              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
+              "       width=\"24px\">\n",
+              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
+              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
+              "  </svg>\n",
+              "      </button>\n",
+              "      \n",
+              "  <style>\n",
+              "    .colab-df-container {\n",
+              "      display:flex;\n",
+              "      flex-wrap:wrap;\n",
+              "      gap: 12px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert {\n",
+              "      background-color: #E8F0FE;\n",
+              "      border: none;\n",
+              "      border-radius: 50%;\n",
+              "      cursor: pointer;\n",
+              "      display: none;\n",
+              "      fill: #1967D2;\n",
+              "      height: 32px;\n",
+              "      padding: 0 0 0 0;\n",
+              "      width: 32px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert:hover {\n",
+              "      background-color: #E2EBFA;\n",
+              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "      fill: #174EA6;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert {\n",
+              "      background-color: #3B4455;\n",
+              "      fill: #D2E3FC;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert:hover {\n",
+              "      background-color: #434B5C;\n",
+              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
+              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
+              "      fill: #FFFFFF;\n",
+              "    }\n",
+              "  </style>\n",
+              "\n",
+              "      <script>\n",
+              "        const buttonEl =\n",
+              "          document.querySelector('#df-0c922021-6270-4dd5-beb0-8053eddbf984 button.colab-df-convert');\n",
+              "        buttonEl.style.display =\n",
+              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "\n",
+              "        async function convertToInteractive(key) {\n",
+              "          const element = document.querySelector('#df-0c922021-6270-4dd5-beb0-8053eddbf984');\n",
+              "          const dataTable =\n",
+              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
+              "                                                     [key], {});\n",
+              "          if (!dataTable) return;\n",
+              "\n",
+              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
+              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
+              "            + ' to learn more about interactive tables.';\n",
+              "          element.innerHTML = '';\n",
+              "          dataTable['output_type'] = 'display_data';\n",
+              "          await google.colab.output.renderOutput(dataTable, element);\n",
+              "          const docLink = document.createElement('div');\n",
+              "          docLink.innerHTML = docLinkHtml;\n",
+              "          element.appendChild(docLink);\n",
+              "        }\n",
+              "      </script>\n",
+              "    </div>\n",
+              "  </div>\n",
+              "  "
+            ],
+            "text/plain": [
+              "                      level     scrps   rel_mse      msse\n",
+              "0                   Overall  0.575938  1.495924  2.446064\n",
+              "1                   Country  0.378334  1.381576  2.849082\n",
+              "2             Country/State  0.535384  1.572350  2.126266\n",
+              "3        Country/State/City  0.605753  1.710439  2.282271\n",
+              "4  Country/State/City/Store  0.784278  1.425993  1.959518"
+            ]
+          },
+          "execution_count": 30,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "# Final sCRPS and MSSE evaluation\n",
+        "_scrps = FavoritaHierarchicalDataset._get_hierarchical_scrps(\n",
+        "                                            Y=Y_test, Yq_hat=Yq_hat,\n",
+        "                                            hier_idxs=data['hier_idxs'],\n",
+        "                                            q_to_pred=QUANTILES)\n",
+        "\n",
+        "_rel_mse = FavoritaHierarchicalDataset._get_hierarchical_rel_mse(\n",
+        "                                           Y=Y_test, Y_hat=Y_hat,\n",
+        "                                           Y_train=Y_train,\n",
+        "                                           hier_idxs=data['hier_idxs'])\n",
+        "\n",
+        "_msse = FavoritaHierarchicalDataset._get_hierarchical_msse(\n",
+        "                                           Y=Y_test, Y_hat=Y_hat,\n",
+        "                                           Y_train=Y_train,\n",
+        "                                           hier_idxs=data['hier_idxs'])\n",
+        "\n",
+        "results_df = pd.DataFrame(dict(level=['Overall']+list(data['tags'].keys())))\n",
+        "results_df['scrps'] = _scrps\n",
+        "results_df['rel_mse'] = _rel_mse\n",
+        "results_df['msse'] = _msse\n",
+        "results_df"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 11,
+      "metadata": {
+        "id": "BBYqYKbliqNn"
+      },
+      "outputs": [],
+      "source": []
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "gpuType": "T4",
+      "machine_shape": "hm",
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "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.10.11"
+    },
+    "orig_nbformat": 4
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}