Sktime pytorch integration using skorch

sktime_pytorch.ipynb

{
    "cells": [
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "# NOTES\n",
                "\n",
                "- We are using [skorch](https://github.com/skorch-dev/skorch) to wrap the PyTorch model in a scikit-learn compatible interface.\n",
                "- This allows us to just implement a bare pytorch model, then use their wrapper to make it compatible with sktime.\n"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "# Links\n",
                "\n",
                "- [Skorch+Pycaret](https://towardsdatascience.com/pycaret-skorch-build-pytorch-neural-networks-using-minimal-code-57079e197f33)\n",
                "- [TowardsDataScience Article](https://towardsdatascience.com/skorch-pytorch-models-trained-with-a-scikit-learn-wrapper-62b9a154623e)\n",
                "- [Mnist Example](https://medium.datadriveninvestor.com/train-a-cnn-using-skorch-for-mnist-digit-recognition-53d7d2f971c7)\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "%pip install sktime==0.21.0 skorch==0.12.1 torch==1.13.1 numpy pandas matplotlib mlflow seaborn"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "metadata": {
                "tags": []
            },
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "skorch                        0.12.1\n",
                        "sktime                        0.21.0\n",
                        "torch                         1.13.1\n",
                        "Note: you may need to restart the kernel to use updated packages.\n"
                    ]
                }
            ],
            "source": [
                "%pip list packages | egrep 'skorch|torch|sktime'"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "# Imports\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 2,
            "metadata": {},
            "outputs": [
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "/home/ilker/miniconda3/envs/sktime-pytorch/lib/python3.8/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
                        "  from .autonotebook import tqdm as notebook_tqdm\n"
                    ]
                }
            ],
            "source": [
                "import numpy as np\n",
                "import pandas as pd\n",
                "import torch\n",
                "from torch import nn\n",
                "import torch.nn.functional as F\n",
                "from mlflow.tracking import MlflowClient\n",
                "from sktime.datasets import load_uschange\n",
                "from sktime.forecasting.model_selection import (\n",
                "    temporal_train_test_split,\n",
                "    ForecastingGridSearchCV,\n",
                ")\n",
                "from sktime.utils.plotting import plot_series\n",
                "import matplotlib.pyplot as plt\n",
                "\n",
                "\n",
                "from skorch import NeuralNetRegressor\n",
                "from sktime.forecasting.model_selection import SingleWindowSplitter\n",
                "from skorch.dataset import ValidSplit\n",
                "from sktime.forecasting.compose import YfromX\n",
                "from skorch.callbacks import EarlyStopping, Checkpoint, LRScheduler, MlflowLogger\n",
                "\n",
                "import pandas as pd\n",
                "from skorch import NeuralNetRegressor\n",
                "from torch import nn\n",
                "from typing import Tuple\n",
                "\n",
                "# To fix following skorch error:\n",
                "# RuntimeError: Expected object of scalar type Double but got scalar type Float for argument #2 ‘weight’\n",
                "torch.set_default_dtype(torch.float64)"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {
                "collapsed": false
            },
            "source": [
                "# Device\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 3,
            "metadata": {
                "collapsed": false
            },
            "outputs": [
                {
                    "data": {
                        "text/plain": [
                            "device(type='cpu')"
                        ]
                    },
                    "execution_count": 3,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
                "device = torch.device(\"cpu\")\n",
                "device"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "# Data\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 4,
            "metadata": {},
            "outputs": [],
            "source": [
                "def load_uschange_corrected(target=\"Consumption\") -> Tuple[pd.Series, pd.DataFrame]:\n",
                "    \"\"\"\n",
                "    Multivariate sample univariate from sktime\n",
                "    Loaded USChange dataset from sktime and correct for period index\n",
                "    \"\"\"\n",
                "    y, X = load_uschange(y_name=target)\n",
                "    y.index = pd.period_range(start=\"1960-Q1\", periods=len(y), freq=\"Q\", name=\"Period\")\n",
                "    X.index = pd.period_range(start=\"1960-Q1\", periods=len(X), freq=\"Q\", name=\"Period\")\n",
                "\n",
                "    return y, X"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 5,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "(159,) (28,) (159, 4) (28, 4)\n"
                    ]
                }
            ],
            "source": [
                "y, X = load_uschange_corrected()\n",
                "test_size = 28\n",
                "\n",
                "y_train, y_test, X_train, X_test = temporal_train_test_split(y=y, X=X, test_size=test_size)\n",
                "\n",
                "fh = np.arange(1, len(y_test) + 1)\n",
                "\n",
                "print(y_train.shape, y_test.shape, X_train.shape, X_test.shape)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "# Model"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 6,
            "metadata": {},
            "outputs": [],
            "source": [
                "pytorch_activation_functions = {\n",
                "    \"relu\": nn.ReLU,\n",
                "    \"tanh\": nn.Tanh,\n",
                "    \"softplus\": nn.Softplus,\n",
                "    \"sigmoid\": nn.Sigmoid,\n",
                "    \"softmax\": nn.Softmax,\n",
                "    \"identity\": nn.Identity,\n",
                "    None: nn.Identity,\n",
                "}"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 7,
            "metadata": {},
            "outputs": [],
            "source": [
                "class SimpleMLP(nn.Module):\n",
                "    \"\"\"\n",
                "    Simple MLP model for Pytorch.\n",
                "\n",
                "    NOTE:\n",
                "        `input_size` is not required to be set. It is automatically set to `X.shape[1]`.\n",
                "        This will be the case for all skorch reduced models.\n",
                "        Since it will be set in every forward pass, this might cause performance issues.\n",
                "    \"\"\"\n",
                "\n",
                "    def __init__(\n",
                "        self,\n",
                "        input_size: int = 100,  # Should be X.shape[1]\n",
                "        output_size: int = 1,\n",
                "        hidden_size_1: int = 30,\n",
                "        hidden_size_2: int = 10,\n",
                "        activation: str = \"relu\",\n",
                "    ):\n",
                "        super().__init__()\n",
                "        self.input_size = input_size\n",
                "        self.hidden_size_1 = hidden_size_1\n",
                "        self.hidden_size_2 = hidden_size_2\n",
                "\n",
                "        self.fc1 = nn.Linear(input_size, hidden_size_1)\n",
                "        self.activation = pytorch_activation_functions[activation]()\n",
                "        self.fc2 = nn.Linear(hidden_size_1, hidden_size_2)\n",
                "        self.output = nn.Linear(hidden_size_2, output_size)\n",
                "\n",
                "    def forward(self, X):\n",
                "        # FIXME: This might not efficient!\n",
                "        if self.input_size != X.shape[1]:\n",
                "            print(\n",
                "                f\"Input size: {self.input_size} should be equal to exogenous feature\"\n",
                "                f\" size.Hence, it is set to {X.shape[1]}.\"\n",
                "            )\n",
                "            self.input_size = X.shape[1]\n",
                "            self.fc1 = nn.Linear(self.input_size, self.hidden_size_1)\n",
                "\n",
                "        X = self.activation(self.fc1(X))\n",
                "        X = self.activation(self.fc2(X))\n",
                "        X = self.output(X)\n",
                "\n",
                "        return X"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## Skorch Reducer"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 8,
            "metadata": {},
            "outputs": [],
            "source": [
                "class SkorchRegressor(NeuralNetRegressor):\n",
                "    \"\"\"\n",
                "    A wrapper for skorch NeuralNetRegressor. NeuralNetRegressor only takes numpy arrays\n",
                "    as input. This class takes pandas dataframes as input and converts them to\n",
                "    numpy arrays and reshapes the data if necessary.\n",
                "    \"\"\"\n",
                "\n",
                "    def __init__(self, *args, **kwargs):\n",
                "        super().__init__(*args, **kwargs)\n",
                "\n",
                "    def fit(self, X, y, **fit_params):\n",
                "        if isinstance(y, (pd.Series, pd.DataFrame)):\n",
                "            y = y.to_numpy()\n",
                "\n",
                "        if isinstance(X, pd.DataFrame):\n",
                "            X = X.to_numpy()\n",
                "\n",
                "        # if y is one dimensional, force it to 2 dimensional\n",
                "        if y.ndim == 1:\n",
                "            y = y.reshape(-1, 1)\n",
                "\n",
                "        return super().fit(X, y, **fit_params)\n",
                "\n",
                "    def predict(self, X):\n",
                "        if isinstance(X, pd.Series):\n",
                "            print(\"SkorchRegressor.predict X is a series. Why? (dev note)\")\n",
                "            X = X.to_numpy()\n",
                "        elif isinstance(X, pd.DataFrame):\n",
                "            X = X.to_numpy()\n",
                "\n",
                "        return super().predict(X)\n",
                "\n",
                "    def predict_proba(self, X):\n",
                "        if isinstance(X, pd.Series):\n",
                "            print(\"SkorchRegressor.predict_proba X is a series. Why? (dev note)\")\n",
                "            X = X.to_numpy()\n",
                "        elif isinstance(X, pd.DataFrame):\n",
                "            X = X.to_numpy()\n",
                "\n",
                "        return super().predict_proba(X)"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "# Model\n"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## Callbacks\n",
                "\n",
                "- [Skorch MlflowLogger Doc Ref](https://skorch.readthedocs.io/en/latest/callbacks.html#skorch.callbacks.MlflowLogger)\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 9,
            "metadata": {},
            "outputs": [],
            "source": [
                "early_stopping = EarlyStopping(patience=5, monitor=\"train_loss\")\n",
                "\n",
                "# Uses torch.optim.lr_scheduler.StepLR to scale learning rates by gamma=0.1 every 7 steps\n",
                "lrscheduler = LRScheduler(policy=\"StepLR\", step_size=7, gamma=0.1)\n",
                "\n",
                "# Saves the best model by monitoring the validation accuracy.\n",
                "checkpoint = Checkpoint(f_params=\"best_model.pt\", monitor=\"valid_loss_best\")\n",
                "\n",
                "\n",
                "# Mlflow\n",
                "client = MlflowClient()\n",
                "experiment = client.get_experiment_by_name(\"Default\")\n",
                "run = client.create_run(experiment.experiment_id)\n",
                "mlflow_callback = MlflowLogger(run, client)\n",
                "\n",
                "\n",
                "callbacks = [early_stopping, lrscheduler, checkpoint, mlflow_callback]\n",
                "callbacks = None"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 13,
            "metadata": {},
            "outputs": [],
            "source": [
                "pytorch_model = SimpleMLP(\n",
                "    input_size=X_train.shape[1], output_size=1, hidden_size_1=30, hidden_size_2=10\n",
                ")\n",
                "\n",
                "skorch_model = SkorchRegressor(\n",
                "    pytorch_model,\n",
                "    max_epochs=100,\n",
                "    lr=0.1,\n",
                "    # device=\"cpu\",  # \"cuda\"\n",
                "    device=device,\n",
                "    criterion=torch.nn.MSELoss,  # custom loss can be defined\n",
                "    batch_size=64,\n",
                "    # train_split=ValidSplit(5),  # should be None for GridSearch\n",
                "    train_split=None,\n",
                "    iterator_train__shuffle=False,\n",
                "    # Shuffle training data on each epoch\n",
                "    iterator_train__num_workers=2,\n",
                "    # iterator_val__shuffle=False, # Shuffle training data on each epoch\n",
                "    optimizer=torch.optim.Adam,\n",
                "    ## custom optimizer\n",
                "    # optimizer=custom_optim,\n",
                "    # optimizer__optimizer_cls=torch.optim.Adam,\n",
                "    # optimizer__weight_decay=1e-2,\n",
                "    # optimizer__k=5,\n",
                "    # optimizer__alpha=0.5,\n",
                "    verbose=0,\n",
                "    callbacks=callbacks,\n",
                ")\n",
                "sktime_pytorch_model = YfromX(skorch_model)"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 11,
            "metadata": {
                "tags": []
            },
            "outputs": [
                {
                    "data": {
                        "text/html": [
                            "<style>#sk-d882b79d-7961-4e89-88ef-af7e1b29cccf {color: black;background-color: white;}#sk-d882b79d-7961-4e89-88ef-af7e1b29cccf pre{padding: 0;}#sk-d882b79d-7961-4e89-88ef-af7e1b29cccf div.sk-toggleable {background-color: white;}#sk-d882b79d-7961-4e89-88ef-af7e1b29cccf label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-d882b79d-7961-4e89-88ef-af7e1b29cccf label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-d882b79d-7961-4e89-88ef-af7e1b29cccf label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-d882b79d-7961-4e89-88ef-af7e1b29cccf div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-d882b79d-7961-4e89-88ef-af7e1b29cccf div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-d882b79d-7961-4e89-88ef-af7e1b29cccf div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-d882b79d-7961-4e89-88ef-af7e1b29cccf input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-d882b79d-7961-4e89-88ef-af7e1b29cccf input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-d882b79d-7961-4e89-88ef-af7e1b29cccf div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-d882b79d-7961-4e89-88ef-af7e1b29cccf div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-d882b79d-7961-4e89-88ef-af7e1b29cccf input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-d882b79d-7961-4e89-88ef-af7e1b29cccf div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-d882b79d-7961-4e89-88ef-af7e1b29cccf div.sk-estimator:hover {background-color: #d4ebff;}#sk-d882b79d-7961-4e89-88ef-af7e1b29cccf div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-d882b79d-7961-4e89-88ef-af7e1b29cccf div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-d882b79d-7961-4e89-88ef-af7e1b29cccf div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 2em;bottom: 0;left: 50%;}#sk-d882b79d-7961-4e89-88ef-af7e1b29cccf div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;}#sk-d882b79d-7961-4e89-88ef-af7e1b29cccf div.sk-item {z-index: 1;}#sk-d882b79d-7961-4e89-88ef-af7e1b29cccf div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;}#sk-d882b79d-7961-4e89-88ef-af7e1b29cccf div.sk-parallel::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 2em;bottom: 0;left: 50%;}#sk-d882b79d-7961-4e89-88ef-af7e1b29cccf div.sk-parallel-item {display: flex;flex-direction: column;position: relative;background-color: white;}#sk-d882b79d-7961-4e89-88ef-af7e1b29cccf div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-d882b79d-7961-4e89-88ef-af7e1b29cccf div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-d882b79d-7961-4e89-88ef-af7e1b29cccf div.sk-parallel-item:only-child::after {width: 0;}#sk-d882b79d-7961-4e89-88ef-af7e1b29cccf div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;position: relative;}#sk-d882b79d-7961-4e89-88ef-af7e1b29cccf div.sk-label label {font-family: monospace;font-weight: bold;background-color: white;display: inline-block;line-height: 1.2em;}#sk-d882b79d-7961-4e89-88ef-af7e1b29cccf div.sk-label-container {position: relative;z-index: 2;text-align: center;}#sk-d882b79d-7961-4e89-88ef-af7e1b29cccf div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-d882b79d-7961-4e89-88ef-af7e1b29cccf div.sk-text-repr-fallback {display: none;}</style><div id='sk-d882b79d-7961-4e89-88ef-af7e1b29cccf' class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>YfromX(estimator=&lt;class &#x27;__main__.SkorchRegressor&#x27;&gt;[uninitialized](\n",
                            "  module=SimpleMLP(\n",
                            "    (fc1): Linear(in_features=4, out_features=30, bias=True)\n",
                            "    (activation): ReLU()\n",
                            "    (fc2): Linear(in_features=30, out_features=10, bias=True)\n",
                            "    (output): Linear(in_features=10, out_features=1, bias=True)\n",
                            "  ),\n",
                            "))</pre><b>Please rerun this cell to show the HTML repr or trust the notebook.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item sk-dashed-wrapped\"><div class='sk-label-container'><div class=\"sk-label sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=UUID('de7dad26-c8db-461d-986d-09175bdd970a') type=\"checkbox\" ><label for=UUID('de7dad26-c8db-461d-986d-09175bdd970a') class='sk-toggleable__label sk-toggleable__label-arrow'>YfromX</label><div class=\"sk-toggleable__content\"><pre>YfromX(estimator=&lt;class &#x27;__main__.SkorchRegressor&#x27;&gt;[uninitialized](\n",
                            "  module=SimpleMLP(\n",
                            "    (fc1): Linear(in_features=4, out_features=30, bias=True)\n",
                            "    (activation): ReLU()\n",
                            "    (fc2): Linear(in_features=30, out_features=10, bias=True)\n",
                            "    (output): Linear(in_features=10, out_features=1, bias=True)\n",
                            "  ),\n",
                            "))</pre></div></div></div><div class=\"sk-parallel\"><div class=\"sk-parallel-item\"><div class=\"sk-item\"><div class=\"sk-serial\"><div class='sk-item'><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=UUID('efeb07b2-68dd-4a6e-be01-b4c49f2734ce') type=\"checkbox\" ><label for=UUID('efeb07b2-68dd-4a6e-be01-b4c49f2734ce') class='sk-toggleable__label sk-toggleable__label-arrow'>SkorchRegressor</label><div class=\"sk-toggleable__content\"><pre>&lt;class &#x27;__main__.SkorchRegressor&#x27;&gt;[uninitialized](\n",
                            "  module=SimpleMLP(\n",
                            "    (fc1): Linear(in_features=4, out_features=30, bias=True)\n",
                            "    (activation): ReLU()\n",
                            "    (fc2): Linear(in_features=30, out_features=10, bias=True)\n",
                            "    (output): Linear(in_features=10, out_features=1, bias=True)\n",
                            "  ),\n",
                            ")</pre></div></div></div></div></div></div></div></div></div></div>"
                        ],
                        "text/plain": [
                            "YfromX(estimator=<class '__main__.SkorchRegressor'>[uninitialized](\n",
                            "  module=SimpleMLP(\n",
                            "    (fc1): Linear(in_features=4, out_features=30, bias=True)\n",
                            "    (activation): ReLU()\n",
                            "    (fc2): Linear(in_features=30, out_features=10, bias=True)\n",
                            "    (output): Linear(in_features=10, out_features=1, bias=True)\n",
                            "  ),\n",
                            "))"
                        ]
                    },
                    "execution_count": 11,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "sktime_pytorch_model.fit(y=y_train, X=X_train)"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 12,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "text/plain": [
                            "(<Figure size 1600x400 with 1 Axes>, <Axes: ylabel='Consumption'>)"
                        ]
                    },
                    "execution_count": 12,
                    "metadata": {},
                    "output_type": "execute_result"
                },
                {
                    "data": {
                        "image/png": "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",
                        "text/plain": [
                            "<Figure size 1600x400 with 1 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                }
            ],
            "source": [
                "y_pred = sktime_pytorch_model.predict(fh=fh, X=X_test)\n",
                "\n",
                "plot_series(y_train, y_test, y_pred, labels=[\"y_train\", \"y_test\", \"y_pred\"])"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## Validation && TrainLoss History\n",
                "\n",
                "- Works when `train_split` is not None.\n",
                "- `train_split` should be None in order for `ForecastingGridSearchCV` to work.\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 30,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "image/png": "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",
                        "text/plain": [
                            "<Figure size 1000x800 with 1 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                }
            ],
            "source": [
                "val_loss = []\n",
                "train_loss = []\n",
                "for i in range(10):\n",
                "    val_loss.append(sktime_pytorch_model.estimator_.history[i][\"valid_loss\"])\n",
                "    train_loss.append(sktime_pytorch_model.estimator_.history[i][\"train_loss\"])\n",
                "\n",
                "plt.figure(figsize=(10, 8))\n",
                "plt.semilogy(train_loss, label=\"Train loss\")\n",
                "plt.semilogy(val_loss, label=\"Validation loss\")\n",
                "plt.xlabel(\"Epoch\")\n",
                "plt.ylabel(\"Loss\")\n",
                "plt.grid()\n",
                "plt.legend()\n",
                "plt.show()"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## Grid Search\n",
                "\n",
                "- Although skorch models defines `get_params()` they are not fetch from sktime. \n",
                "- Hence, `__module` params not working in grid search\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 12,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "iterator_train, iterator_valid, callbacks, dataset, compile\n",
                        "**************************************************\n",
                        "estimator, pooling, estimator__module, estimator__criterion, estimator__optimizer, estimator__lr, estimator__max_epochs, estimator__batch_size, estimator__iterator_train, estimator__iterator_valid, estimator__dataset, estimator__train_split, estimator__callbacks, estimator__predict_nonlinearity, estimator__warm_start, estimator__verbose, estimator__device, estimator__compile, estimator___params_to_validate, estimator__iterator_train__shuffle, estimator__iterator_train__num_workers, estimator__callbacks__epoch_timer, estimator__callbacks__train_loss, estimator__callbacks__train_loss__name, estimator__callbacks__train_loss__lower_is_better, estimator__callbacks__train_loss__on_train, estimator__callbacks__valid_loss, estimator__callbacks__valid_loss__name, estimator__callbacks__valid_loss__lower_is_better, estimator__callbacks__valid_loss__on_train, estimator__callbacks__print_log, estimator__callbacks__print_log__keys_ignored, estimator__callbacks__print_log__sink, estimator__callbacks__print_log__tablefmt, estimator__callbacks__print_log__floatfmt, estimator__callbacks__print_log__stralign\n"
                    ]
                }
            ],
            "source": [
                "print(\", \".join(sktime_pytorch_model.estimator.prefixes_))\n",
                "print(\"*\" * 50)\n",
                "print(\", \".join(sktime_pytorch_model.get_params()))"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 14,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Fitting 1 folds for each of 8 candidates, totalling 8 fits\n"
                    ]
                },
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "/home/ilker/miniconda3/envs/sktime-pytorch/lib/python3.8/site-packages/sktime/forecasting/model_evaluation/_functions.py:480: FitFailedWarning: \n",
                        "                In evaluate, fitting of forecaster YfromX failed,\n",
                        "                you can set error_score='raise' in evaluate to see\n",
                        "                the exception message. Fit failed for len(y_train)=131.\n",
                        "                The score will be set to nan.\n",
                        "                Failed forecaster with parameters: YfromX(estimator=<class '__main__.SkorchRegressor'>[uninitialized](\n",
                        "  module=SimpleMLP(\n",
                        "    (fc1): Linear(in_features=4, out_features=30, bias=True)\n",
                        "    (activation): ReLU()\n",
                        "    (fc2): Linear(in_features=30, out_features=10, bias=True)\n",
                        "    (output): Linear(in_features=10, out_features=1, bias=True)\n",
                        "  ),\n",
                        ")).\n",
                        "                \n",
                        "  result = _evaluate_window(\n",
                        "/home/ilker/miniconda3/envs/sktime-pytorch/lib/python3.8/site-packages/sktime/forecasting/model_evaluation/_functions.py:480: FitFailedWarning: \n",
                        "                In evaluate, fitting of forecaster YfromX failed,\n",
                        "                you can set error_score='raise' in evaluate to see\n",
                        "                the exception message. Fit failed for len(y_train)=131.\n",
                        "                The score will be set to nan.\n",
                        "                Failed forecaster with parameters: YfromX(estimator=<class '__main__.SkorchRegressor'>[uninitialized](\n",
                        "  module=SimpleMLP(\n",
                        "    (fc1): Linear(in_features=4, out_features=30, bias=True)\n",
                        "    (activation): ReLU()\n",
                        "    (fc2): Linear(in_features=30, out_features=10, bias=True)\n",
                        "    (output): Linear(in_features=10, out_features=1, bias=True)\n",
                        "  ),\n",
                        ")).\n",
                        "                \n",
                        "  result = _evaluate_window(\n",
                        "/home/ilker/miniconda3/envs/sktime-pytorch/lib/python3.8/site-packages/sktime/forecasting/model_evaluation/_functions.py:480: FitFailedWarning: \n",
                        "                In evaluate, fitting of forecaster YfromX failed,\n",
                        "                you can set error_score='raise' in evaluate to see\n",
                        "                the exception message. Fit failed for len(y_train)=131.\n",
                        "                The score will be set to nan.\n",
                        "                Failed forecaster with parameters: YfromX(estimator=<class '__main__.SkorchRegressor'>[uninitialized](\n",
                        "  module=SimpleMLP(\n",
                        "    (fc1): Linear(in_features=4, out_features=30, bias=True)\n",
                        "    (activation): ReLU()\n",
                        "    (fc2): Linear(in_features=30, out_features=10, bias=True)\n",
                        "    (output): Linear(in_features=10, out_features=1, bias=True)\n",
                        "  ),\n",
                        ")).\n",
                        "                \n",
                        "  result = _evaluate_window(\n",
                        "/home/ilker/miniconda3/envs/sktime-pytorch/lib/python3.8/site-packages/sktime/forecasting/model_evaluation/_functions.py:480: FitFailedWarning: \n",
                        "                In evaluate, fitting of forecaster YfromX failed,\n",
                        "                you can set error_score='raise' in evaluate to see\n",
                        "                the exception message. Fit failed for len(y_train)=131.\n",
                        "                The score will be set to nan.\n",
                        "                Failed forecaster with parameters: YfromX(estimator=<class '__main__.SkorchRegressor'>[uninitialized](\n",
                        "  module=SimpleMLP(\n",
                        "    (fc1): Linear(in_features=4, out_features=30, bias=True)\n",
                        "    (activation): ReLU()\n",
                        "    (fc2): Linear(in_features=30, out_features=10, bias=True)\n",
                        "    (output): Linear(in_features=10, out_features=1, bias=True)\n",
                        "  ),\n",
                        ")).\n",
                        "                \n",
                        "  result = _evaluate_window(\n",
                        "/home/ilker/miniconda3/envs/sktime-pytorch/lib/python3.8/site-packages/sktime/forecasting/model_evaluation/_functions.py:480: FitFailedWarning: \n",
                        "                In evaluate, fitting of forecaster YfromX failed,\n",
                        "                you can set error_score='raise' in evaluate to see\n",
                        "                the exception message. Fit failed for len(y_train)=131.\n",
                        "                The score will be set to nan.\n",
                        "                Failed forecaster with parameters: YfromX(estimator=<class '__main__.SkorchRegressor'>[uninitialized](\n",
                        "  module=SimpleMLP(\n",
                        "    (fc1): Linear(in_features=4, out_features=30, bias=True)\n",
                        "    (activation): ReLU()\n",
                        "    (fc2): Linear(in_features=30, out_features=10, bias=True)\n",
                        "    (output): Linear(in_features=10, out_features=1, bias=True)\n",
                        "  ),\n",
                        ")).\n",
                        "                \n",
                        "  result = _evaluate_window(\n",
                        "/home/ilker/miniconda3/envs/sktime-pytorch/lib/python3.8/site-packages/sktime/forecasting/model_evaluation/_functions.py:480: FitFailedWarning: \n",
                        "                In evaluate, fitting of forecaster YfromX failed,\n",
                        "                you can set error_score='raise' in evaluate to see\n",
                        "                the exception message. Fit failed for len(y_train)=131.\n",
                        "                The score will be set to nan.\n",
                        "                Failed forecaster with parameters: YfromX(estimator=<class '__main__.SkorchRegressor'>[uninitialized](\n",
                        "  module=SimpleMLP(\n",
                        "    (fc1): Linear(in_features=4, out_features=30, bias=True)\n",
                        "    (activation): ReLU()\n",
                        "    (fc2): Linear(in_features=30, out_features=10, bias=True)\n",
                        "    (output): Linear(in_features=10, out_features=1, bias=True)\n",
                        "  ),\n",
                        ")).\n",
                        "                \n",
                        "  result = _evaluate_window(\n",
                        "/home/ilker/miniconda3/envs/sktime-pytorch/lib/python3.8/site-packages/sktime/forecasting/model_evaluation/_functions.py:480: FitFailedWarning: \n",
                        "                In evaluate, fitting of forecaster YfromX failed,\n",
                        "                you can set error_score='raise' in evaluate to see\n",
                        "                the exception message. Fit failed for len(y_train)=131.\n",
                        "                The score will be set to nan.\n",
                        "                Failed forecaster with parameters: YfromX(estimator=<class '__main__.SkorchRegressor'>[uninitialized](\n",
                        "  module=SimpleMLP(\n",
                        "    (fc1): Linear(in_features=4, out_features=30, bias=True)\n",
                        "    (activation): ReLU()\n",
                        "    (fc2): Linear(in_features=30, out_features=10, bias=True)\n",
                        "    (output): Linear(in_features=10, out_features=1, bias=True)\n",
                        "  ),\n",
                        ")).\n",
                        "                \n",
                        "  result = _evaluate_window(\n",
                        "/home/ilker/miniconda3/envs/sktime-pytorch/lib/python3.8/site-packages/sktime/forecasting/model_evaluation/_functions.py:480: FitFailedWarning: \n",
                        "                In evaluate, fitting of forecaster YfromX failed,\n",
                        "                you can set error_score='raise' in evaluate to see\n",
                        "                the exception message. Fit failed for len(y_train)=131.\n",
                        "                The score will be set to nan.\n",
                        "                Failed forecaster with parameters: YfromX(estimator=<class '__main__.SkorchRegressor'>[uninitialized](\n",
                        "  module=SimpleMLP(\n",
                        "    (fc1): Linear(in_features=4, out_features=30, bias=True)\n",
                        "    (activation): ReLU()\n",
                        "    (fc2): Linear(in_features=30, out_features=10, bias=True)\n",
                        "    (output): Linear(in_features=10, out_features=1, bias=True)\n",
                        "  ),\n",
                        ")).\n",
                        "                \n",
                        "  result = _evaluate_window(\n"
                    ]
                },
                {
                    "ename": "NotFittedError",
                    "evalue": "All fits of forecaster failed,\n                set error_score='raise' to see the exceptions.\n                Failed forecaster: YfromX(estimator=<class '__main__.SkorchRegressor'>[uninitialized](\n  module=SimpleMLP(\n    (fc1): Linear(in_features=4, out_features=30, bias=True)\n    (activation): ReLU()\n    (fc2): Linear(in_features=30, out_features=10, bias=True)\n    (output): Linear(in_features=10, out_features=1, bias=True)\n  ),\n))",
                    "output_type": "error",
                    "traceback": [
                        "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
                        "\u001b[0;31mNotFittedError\u001b[0m                            Traceback (most recent call last)",
                        "Cell \u001b[0;32mIn[14], line 20\u001b[0m\n\u001b[1;32m     10\u001b[0m cv \u001b[39m=\u001b[39m SingleWindowSplitter(fh\u001b[39m=\u001b[39mtest_size)\n\u001b[1;32m     12\u001b[0m gs \u001b[39m=\u001b[39m ForecastingGridSearchCV(\n\u001b[1;32m     13\u001b[0m     forecaster\u001b[39m=\u001b[39msktime_pytorch_model,\n\u001b[1;32m     14\u001b[0m     param_grid\u001b[39m=\u001b[39mparams,\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m     18\u001b[0m     n_jobs\u001b[39m=\u001b[39m\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m,\n\u001b[1;32m     19\u001b[0m )\n\u001b[0;32m---> 20\u001b[0m gs\u001b[39m.\u001b[39;49mfit(X_train, y_train)\n",
                        "File \u001b[0;32m~/miniconda3/envs/sktime-pytorch/lib/python3.8/site-packages/sktime/forecasting/base/_base.py:352\u001b[0m, in \u001b[0;36mBaseForecaster.fit\u001b[0;34m(self, y, X, fh)\u001b[0m\n\u001b[1;32m    349\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_fit(y\u001b[39m=\u001b[39my_inner, X\u001b[39m=\u001b[39mX_inner, fh\u001b[39m=\u001b[39mfh)\n\u001b[1;32m    350\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m    351\u001b[0m     \u001b[39m# otherwise we call the vectorized version of fit\u001b[39;00m\n\u001b[0;32m--> 352\u001b[0m     \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_vectorize(\u001b[39m\"\u001b[39;49m\u001b[39mfit\u001b[39;49m\u001b[39m\"\u001b[39;49m, y\u001b[39m=\u001b[39;49my_inner, X\u001b[39m=\u001b[39;49mX_inner, fh\u001b[39m=\u001b[39;49mfh)\n\u001b[1;32m    354\u001b[0m \u001b[39m# this should happen last\u001b[39;00m\n\u001b[1;32m    355\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_is_fitted \u001b[39m=\u001b[39m \u001b[39mTrue\u001b[39;00m\n",
                        "File \u001b[0;32m~/miniconda3/envs/sktime-pytorch/lib/python3.8/site-packages/sktime/forecasting/base/_base.py:1833\u001b[0m, in \u001b[0;36mBaseForecaster._vectorize\u001b[0;34m(self, methodname, **kwargs)\u001b[0m\n\u001b[1;32m   1830\u001b[0m     \u001b[39melse\u001b[39;00m:\n\u001b[1;32m   1831\u001b[0m         forecasters_ \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mforecasters_\n\u001b[0;32m-> 1833\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mforecasters_ \u001b[39m=\u001b[39m y\u001b[39m.\u001b[39;49mvectorize_est(\n\u001b[1;32m   1834\u001b[0m         forecasters_, method\u001b[39m=\u001b[39;49mmethodname, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs\n\u001b[1;32m   1835\u001b[0m     )\n\u001b[1;32m   1836\u001b[0m     \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\n\u001b[1;32m   1838\u001b[0m \u001b[39m# predict-like methods: return as list, then run through reconstruct\u001b[39;00m\n\u001b[1;32m   1839\u001b[0m \u001b[39m# to obtain a pandas based container in one of the pandas mtype formats\u001b[39;00m\n",
                        "File \u001b[0;32m~/miniconda3/envs/sktime-pytorch/lib/python3.8/site-packages/sktime/datatypes/_vectorize.py:584\u001b[0m, in \u001b[0;36mVectorizedDF.vectorize_est\u001b[0;34m(self, estimator, method, args, args_rowvec, return_type, rowname_default, colname_default, varname_of_self, **kwargs)\u001b[0m\n\u001b[1;32m    581\u001b[0m     args_i[varname_of_self] \u001b[39m=\u001b[39m group\n\u001b[1;32m    583\u001b[0m est_i_method \u001b[39m=\u001b[39m \u001b[39mgetattr\u001b[39m(est_i, method)\n\u001b[0;32m--> 584\u001b[0m est_i_result \u001b[39m=\u001b[39m est_i_method(\u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49margs_i)\n\u001b[1;32m    586\u001b[0m \u001b[39mif\u001b[39;00m group_name \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m    587\u001b[0m     group_name \u001b[39m=\u001b[39m rowname_default\n",
                        "File \u001b[0;32m~/miniconda3/envs/sktime-pytorch/lib/python3.8/site-packages/sktime/forecasting/base/_base.py:349\u001b[0m, in \u001b[0;36mBaseForecaster.fit\u001b[0;34m(self, y, X, fh)\u001b[0m\n\u001b[1;32m    347\u001b[0m \u001b[39m# we call the ordinary _fit if no looping/vectorization needed\u001b[39;00m\n\u001b[1;32m    348\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m vectorization_needed:\n\u001b[0;32m--> 349\u001b[0m     \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_fit(y\u001b[39m=\u001b[39;49my_inner, X\u001b[39m=\u001b[39;49mX_inner, fh\u001b[39m=\u001b[39;49mfh)\n\u001b[1;32m    350\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m    351\u001b[0m     \u001b[39m# otherwise we call the vectorized version of fit\u001b[39;00m\n\u001b[1;32m    352\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_vectorize(\u001b[39m\"\u001b[39m\u001b[39mfit\u001b[39m\u001b[39m\"\u001b[39m, y\u001b[39m=\u001b[39my_inner, X\u001b[39m=\u001b[39mX_inner, fh\u001b[39m=\u001b[39mfh)\n",
                        "File \u001b[0;32m~/miniconda3/envs/sktime-pytorch/lib/python3.8/site-packages/sktime/forecasting/model_selection/_tune.py:235\u001b[0m, in \u001b[0;36mBaseGridSearch._fit\u001b[0;34m(self, y, X, fh)\u001b[0m\n\u001b[1;32m    233\u001b[0m \u001b[39m# Raise error if all fits in evaluate failed because all score values are NaN.\u001b[39;00m\n\u001b[1;32m    234\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mbest_index_ \u001b[39m==\u001b[39m \u001b[39m-\u001b[39m\u001b[39m1\u001b[39m:\n\u001b[0;32m--> 235\u001b[0m     \u001b[39mraise\u001b[39;00m NotFittedError(\n\u001b[1;32m    236\u001b[0m         \u001b[39mf\u001b[39m\u001b[39m\"\"\"\u001b[39m\u001b[39mAll fits of forecaster failed,\u001b[39m\n\u001b[1;32m    237\u001b[0m \u001b[39m        set error_score=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mraise\u001b[39m\u001b[39m'\u001b[39m\u001b[39m to see the exceptions.\u001b[39m\n\u001b[1;32m    238\u001b[0m \u001b[39m        Failed forecaster: \u001b[39m\u001b[39m{\u001b[39;00m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mforecaster\u001b[39m}\u001b[39;00m\u001b[39m\"\"\"\u001b[39m\n\u001b[1;32m    239\u001b[0m     )\n\u001b[1;32m    240\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mbest_score_ \u001b[39m=\u001b[39m results\u001b[39m.\u001b[39mloc[\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mbest_index_, \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mmean_\u001b[39m\u001b[39m{\u001b[39;00mscoring_name\u001b[39m}\u001b[39;00m\u001b[39m\"\u001b[39m]\n\u001b[1;32m    241\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mbest_params_ \u001b[39m=\u001b[39m results\u001b[39m.\u001b[39mloc[\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mbest_index_, \u001b[39m\"\u001b[39m\u001b[39mparams\u001b[39m\u001b[39m\"\u001b[39m]\n",
                        "\u001b[0;31mNotFittedError\u001b[0m: All fits of forecaster failed,\n                set error_score='raise' to see the exceptions.\n                Failed forecaster: YfromX(estimator=<class '__main__.SkorchRegressor'>[uninitialized](\n  module=SimpleMLP(\n    (fc1): Linear(in_features=4, out_features=30, bias=True)\n    (activation): ReLU()\n    (fc2): Linear(in_features=30, out_features=10, bias=True)\n    (output): Linear(in_features=10, out_features=1, bias=True)\n  ),\n))"
                    ]
                }
            ],
            "source": [
                "params = {\n",
                "    \"estimator__lr\": [0.05, 0.1],\n",
                "    \"estimator__batch_size\": [32, 64],\n",
                "    # \"estimator__optimizer\": [torch.optim.Adam, torch.optim.SGD, torch.optim.RMSprop],\n",
                "    \"estimator__max_epochs\": [10, 20],\n",
                "    # \"estimator__module__activation\": [\"relu\", \"tanh\"],\n",
                "}\n",
                "\n",
                "# cv = ExpandingGreedySplitter(folds=3, test_size=test_size)\n",
                "cv = SingleWindowSplitter(fh=test_size)\n",
                "\n",
                "gs = ForecastingGridSearchCV(\n",
                "    forecaster=sktime_pytorch_model,\n",
                "    param_grid=params,\n",
                "    refit=False,\n",
                "    cv=cv,\n",
                "    verbose=1,\n",
                "    n_jobs=-1,\n",
                ")\n",
                "gs.fit(X_train, y_train)"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## Save/Load Model\n",
                "\n",
                "- This only saves and loads the proper module parameters, meaning that hyperparameters such as lr and max_epochs are not saved. Therefore, to load the model, we have to re-initialize it beforehand.\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "file_name = \"skorch_model\"\n",
                "\n",
                "sktime_pytorch_model.save_params(f_params=file_name)  # a file handler also works\n",
                "\n",
                "# first initialize the model\n",
                "# TODO: Other field like `max_epochs`, `lr` etc. needs re-defining?\n",
                "new_net = SkorchRegressor(SimpleMLP).initialize()\n",
                "\n",
                "new_net.load_params(file_name)"
            ]
        }
    ],
    "metadata": {
        "interpreter": {
            "hash": "5bc8f6cf25ca0e55cc21a562f1ee8063e70565d7d58fe891f8de87adc740ad20"
        },
        "kernelspec": {
            "display_name": "Python 3.8.13 ('predy-ts')",
            "language": "python",
            "name": "python3"
        },
        "language_info": {
            "codemirror_mode": {
                "name": "ipython",
                "version": 3
            },
            "file_extension": ".py",
            "mimetype": "text/x-python",
            "name": "python",
            "nbconvert_exporter": "python",
            "pygments_lexer": "ipython3",
            "version": "3.8.17"
        }
    },
    "nbformat": 4,
    "nbformat_minor": 4
}