lstm_multi_outputs.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "pycharm": {
          "is_executing": false
        }
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "# from generate_data import *\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import math \n",
        "from load_matlab_timedata import get_data_from\n",
        "import sklearn.preprocessing \n",
        "from tqdm import tqdm_notebook as tqdm\n",
        "import random\n",
        "import yaml\n",
        "import h5py\n",
        "from torch.utils.data import Dataset, DataLoader, SequentialSampler, BatchSampler\n",
        "import logging\n",
        "import datetime\n",
        "import os\n",
        "import time\n",
        "import torch.nn.functional as F\n",
        "from src.TSGenerator import f_Y, f_X, get_func_timeseries\n",
        "from src.DataLoader import TimeSeriesDataset\n",
        "from src.model_utils import init_logger, plot_shared_scale, plot_multiscale\n",
        "from src.Model import LSTM\n",
        "from src.Losses import myLoss\n",
        "import pprint"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "pycharm": {
          "is_executing": false
        }
      },
      "outputs": [
        {
          "name": "stdout",
          "text": [
            "dc_engine_random_sig_const_periods.slx\r\ndc_engine_random_sig_random_period_gaus_noise.slx\r\ndc_engine_random_sig_random_period_gaus_noise.slx.autosave\r\ndc_engine_random_sig_random_period_gaus_noise.slxc\r\ndc_engine_random_sig_random_period.slx\r\ndc_engine_random_sig_random_period.slxc\r\ndc_engine_random_sig_random_period.slx.original\r\nDC_motor_simulation.prj\r\ndiff_eq_system.slx\r\ndiff_eq_system.slx.original\r\nres.mat\r\nresources\r\nslprj\r\n"
          ],
          "output_type": "stream"
        }
      ],
      "source": [
        "! ls DC_motor_simulation"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "pycharm": {
          "is_executing": false
        }
      },
      "outputs": [],
      "source": [
        "plt.rcParams[\u0027figure.figsize\u0027] \u003d 20, 7."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "pycharm": {}
      },
      "outputs": [],
      "source": [
        "CONFIG_FILENAME \u003d \"model_params.yaml\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "pycharm": {}
      },
      "outputs": [],
      "source": [
        "with open(CONFIG_FILENAME, \u0027r\u0027) as f:\n",
        "        config \u003d yaml.load(f, Loader\u003dyaml.FullLoader)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "pycharm": {}
      },
      "outputs": [],
      "source": [
        "to_generate_data \u003d config[\u0027to_generate_data\u0027]\n",
        "if to_generate_data:\n",
        "    p_gen \u003d config[\u0027generator_params\u0027]\n",
        "    a \u003d p_gen[\u0027a\u0027]\n",
        "is_debug \u003d config[\u0027is_debug\u0027]\n",
        "if is_debug:\n",
        "    p_generate \u003d config[\u0027generator_params\u0027]\n",
        "    pprint.pprint(p_generate)\n",
        "    "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "pycharm": {}
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "{\u0027data_params\u0027: {\u0027leave_nth\u0027: 13,\n",
            "                 \u0027mat_file\u0027: \u0027DC_motor_simulation/res.mat\u0027,\n",
            "                 \u0027need_normalize\u0027: True,\n",
            "                 \u0027test_size\u0027: 0.3},\n",
            " \u0027exp_path\u0027: \u0027only_batches\u0027,\n",
            " \u0027generator_params\u0027: {\u0027a\u0027: 0.5, \u0027b\u0027: 1.0, \u0027f_X\u0027: \u0027math.sin\u0027, \u0027f_Y\u0027: \u0027math.cos\u0027},\n",
            " \u0027is_debug\u0027: False,\n",
            " \u0027network_params\u0027: {\u0027dtype\u0027: \u0027torch.float\u0027,\n",
            "                    \u0027hidden_size\u0027: 16,\n",
            "                    \u0027input_size\u0027: 64,\n",
            "                    \u0027num_layers\u0027: 1,\n",
            "                    \u0027output_dim\u0027: 3,\n",
            "                    \u0027per_element\u0027: True,\n",
            "                    \u0027retrospective_steps\u0027: 128},\n",
            " \u0027to_generate_data\u0027: False,\n",
            " \u0027train_params\u0027: {\u0027batch_size\u0027: 128,\n",
            "                  \u0027learning_rate\u0027: 0.1,\n",
            "                  \u0027loss_fn\u0027: \u0027mse\u0027,\n",
            "                  \u0027num_epochs\u0027: 40,\n",
            "                  \u0027optimizer\u0027: \u0027adam\u0027,\n",
            "                  \u0027reduction\u0027: \u0027sum\u0027}}\n"
          ]
        }
      ],
      "source": [
        "pprint.pprint(config)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "pycharm": {}
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "{\u0027leave_nth\u0027: 13,\n",
            " \u0027mat_file\u0027: \u0027DC_motor_simulation/res.mat\u0027,\n",
            " \u0027need_normalize\u0027: True,\n",
            " \u0027test_size\u0027: 0.3}\n"
          ]
        }
      ],
      "source": [
        "p_data \u003d config[\u0027data_params\u0027]\n",
        "pprint.pprint(p_data)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "pycharm": {}
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "{\u0027dtype\u0027: \u0027torch.float\u0027,\n",
            " \u0027hidden_size\u0027: 16,\n",
            " \u0027input_size\u0027: 64,\n",
            " \u0027num_layers\u0027: 1,\n",
            " \u0027output_dim\u0027: 3,\n",
            " \u0027per_element\u0027: True,\n",
            " \u0027retrospective_steps\u0027: 128}\n"
          ]
        }
      ],
      "source": [
        "p_net \u003d config[\u0027network_params\u0027]\n",
        "pprint.pprint(p_net)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "pycharm": {}
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "{\u0027batch_size\u0027: 128,\n",
            " \u0027learning_rate\u0027: 0.1,\n",
            " \u0027loss_fn\u0027: \u0027mse\u0027,\n",
            " \u0027num_epochs\u0027: 40,\n",
            " \u0027optimizer\u0027: \u0027adam\u0027,\n",
            " \u0027reduction\u0027: \u0027sum\u0027}\n"
          ]
        }
      ],
      "source": [
        "p_train \u003d config[\u0027train_params\u0027]\n",
        "pprint.pprint(p_train)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "pycharm": {}
      },
      "outputs": [],
      "source": [
        "p_gen \u003d config[\u0027generator_params\u0027]\n",
        "a \u003d p_gen[\u0027a\u0027]\n",
        "b \u003d p_gen[\u0027b\u0027]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "pycharm": {}
      },
      "outputs": [],
      "source": [
        "if is_debug:\n",
        "    x, y \u003d get_func_timeseries(f_Y \u003d f_Y, f_X \u003d f_X, a\u003dp_generate[\u0027a\u0027], b\u003dp_generate[\u0027b\u0027])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "pycharm": {}
      },
      "outputs": [],
      "source": [
        "#####################\n",
        "# Set parameters\n",
        "#####################\n",
        "# # If `per_element` is True, then LSTM reads in one timestep at a time.\n",
        "if  p_net[\u0027per_element\u0027]:\n",
        "    lstm_input_size \u003d 1\n",
        "else:\n",
        "    lstm_input_size \u003d p_net[\u0027input_size\u0027]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "pycharm": {}
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "logger inited to file [only_batcheslogs/exp_2019-04-24_16:04:52.log]\n"
          ]
        }
      ],
      "source": [
        "init_logger(config)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "pycharm": {}
      },
      "outputs": [],
      "source": [
        "logging.info(\"Experiment started with params\")\n",
        "logging.info(f\"data_par: {p_data}\")\n",
        "logging.info(f\"net_par: {p_net}\")\n",
        "logging.info(f\"train_par: {p_train}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "scrolled": false,
        "pycharm": {}
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "input shape (7693, 1)\n",
            "input partition shape (2308, 1)\n",
            "output partition shape (2308, 1)\n",
            "stacked Y shape  (2179, 3)\n",
            "Y_tensor torch.Size([2179, 3])\n",
            "X_tensor torch.Size([128, 2179, 1])\n"
          ]
        }
      ],
      "source": [
        "test_ts_ds \u003d TimeSeriesDataset(config\u003dconfig,\n",
        "                               partition\u003d(1 - p_data[\u0027test_size\u0027], 1),                        \n",
        "                               logging\u003dlogging)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "scrolled": false,
        "pycharm": {}
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "input shape (7693, 1)\n",
            "input partition shape (5385, 1)\n",
            "output partition shape (5385, 1)\n",
            "stacked Y shape  (5256, 3)\n",
            "Y_tensor torch.Size([5256, 3])\n",
            "X_tensor torch.Size([128, 5256, 1])\n"
          ]
        }
      ],
      "source": [
        "train_ts_ds \u003d TimeSeriesDataset(config\u003dconfig,\n",
        "                                partition\u003d(0, 1 - p_data[\u0027test_size\u0027]),\n",
        "                                logging\u003dlogging)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "pycharm": {}
      },
      "outputs": [],
      "source": [
        "train_dl \u003d DataLoader(dataset \u003d train_ts_ds,\n",
        "                      batch_sampler \u003d BatchSampler(\n",
        "                          sampler \u003d SequentialSampler(train_ts_ds), \n",
        "                          batch_size \u003d p_train[\u0027batch_size\u0027],\n",
        "                          drop_last \u003d True)\n",
        "                     )\n",
        "test_dl \u003d DataLoader(dataset \u003d test_ts_ds,\n",
        "                     batch_sampler \u003d BatchSampler(\n",
        "                     sampler \u003d SequentialSampler(test_ts_ds), \n",
        "                     batch_size \u003d p_train[\u0027batch_size\u0027], \n",
        "                     drop_last \u003d True)\n",
        "                    )"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "pycharm": {}
      },
      "outputs": [],
      "source": [
        "## Inspecting data we have"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "pycharm": {}
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "41"
            ]
          },
          "execution_count": 20,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "len(train_dl)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "scrolled": false,
        "pycharm": {}
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "x :torch.Size([128, 128, 1])\n",
            "y: torch.Size([128, 3])\n",
            "y_last: (128,)\n"
          ]
        },
        {
          "data": {
            "image/png": "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\u003d\n",
            "text/plain": [
              "\u003cFigure size 1440x504 with 1 Axes\u003e"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "x :torch.Size([128, 128, 1])\n",
            "y: torch.Size([128, 3])\n",
            "y_last: (128,)\n"
          ]
        },
        {
          "data": {
            "image/png": "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\u003d\n",
            "text/plain": [
              "\u003cFigure size 1440x504 with 1 Axes\u003e"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "f, t \u003d 0, 150\n",
        "for i, batch in enumerate(train_dl):\n",
        "    x, y, ind \u003d batch\n",
        "    print(f\"x :{x.shape}\")\n",
        "    print(f\"y: {y.shape}\")\n",
        "    y_kth \u003d y.detach().numpy()[f:t, 0]\n",
        "    print(f\"y_last: {y_kth.shape}\")\n",
        "    x \u003d x.transpose(0,1)\n",
        "    plt.plot(x.detach().numpy()[-1][f:t])\n",
        "    plt.plot(x.detach().numpy()[-2][f:t])\n",
        "    plt.plot(y_kth)\n",
        "    plt.show()\n",
        "    if i \u003d\u003d 1:\n",
        "        break"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "pycharm": {}
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "pycharm": {}
      },
      "outputs": [],
      "source": [
        "model \u003d LSTM(lstm_input_size,\n",
        "             p_net[\u0027hidden_size\u0027],\n",
        "             batch_size\u003dp_train[\u0027batch_size\u0027],\n",
        "             output_dim\u003dp_net[\u0027output_dim\u0027],\n",
        "             num_layers\u003dp_net[\u0027num_layers\u0027])\n",
        "\n",
        "loss_fn \u003d myLoss\n",
        "\n",
        "# if p_train[\u0027loss_fn\u0027] \u003d\u003d \u0027mse\u0027:  \n",
        "#     loss_fn \u003d torch.nn.MSELoss(reduction\u003dp_train[\u0027reduction\u0027])\n",
        "# elif p_train[\u0027loss_fn\u0027] \u003d\u003d \u0027l1\u0027:  \n",
        "#     loss_fn \u003d torch.nn.L1Loss(reduction\u003dp_train[\u0027reduction\u0027])\n",
        "\n",
        "if p_train[\u0027optimizer\u0027] \u003d\u003d \"adam\":\n",
        "    optimiser \u003d torch.optim.Adam(model.parameters(), lr\u003dp_train[\u0027learning_rate\u0027])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "pycharm": {}
      },
      "outputs": [],
      "source": [
        "logging.info(f\"Model n params: {model.get_num_params()}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "pycharm": {}
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "1267.0"
            ]
          },
          "execution_count": 24,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "model.get_num_params()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "pycharm": {}
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "pycharm": {}
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "pycharm": {}
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "41"
            ]
          },
          "execution_count": 25,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "len(train_dl)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "metadata": {
        "pycharm": {}
      },
      "outputs": [],
      "source": [
        "num_epochs \u003d p_train[\u0027num_epochs\u0027]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {
        "pycharm": {}
      },
      "outputs": [],
      "source": [
        "logging.info(\"Training process START\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "scrolled": false,
        "pycharm": {
          "is_executing": false
        }
      },
      "outputs": [
        {
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m\u003cipython-input-3-1bbc5fe12994\u003e\u001b[0m in \u001b[0;36m\u003cmodule\u003e\u001b[0;34m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;31m#####################\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----\u003e 5\u001b[0;31m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhidden\u001b[0m \u001b[0;34m\u003d\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minit_hidden\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m hist \u003d {\"train_loss\":np.zeros(num_epochs), \n\u001b[1;32m      7\u001b[0m         \u001b[0;34m\"train_local_loss\"\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzeros\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain_dl\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mNameError\u001b[0m: name \u0027model\u0027 is not defined"
          ],
          "ename": "NameError",
          "evalue": "name \u0027model\u0027 is not defined",
          "output_type": "error"
        }
      ],
      "source": [
        "#####################\n",
        "# Train model\n",
        "#####################\n",
        "\n",
        "model.hidden \u003d model.init_hidden()\n",
        "hist \u003d {\"train_loss\":np.zeros(num_epochs), \n",
        "        \"train_local_loss\":np.zeros(len(train_dl)),\n",
        "        \"eval_train_local\":np.zeros(len(train_dl)),\n",
        "         \"eval_test_local\":np.zeros(len(test_dl)),\n",
        "        \"eval_train\":np.zeros(num_epochs),\n",
        "         \"eval_test\":np.zeros(num_epochs),\n",
        "        \n",
        "        \"aux\":{\n",
        "            \"train_loss\":np.zeros(num_epochs), \n",
        "        \"train_local_loss\":np.zeros(len(train_dl)),\n",
        "        \"eval_train_local\":np.zeros(len(train_dl)),\n",
        "         \"eval_test_local\":np.zeros(len(test_dl)),\n",
        "        \"eval_train\":np.zeros(num_epochs),\n",
        "         \"eval_test\":np.zeros(num_epochs),\n",
        "        }\n",
        "        \n",
        "       }\n",
        "\n",
        "for t in range(num_epochs):\n",
        "    \n",
        "    for i, data in enumerate(tqdm(train_dl)):\n",
        "        x_batch, y_batch, indexes \u003d data\n",
        "        x_batch.transpose_(0, 1)\n",
        "    # Initialise hidden state\n",
        "    # Don\u0027t do this if you want your LSTM to be stateful\n",
        "    #model.hidden \u003d model.init_hidden()\n",
        "    \n",
        "    # Forward pass\n",
        "        y_pred \u003d model(x_batch)\n",
        "        loss \u003d loss_fn(y_pred, y_batch, x_batch, config)\n",
        "#         print(loss.shape)\n",
        "        hist[\u0027train_local_loss\u0027][i] \u003d loss.item()\n",
        "        hist[\u0027aux\u0027][\u0027train_local_loss\u0027][i] \u003d torch.mean(torch.abs(y_pred[:, 1] - a))\n",
        "        # Zero out gradient, else they will accumulate between epochs\n",
        "        optimiser.zero_grad()\n",
        "\n",
        "        # Backward pass\n",
        "        loss.backward()\n",
        "\n",
        "        # Update parameters\n",
        "        optimiser.step()\n",
        "    \n",
        "#     print(y_pred.shape)\n",
        "    print(f\"aux preds: {torch.mean(y_pred[:, 1])} {torch.mean(y_pred[:, 2])}\")\n",
        "    plot_shared_scale([\n",
        "        (y_pred.detach().numpy(),\"Preds\" ),\n",
        "#          (y_batch.detach().numpy(), \"Data\"),\n",
        "#          (x_batch[-1].detach().numpy(), \"Input\")\n",
        "        ])\n",
        "#     plot_shared_scale([\n",
        "#         (y_pred.detach().numpy(),\"Preds\" ),\n",
        "#          (y_batch.detach().numpy(), \"Data\"),\n",
        "#          (x_batch[-1].detach().numpy(), \"Input\")\n",
        "#         ])\n",
        "    plot_shared_scale([\n",
        "#         (y_pred.detach().numpy(),\"Preds\" ),\n",
        "         (y_batch.detach().numpy(), \"Data\"),\n",
        "         (x_batch[-1].detach().numpy(), \"Input\")\n",
        "        ])\n",
        "    residuals \u003d y_batch-y_pred\n",
        "    plot_multiscale([(residuals.detach().numpy(), \"Red\"),\n",
        "                          (y_batch.detach().numpy(), \"Green\")]) \n",
        "    \n",
        "\n",
        "        # validate during evaluation\n",
        "    with torch.no_grad():\n",
        "        model \u003d model.eval()\n",
        "        for i, data in enumerate(tqdm(train_dl)):\n",
        "            x_batch, y_batch, indexes \u003d data\n",
        "            x_batch.transpose_(0, 1)\n",
        "            y_pred \u003d model(x_batch)\n",
        "            loss \u003d loss_fn(y_pred, y_batch, x_batch, config)\n",
        "            hist[\u0027eval_train_local\u0027][i] \u003d loss.item()\n",
        "            hist[\u0027aux\u0027][\u0027eval_train_local\u0027][i] \u003d torch.mean(torch.abs(y_pred[:, 1] - a) )\n",
        "        for i, data in enumerate(tqdm(test_dl)):\n",
        "            x_batch_test, y_batch_test, indexes \u003d data\n",
        "            x_batch_test.transpose_(0, 1)\n",
        "            y_pred_test \u003d model(x_batch_test)\n",
        "            loss \u003d loss_fn(y_pred_test, y_batch_test, x_batch_test, config)\n",
        "            hist[\u0027eval_test_local\u0027][i] \u003d loss.item()\n",
        "            hist[\u0027aux\u0027][\u0027eval_test_local\u0027][i] \u003d torch.mean(torch.abs(y_pred_test[:, 1] - a) )\n",
        "        model \u003d model.train()\n",
        "\n",
        "        \n",
        "#     smoothed_train \u003d []\n",
        "#     smoothed_test \u003d []\n",
        "#     k_smooth \u003d 1\n",
        "#     for elm in range(hist[\u0027eval_train_local\u0027][:-k_smooth].shape[0]):\n",
        "#         smoothed_train.append(np.average(hist[\u0027eval_train_local\u0027][elm:elm+k_smooth]))\n",
        "#     for elm in range(hist[\u0027eval_test_local\u0027][:-k_smooth].shape[0]):\n",
        "#         smoothed_test.append(np.average(hist[\u0027eval_test_local\u0027][elm:elm+k_smooth])) \n",
        "    \n",
        "#     plot_shared_scale([\n",
        "#             (smoothed_train,\"Train\" ),\n",
        "#              (smoothed_test, \"Test\")])        \n",
        "    \n",
        "    plot_shared_scale([\n",
        "            (y_pred_test[:, 1].detach().numpy(),\"Preds\" ),\n",
        "        \n",
        "            (y_pred_test[:, 2].detach().numpy(),\"Preds\" ),\n",
        "#              (y_batch_test.detach().numpy(), \"Data\"),\n",
        "#              (x_batch_test[-1].detach().numpy(), \"Input\")\n",
        "    ])\n",
        "    \n",
        "    plot_shared_scale([\n",
        "            (y_pred_test[:, 0].detach().numpy(),\"Preds\" ),\n",
        "             (y_batch_test.detach().numpy(), \"Data\"),\n",
        "#              (x_batch_test[-1].detach().numpy(), \"Input\")\n",
        "    ])\n",
        "    \n",
        "#     plot_shared_scale([\n",
        "#             (y_pred_test.detach().numpy(),\"Preds\" ),\n",
        "#              (y_batch_test.detach().numpy(), \"Data\"),\n",
        "#              (x_batch_test[-1].detach().numpy(), \"Input\")\n",
        "#     ])\n",
        "\n",
        "    residuals \u003d y_batch_test - y_pred_test\n",
        "    plot_multiscale(\n",
        "            [(residuals.detach().numpy(), \"Red\"), \n",
        "             (y_batch_test.detach().numpy(),\"Green\")\n",
        "            ])\n",
        "#     plot_shared_scale( [ (hist[\"eval_train_local\"], \"train\"),\n",
        "#                         (hist[\"eval_test_local\"], \"test\")])\n",
        "    logging.info(f\"Epoch [{t}] \\\n",
        "    \\n train_loss[{hist[\u0027train_loss\u0027][t]}] \\\n",
        "    \\n eval_traiDn[{hist[\u0027eval_train\u0027][t]}] \\\n",
        "    \\n eval_test[{hist[\u0027eval_test\u0027][t]}] \")\n",
        "                 \n",
        "    hist[\"train_loss\"][t] \u003d np.average(hist[\"train_local_loss\"])\n",
        "    hist[\"eval_train\"][t] \u003d np.average(hist[\"eval_train_local\"])\n",
        "    hist[\"eval_test\"][t] \u003d np.average(hist[\"eval_test_local\"])\n",
        "    hist[\u0027aux\u0027][\u0027eval_test\u0027][t] \u003d np.average(hist[\u0027aux\u0027][\u0027eval_test_local\u0027])\n",
        "    hist[\u0027aux\u0027][\u0027eval_train\u0027][t] \u003d np.average(hist[\u0027aux\u0027][\u0027eval_train_local\u0027])\n",
        "    hist[\u0027aux\u0027][\u0027train_loss\u0027][t] \u003d np.average(hist[\u0027aux\u0027][\u0027train_local_loss\u0027])\n",
        "                 \n",
        "#     hist[\"aux_error\"][t] \u003d np.average[]\n",
        "    print(f\" Epoch [{t}] \\\n",
        "    \\n train_loss[{hist[\u0027train_loss\u0027][t]}] \\\n",
        "    \\n eval_train[{hist[\u0027eval_train\u0027][t]}] \\\n",
        "    \\n eval_test[{hist[\u0027eval_test\u0027][t]}] \")\n",
        "    logging.info(f\" Epoch [{t}] \\\n",
        "    \\n train_loss[{hist[\u0027train_loss\u0027][t]}] \\\n",
        "    \\n eval_train[{hist[\u0027eval_train\u0027][t]}] \\\n",
        "    \\n eval_test[{hist[\u0027eval_test\u0027][t]}] \")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "pycharm": {}
      },
      "outputs": [],
      "source": [
        "s, e \u003d 0, -1\n",
        "plot_shared_scale([\n",
        "    (hist[\u0027train_loss\u0027][s:e],\"Train\" ),\n",
        "             (hist[\u0027eval_train\u0027][s:e], \"Eval_train\"),\n",
        "             (hist[\u0027eval_test\u0027][s:e], \"Eval_test\"),\n",
        "                  (hist[\u0027aux\u0027][\u0027train_loss\u0027][s:e], \"aux_train\"),\n",
        "                  (hist[\u0027aux\u0027][\u0027eval_train\u0027][s:e], \"aux_Eval_train\"),\n",
        "                  (hist[\u0027aux\u0027][\u0027eval_test\u0027][s:e], \"aux_Eval_test\")\n",
        "])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "pycharm": {}
      },
      "outputs": [],
      "source": [
        "s, e \u003d 0, -1\n",
        "plot_shared_scale([\n",
        "    (hist[\u0027train_loss\u0027][s:e],\"Train\" ),\n",
        "             (hist[\u0027eval_train\u0027][s:e], \"Eval_train\"),\n",
        "             (hist[\u0027eval_test\u0027][s:e], \"Eval_test\"),\n",
        "#                   (hist[\u0027aux\u0027][\u0027train_loss\u0027][s:e], \"aux_train\"),\n",
        "#                   (hist[\u0027aux\u0027][\u0027eval_train\u0027][s:e], \"aux_Eval_train\"),\n",
        "#                   (hist[\u0027aux\u0027][\u0027eval_test\u0027][s:e], \"aux_Eval_test\")\n",
        "])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "scrolled": true,
        "pycharm": {}
      },
      "outputs": [],
      "source": [
        "s, e \u003d 0, -1\n",
        "plot_shared_scale([\n",
        "#     (hist[\u0027train_loss\u0027][s:e],\"Train\" ),\n",
        "#              (hist[\u0027eval_train\u0027][s:e], \"Eval_train\"),\n",
        "#              (hist[\u0027eval_test\u0027][s:e], \"Eval_test\"),\n",
        "                  (hist[\u0027aux\u0027][\u0027train_loss\u0027][s:e], \"aux_train\"),\n",
        "                  (hist[\u0027aux\u0027][\u0027eval_train\u0027][s:e], \"aux_Eval_train\"),\n",
        "                  (hist[\u0027aux\u0027][\u0027eval_test\u0027][s:e], \"aux_Eval_test\")])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "pycharm": {}
      },
      "outputs": [],
      "source": [
        "model.buffers"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "pycharm": {}
      },
      "outputs": [],
      "source": [
        "logging.info(\"Training process END\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "pycharm": {}
      },
      "outputs": [],
      "source": [
        "#"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "pycharm": {}
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "pycharm": {}
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "pycharm": {}
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "pycharm": {}
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "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.7.3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}