main.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "\n",
    "# # check if CUDA is available\n",
    "# train_on_gpu = torch.cuda.is_available()\n",
    "\n",
    "# if not train_on_gpu:\n",
    "#     print('CUDA is not available.  Training on CPU ...')\n",
    "# else:\n",
    "#     print('CUDA is available!  Training on GPU ...')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "DEVICE = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# IMPORTS\n",
    "\n",
    "# Files\n",
    "import data_preprocess\n",
    "import network as net\n",
    "\n",
    "# Torch Features\n",
    "from torch import nn\n",
    "from torch import optim\n",
    "import torch.nn.functional as F\n",
    "\n",
    "# Calc Utilities\n",
    "import numpy as np\n",
    "from collections import OrderedDict\n",
    "\n",
    "# Plot Utilities\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "# Miscellaneous\n",
    "import time\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_model(model, n_epochs=80, checkpoint_path = False):\n",
    "    \n",
    "    # Start epoch variable\n",
    "    start_epoch = 0\n",
    "    \n",
    "    # Track change in validation loss\n",
    "    valid_loss_min = np.Inf \n",
    "    \n",
    "    # Define the Loss\n",
    "    criterion = nn.NLLLoss()\n",
    "\n",
    "    # Only train the classifier parameters, feature parameters are frozen\n",
    "    optimizer = optim.Adadelta(model.parameters())\n",
    "    \n",
    "    #Check if there is an old run\n",
    "    if checkpoint_path:\n",
    "      cfile = torch.load(checkpoint_path)\n",
    "      start_epoch = cfile['epochs']\n",
    "      optimizer.load_state_dict(cfile['optim'])\n",
    "\n",
    "    \n",
    "    for epoch in range(1, n_epochs + 1):\n",
    "        start_time = time.time()\n",
    "      \n",
    "        # Move model to GPU if CUDA is available\n",
    "#         if train_on_gpu:\n",
    "#             model.cuda()\n",
    "\n",
    "        # keep track of training and validation loss\n",
    "        train_loss = 0.0\n",
    "        valid_loss = 0.0\n",
    "\n",
    "        ###################\n",
    "        # train the model #\n",
    "        ###################\n",
    "        model.train()\n",
    "        for data, target in train_loader:\n",
    "            # move tensors to GPU if CUDA is available\n",
    "            data, target = data.to(DEVICE).float(), target.to(DEVICE).long()\n",
    "#             if train_on_gpu:\n",
    "#                 data, target = data.cuda().float(), target.cuda().long()\n",
    "            # flatten the data\n",
    "            data = data.view(-1, 9, 1, 128)\n",
    "            # clear the gradients of all optimized variables\n",
    "            optimizer.zero_grad()\n",
    "            # forward pass: compute predicted outputs by passing inputs to the model\n",
    "            output = model(data)\n",
    "            # calculate the batch loss\n",
    "            loss = criterion(output, target)\n",
    "            # backward pass: compute gradient of the loss with respect to model parameters\n",
    "            loss.backward()\n",
    "            # perform a single optimization step (parameter update)\n",
    "            optimizer.step()\n",
    "            # update training loss\n",
    "            train_loss += loss.item()\n",
    "\n",
    "        ######################    \n",
    "        # validate the model #\n",
    "        ######################\n",
    "        correct = 0\n",
    "        total = 0\n",
    "        model.eval()\n",
    "        for data, target in valid_loader:\n",
    "            # move tensors to GPU if CUDA is available\n",
    "            data, target = data.to(DEVICE).float(), target.to(DEVICE).long()\n",
    "#             if train_on_gpu:\n",
    "#                 data, target = data.cuda().float(), target.cuda().long()\n",
    "            # flatten the data\n",
    "            data = data.view(-1, 9, 1, 128)\n",
    "            # forward pass: compute predicted outputs by passing inputs to the model\n",
    "            output = model(data)\n",
    "            # calculate the batch loss\n",
    "            loss = criterion(output, target)\n",
    "            # update average validation loss \n",
    "            valid_loss += loss.item()\n",
    "            \n",
    "            #calculate accuracy\n",
    "            _, predicted = torch.max(output.data, 1)\n",
    "            total += target.size(0)\n",
    "            correct += (predicted == target).sum()\n",
    "\n",
    "        # calculate average losses\n",
    "        train_loss = train_loss/len(train_loader.dataset)\n",
    "        valid_loss = valid_loss/len(valid_loader.dataset)\n",
    "        acc_valid = float(correct) * 100.0 / (len(train_loader.dataset))\n",
    "        duration = (time.time() - start_time)/60       \n",
    "\n",
    "\n",
    "        # print training/validation statistics \n",
    "        print('Epoch: {} \\tTraining Loss: {:.6f} \\tValidation Loss: {:.6f} \\tValidation Acc.: {:.2f} \\tDuration: {:.2f} min.'.format(\n",
    "            start_epoch + epoch, train_loss, valid_loss,acc_valid,duration))\n",
    "\n",
    "        # save model if validation loss has decreased\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(7352, 1152)\n",
      "(7352, 128, 9)\n",
      "(2947, 1152)\n",
      "(2947, 128, 9)\n",
      "Epoch: 1 \tTraining Loss: -0.019836 \tValidation Loss: -0.006421 \tValidation Acc.: 12.74 \tDuration: 0.14 min.\n",
      "Epoch: 2 \tTraining Loss: -0.025697 \tValidation Loss: -0.006444 \tValidation Acc.: 12.80 \tDuration: 0.14 min.\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-18-6528af06b8ff>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     10\u001b[0m     \u001b[0mmodel\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnet\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mNetwork\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mDEVICE\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m     \u001b[0;31m# Train the Model\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 12\u001b[0;31m     \u001b[0mtrain_model\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn_epochs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcheckpoint_path\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-17-795d98389364>\u001b[0m in \u001b[0;36mtrain_model\u001b[0;34m(model, n_epochs, checkpoint_path)\u001b[0m\n\u001b[1;32m     53\u001b[0m             \u001b[0moptimizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     54\u001b[0m             \u001b[0;31m# update training loss\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m             \u001b[0mtrain_loss\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0mloss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitem\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     56\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     57\u001b[0m         \u001b[0;31m######################\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "if __name__ == '__main__':\n",
    "    # how many samples per batch to load\n",
    "    batch_size = 20\n",
    "    # number of epochs\n",
    "    n_epochs = 80 \n",
    "    \n",
    "    # Load data\n",
    "    train_loader, valid_loader, test_loader = data_preprocess.load(batch_size=batch_size)\n",
    "    # Define the Model\n",
    "    model = net.Network().to(DEVICE)\n",
    "    # Train the Model\n",
    "    train_model(model, n_epochs, checkpoint_path = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}