PyTorch Concepts(Saving and Loading Models).ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Saving and Loading of Models in PyTorch\n",
    "%matplotlib inline\n",
    "%config InlineBackend.figure_format = 'retina'\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import torch\n",
    "from torch import nn\n",
    "from torch import optim\n",
    "import torch.nn.functional as F\n",
    "from torchvision import datasets, transforms\n",
    "\n",
    "import helper\n",
    "import fc_model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a transform to normalize the data\n",
    "transform = transforms.Compose([transforms.ToTensor(),\n",
    "                                transforms.Normalize((0.5,), (0.5,))])\n",
    "# Download and load the training data\n",
    "trainset = datasets.FashionMNIST('~/.pytorch/F_MNIST_data/', download=False, train=True, transform=transform)\n",
    "trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)\n",
    "\n",
    "# Download and load the test data\n",
    "testset = datasets.FashionMNIST('~/.pytorch/F_MNIST_data/', download=False, train=False, transform=transform)\n",
    "testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f07d5c80588>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f07d5d1fc18>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 250,
       "width": 253
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "image,label = next(iter(trainloader))\n",
    "plt.imshow(image[0].numpy().squeeze())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = nn.Sequential(\n",
    "                    nn.Linear(784,256),\n",
    "                    nn.ReLU(),\n",
    "                    nn.Linear(256,128),\n",
    "                    nn.ReLU(),\n",
    "                    nn.Linear(128,64),\n",
    "                    nn.ReLU(),\n",
    "                    nn.Linear(64,10),\n",
    "                    nn.LogSoftmax(dim=1)\n",
    ")\n",
    "#defining the loss\n",
    "criterion = nn.NLLLoss()\n",
    "optimizer = optim.Adam(model.parameters(),lr=0.003)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 1/5..  Training Loss: 0.517..  Test Loss: 0.454..  Test Accuracy: 0.833\n",
      "Epoch: 2/5..  Training Loss: 0.393..  Test Loss: 0.418..  Test Accuracy: 0.853\n",
      "Epoch: 3/5..  Training Loss: 0.356..  Test Loss: 0.384..  Test Accuracy: 0.863\n",
      "Epoch: 4/5..  Training Loss: 0.331..  Test Loss: 0.392..  Test Accuracy: 0.862\n",
      "Epoch: 5/5..  Training Loss: 0.317..  Test Loss: 0.390..  Test Accuracy: 0.857\n"
     ]
    }
   ],
   "source": [
    "#trainig the model\n",
    "epochs = 5\n",
    "steps = 0\n",
    "train_losses, test_losses = [], []\n",
    "for e in range(epochs):\n",
    "    running_loss = 0\n",
    "    for images,labels in trainloader:\n",
    "        optimizer.zero_grad()\n",
    "        images = images.view(images.shape[0],-1)\n",
    "        log_ps = model(images)\n",
    "        loss=criterion(log_ps,labels)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        running_loss+=loss.item()\n",
    "    else:\n",
    "        test_loss = 0\n",
    "        accuracy = 0\n",
    "        #turning off the gradients will save memory and time\n",
    "        with torch.no_grad():\n",
    "            for images,labels in testloader:\n",
    "                images = images.view(images.shape[0],-1)\n",
    "                log_ps = model(images)\n",
    "                test_loss += criterion(log_ps,labels)\n",
    "                \n",
    "                ps = torch.exp(log_ps)\n",
    "                top_p,top_class = ps.topk(1,dim=1)\n",
    "                equals = top_class == labels.view(*top_class.shape)\n",
    "                accuracy += torch.mean(equals.type(torch.FloatTensor))\n",
    "        train_losses.append(running_loss/len(trainloader))\n",
    "        test_losses.append(test_loss/len(testloader))\n",
    "\n",
    "        print(\"Epoch: {}/{}.. \".format(e+1, epochs),\n",
    "              \"Training Loss: {:.3f}.. \".format(running_loss/len(trainloader)),\n",
    "              \"Test Loss: {:.3f}.. \".format(test_loss/len(testloader)),\n",
    "              \"Test Accuracy: {:.3f}\".format(accuracy/len(testloader)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The state dict keys odict_keys(['0.weight', '0.bias', '2.weight', '2.bias', '4.weight', '4.bias', '6.weight', '6.bias'])\n"
     ]
    }
   ],
   "source": [
    "#we can use the state.dict keys \n",
    "#to save the model\n",
    "print(\"The state dict keys\",model.state_dict().keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "#we can save the state_dict torch.save\n",
    "torch.save(model.state_dict(),'checkpoint.pth')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "odict_keys(['0.weight', '0.bias', '2.weight', '2.bias', '4.weight', '4.bias', '6.weight', '6.bias'])\n"
     ]
    }
   ],
   "source": [
    "#we can load our state dict with torch.load\n",
    "state_dict_a = torch.load('checkpoint.pth')\n",
    "print(state_dict_a.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "#this thing only works if the model architucture is same as the one in the state_dict\n",
    "model.load_state_dict(state_dict_a)\n",
    "hidden_layers=[]\n",
    "for each in model:\n",
    "    #print(each)\n",
    "    try:\n",
    "        a=each.out_features\n",
    "        hidden_layers.append(a)\n",
    "    except:\n",
    "        #print(\"--------------------\")\n",
    "        b = 1+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "#so it is useful to save the info of model ie architucture in the state dict too\n",
    "checkpoint = {\n",
    "    'input_size':784,\n",
    "    'output_size':10,\n",
    "    'hidden_layers':hidden_layers,\n",
    "    'state_dict':model.state_dict()\n",
    "}\n",
    "torch.save(checkpoint,'checkpoint_a.pth')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_checkpoint(filepath):\n",
    "    checkpoint = torch.load(filepath)\n",
    "    model = fc_model.Network(checkpoint['input_size'],\n",
    "                             checkpoint['output_size'],\n",
    "                             checkpoint['hidden_layers'])\n",
    "    model.load_state_dict(checkpoint['state_dict'])\n",
    "    \n",
    "    return model"
   ]
  },
  {
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}