pytorch_training.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#    Copyright 2020 Arkadip Bhattacharya\n",
    "\n",
    "#    Licensed under the Apache License, Version 2.0 (the \"License\");\n",
    "#    you may not use this file except in compliance with the License.\n",
    "#    You may obtain a copy of the License at\n",
    "\n",
    "#        http://www.apache.org/licenses/LICENSE-2.0\n",
    "\n",
    "#    Unless required by applicable law or agreed to in writing, software\n",
    "#    distributed under the License is distributed on an \"AS IS\" BASIS,\n",
    "#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
    "#    See the License for the specific language governing permissions and\n",
    "#    limitations under the License."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Wind speed Prediction\n",
    "\n",
    "This notebook contains all necessary codes to Train a `Deep Learning Model` and Validate it.\n",
    "\n",
    "The Model is based on `Pytorch`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Importing all the necessary Libraries along with some self-made functions\n",
    "\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "import os\n",
    "import torch\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from torch.utils.data import dataloader\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "from preprocessing import WindSpeedTimeSeriesDataset, ComposeTransform, ToTensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<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>time</th>\n",
       "      <th>air_temperature_mean</th>\n",
       "      <th>pressure</th>\n",
       "      <th>wind_direction</th>\n",
       "      <th>wind_speed</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>2010-01-01 00:00:00</td>\n",
       "      <td>-1.8</td>\n",
       "      <td>997.0</td>\n",
       "      <td>59</td>\n",
       "      <td>3.8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>2010-01-01 01:00:00</td>\n",
       "      <td>-2.1</td>\n",
       "      <td>996.0</td>\n",
       "      <td>58</td>\n",
       "      <td>3.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>2010-01-01 02:00:00</td>\n",
       "      <td>-2.1</td>\n",
       "      <td>996.0</td>\n",
       "      <td>49</td>\n",
       "      <td>3.7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>2010-01-01 03:00:00</td>\n",
       "      <td>-2.2</td>\n",
       "      <td>996.0</td>\n",
       "      <td>49</td>\n",
       "      <td>3.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>2010-01-01 04:00:00</td>\n",
       "      <td>-2.2</td>\n",
       "      <td>996.0</td>\n",
       "      <td>49</td>\n",
       "      <td>3.5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                  time  air_temperature_mean  pressure  wind_direction  \\\n",
       "0  2010-01-01 00:00:00                  -1.8     997.0              59   \n",
       "1  2010-01-01 01:00:00                  -2.1     996.0              58   \n",
       "2  2010-01-01 02:00:00                  -2.1     996.0              49   \n",
       "3  2010-01-01 03:00:00                  -2.2     996.0              49   \n",
       "4  2010-01-01 04:00:00                  -2.2     996.0              49   \n",
       "\n",
       "   wind_speed  \n",
       "0         3.8  \n",
       "1         3.5  \n",
       "2         3.7  \n",
       "3         3.5  \n",
       "4         3.5  "
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Reading the Dataset\n",
    "\n",
    "dataset = pd.read_csv('./dataset-hourly.csv')\n",
    "dataset.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<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>time</th>\n",
       "      <th>air_temperature_mean</th>\n",
       "      <th>pressure</th>\n",
       "      <th>wind_direction</th>\n",
       "      <th>wind_speed</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>2010-01-01 00:00:00</td>\n",
       "      <td>0.260788</td>\n",
       "      <td>0.407895</td>\n",
       "      <td>0.163889</td>\n",
       "      <td>0.333333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>2010-01-01 01:00:00</td>\n",
       "      <td>0.255159</td>\n",
       "      <td>0.394737</td>\n",
       "      <td>0.161111</td>\n",
       "      <td>0.307018</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>2010-01-01 02:00:00</td>\n",
       "      <td>0.255159</td>\n",
       "      <td>0.394737</td>\n",
       "      <td>0.136111</td>\n",
       "      <td>0.324561</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>2010-01-01 03:00:00</td>\n",
       "      <td>0.253283</td>\n",
       "      <td>0.394737</td>\n",
       "      <td>0.136111</td>\n",
       "      <td>0.307018</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>2010-01-01 04:00:00</td>\n",
       "      <td>0.253283</td>\n",
       "      <td>0.394737</td>\n",
       "      <td>0.136111</td>\n",
       "      <td>0.307018</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                  time  air_temperature_mean  pressure  wind_direction  \\\n",
       "0  2010-01-01 00:00:00              0.260788  0.407895        0.163889   \n",
       "1  2010-01-01 01:00:00              0.255159  0.394737        0.161111   \n",
       "2  2010-01-01 02:00:00              0.255159  0.394737        0.136111   \n",
       "3  2010-01-01 03:00:00              0.253283  0.394737        0.136111   \n",
       "4  2010-01-01 04:00:00              0.253283  0.394737        0.136111   \n",
       "\n",
       "   wind_speed  \n",
       "0    0.333333  \n",
       "1    0.307018  \n",
       "2    0.324561  \n",
       "3    0.307018  \n",
       "4    0.307018  "
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Normalizing te data using the MinMaxScaler of sklearn\n",
    "\n",
    "scaler = MinMaxScaler()\n",
    "dataset[['air_temperature_mean',\n",
    "         'pressure',\n",
    "         'wind_direction',\n",
    "         'wind_speed']] = scaler.fit_transform(dataset[['air_temperature_mean',\n",
    "                                                        'pressure', \n",
    "                                                        'wind_direction', \n",
    "                                                        'wind_speed']])\n",
    "dataset.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Spliting the Dataset into Train Set, Test Set and Validation Set\n",
    "\n",
    "trainset, testset = train_test_split(dataset, test_size = 0.1)\n",
    "trainset, valset = train_test_split(trainset, test_size = 0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "time                    2011-12-18 13:00:00\n",
       "air_temperature_mean               0.363977\n",
       "pressure                           0.473684\n",
       "wind_direction                     0.697222\n",
       "wind_speed                          0.54386\n",
       "Name: 17197, dtype: object"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# A Example Training Attributes\n",
    "\n",
    "trainset.iloc[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating the Time Series dataset Generators with window_size=6\n",
    "# Using the ComposeTranform to Tranform each Time Series matrics into a Torch.Tensor\n",
    "\n",
    "train_dataset = WindSpeedTimeSeriesDataset(trainset, window_size=6, transform=ComposeTransform([ToTensor()]))\n",
    "test_dataset = WindSpeedTimeSeriesDataset(testset, window_size=6, transform=ComposeTransform([ToTensor()]))\n",
    "val_dataset = WindSpeedTimeSeriesDataset(valset, window_size=6, transform=ComposeTransform([ToTensor()]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train[0]: tensor([[0.3640, 0.4737, 0.6972, 0.5439],\n",
      "        [0.6867, 0.7237, 0.8889, 0.3947],\n",
      "        [0.3077, 0.6184, 0.0528, 0.3421],\n",
      "        [0.7111, 0.6447, 0.7722, 0.3158],\n",
      "        [0.6848, 0.6184, 0.9361, 0.2456],\n",
      "        [0.4409, 0.7105, 0.7750, 0.3509]], dtype=torch.float64) \n",
      "\n",
      "Test[0]: tensor([0.3070], dtype=torch.float64)\n"
     ]
    }
   ],
   "source": [
    "# The first Time Series features matix\n",
    "# Each row corresponding to a different times\n",
    "# Each variables in a time signifies a feature\n",
    "\n",
    "print('Train[0]:',train_dataset[0][0],'\\n\\nTest[0]:',train_dataset[0][1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train[1]: tensor([[0.6867, 0.7237, 0.8889, 0.3947],\n",
      "        [0.3077, 0.6184, 0.0528, 0.3421],\n",
      "        [0.7111, 0.6447, 0.7722, 0.3158],\n",
      "        [0.6848, 0.6184, 0.9361, 0.2456],\n",
      "        [0.4409, 0.7105, 0.7750, 0.3509],\n",
      "        [0.2495, 0.8816, 0.5111, 0.3070]], dtype=torch.float64) \n",
      "\n",
      "Test[1]: tensor([0.1930], dtype=torch.float64)\n"
     ]
    }
   ],
   "source": [
    "print('Train[1]:',train_dataset[1][0],'\\n\\nTest[1]:',train_dataset[1][1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Genarating Pytorch DataLoader for the Training and Testing of the Model\n",
    "# Setting the Batch size\n",
    "\n",
    "batch_size = 64\n",
    "\n",
    "trainloader = dataloader.DataLoader(train_dataset, batch_size, shuffle = True)\n",
    "valloader = dataloader.DataLoader(val_dataset, batch_size, shuffle = False)\n",
    "testloader = dataloader.DataLoader(test_dataset, batch_size, shuffle = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Checking the Size of the Features and Label matrix\n",
    "# Features Size = (Batch_size, Time_steps, no_of_features)\n",
    "# Leabels Size = (Batch_size, Time_steps, no_of_labels)\n",
    "\n",
    "f, l = next(iter(trainloader))\n",
    "\n",
    "print(f'Features Size: {f.shape}')\n",
    "print(f'Labels Size: {l.shape}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Checking for the GPU for using Hardware Accelerations\n",
    "# Set the `cuda` and `device` variables accordingly to use the correct device\n",
    "\n",
    "cuda = torch.cuda.is_available()\n",
    "device = torch.device('cuda') if cuda else torch.device('cpu')\n",
    "if cuda:\n",
    "    print(\"Device Count:\", torch.cuda.device_count())\n",
    "    print(\"Device:\", torch.cuda.get_device_name())\n",
    "    print(\"Device Capability:\", torch.cuda.get_device_capability())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing the Model from model.py\n",
    "# Setting the Model hyperparameters and create an instance of it\n",
    "# Send the model to the appropriate device\n",
    "\n",
    "from model import Model\n",
    "model = Model(cuda=cuda)\n",
    "model.to(device)\n",
    "print(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Setting Up training criteria\n",
    "\n",
    "from torch import nn\n",
    "from torch.optim import Adam\n",
    "\n",
    "optimizer = Adam(params=model.parameters(), lr= 0.001)\n",
    "criterion = nn.SmoothL1Loss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# loading the pretrained model\n",
    "\n",
    "model_name = 'lstm-v1'\n",
    "model.load_state_dict(torch.load(os.path.join('model', model_name, 'model.pt'), map_location=device))\n",
    "optimizer.load_state_dict(torch.load(os.path.join('model', model_name, 'optim.pt'), map_location=device))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Set the Model Optimizer, Using 'Adam'\n",
    "# Set the Loss Function, Using 'SmoothL1Loss'\n",
    "# Running the training routing\n",
    "\n",
    "\n",
    "epochs = 40\n",
    "trainlosses, testlosses = model.fit(trainloader = trainloader,\n",
    "                                    validationloader = valloader,\n",
    "                                    criterion = criterion,\n",
    "                                    optimizer = optimizer,\n",
    "                                    epochs = epochs, \n",
    "                                    val_every = 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ploting the Loss stats\n",
    "%matplotlib qt\n",
    "\n",
    "plt.plot(trainlosses, label = 'Training Losses')\n",
    "plt.plot(testlosses, label = 'Testing Losses')\n",
    "plt.ylabel('Losses')\n",
    "plt.xlabel('Batch * Epoch')\n",
    "plt.legend()\n",
    "plt.title('Losses Graph')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Running the model test\n",
    "# Ruturns the result and actual arrayes\n",
    "\n",
    "result, actual = model.test(testloader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ploting the Validation Graph\n",
    "\n",
    "# Just some random checking\n",
    "%matplotlib qt\n",
    "val_from = 100\n",
    "val_to = 200\n",
    "\n",
    "plt.plot(result[val_from:val_to], label = 'Result')\n",
    "plt.plot(actual[val_from:val_to], label = 'Actual')\n",
    "plt.ylabel('Wind Speed (Normalized)')\n",
    "#plt.xticks(range(val_from, val_to))\n",
    "plt.xlabel('Time Range')\n",
    "plt.legend()\n",
    "plt.title('Model Output Validation')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Saving the Model and the summary\n",
    "model_name = '03.c-c-f-l-f--SmoothL1-ADAM'\n",
    "\n",
    "model.save_dict(model_name, save_optim=True)\n",
    "model.save_summary(model_name, testloader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}