fundamentals_DL_PyTorch_save_load_model.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PyTorch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importar librerías"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# PyTorch \n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importar imágenes "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from get_images import get_images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# MNIST path\n",
    "mnist_path = './mnist_raw/'\n",
    "x_train_num, y_train_num, x_test_num, y_test_num = get_images(mnist_path)\n",
    "\n",
    "x_train = x_train_num[:50000].reshape(50000, -1).astype(np.float32)\n",
    "y_train = y_train_num[:50000].reshape(50000, 1)\n",
    "\n",
    "x_val = x_train_num[50000:].reshape(10000, -1).astype(np.float)\n",
    "y_val = y_train_num[50000:].reshape(10000, 1)\n",
    "\n",
    "x_test = x_test_num.copy().reshape(10000, -1).astype(np.float)\n",
    "y_test = y_test_num.copy().reshape(10000, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Normalizar imágenes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def normalise(x_mean, x_std, x_data):\n",
    "    return (x_data - x_mean) / x_std"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_mean = x_train.mean()\n",
    "x_std = x_train.std()\n",
    "\n",
    "x_train = normalise(x_mean, x_std, x_train)\n",
    "x_val = normalise(x_mean, x_std, x_val)\n",
    "x_test = normalise(x_mean, x_std, x_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-3.1638146e-07, 0.99999934)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_train.mean(), x_train.std()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mostrar imágenes "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10000, 784)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(50000, 1)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_number(image):\n",
    "    plt.figure(figsize=(5,5))\n",
    "    plt.imshow(image.squeeze(), cmap=plt.get_cmap('gray'))\n",
    "    plt.axis('off')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La imagen muestreada representa un: 4\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "rnd_idx = np.random.randint(len(y_test))\n",
    "print(f'La imagen muestreada representa un: {y_test[rnd_idx, 0]}')\n",
    "plot_number(x_test_num[rnd_idx])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Crear minibatches "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_minibatches(x, y, mb_size, shuffle = True):\n",
    "    '''\n",
    "    x  #muestras, 784\n",
    "    y #muestras, 1\n",
    "    '''\n",
    "    assert x.shape[0] == y.shape[0], 'Error en cantidad de muestras'\n",
    "    total_data = x.shape[0]\n",
    "    if shuffle: \n",
    "        idxs = np.arange(total_data)\n",
    "        np.random.shuffle(idxs)\n",
    "        x = x[idxs]\n",
    "        y = y[idxs]  \n",
    "    return ((x[i:i+mb_size], y[i:i+mb_size]) for i in range(0, total_data, mb_size))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ahora sí! PyTorch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Convertir Numpy array a PyTorch "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train_tensor = torch.tensor(x_train.copy())\n",
    "y_train_tensor = torch.tensor(y_train.copy())\n",
    "\n",
    "x_val_tensor = torch.tensor(x_val.copy())\n",
    "y_val_tensor = torch.tensor(y_val.copy())\n",
    "\n",
    "x_test_tensor = torch.tensor(x_test.copy())\n",
    "y_test_tensor = torch.tensor(y_test.copy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Usar GPU de estar disponible"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estammos usando: cuda\n"
     ]
    }
   ],
   "source": [
    "if torch.cuda.is_available():\n",
    "    device = torch.device('cuda')\n",
    "else:\n",
    "    device = torch.device('cpu')\n",
    "print(f'Estammos usando: {device}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compute accuracy "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def accuracy(model, x, y, mb_size):\n",
    "    num_correct = 0\n",
    "    num_total = 0\n",
    "    model.eval()\n",
    "    model = model.to(device=device)\n",
    "    with torch.no_grad():\n",
    "        for (xi, yi) in create_minibatches(x, y, mb_size):\n",
    "            xi = xi.to(device=device, dtype = torch.float32)\n",
    "            yi = yi.to(device=device, dtype = torch.long)\n",
    "            scores = model(xi) # mb_size, 10\n",
    "            _, pred = scores.max(dim=1) #pred shape (mb_size )\n",
    "            num_correct += (pred == yi.squeeze()).sum() # pred shape (mb_size), yi shape (mb_size, 1)\n",
    "            num_total += pred.size(0)\n",
    "\n",
    "            return float(num_correct)/num_total     \n",
    "            "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loop de entrenamiento"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(model, optimiser, mb_size, epochs=100):\n",
    "    model = model.to(device=device)\n",
    "    for epoch in range(epochs):\n",
    "        for (xi, yi) in create_minibatches(x_train_tensor, y_train_tensor, mb_size):\n",
    "            model.train()\n",
    "            xi = xi.to(device=device, dtype=torch.float32)\n",
    "            yi = yi.to(device=device, dtype=torch.long)\n",
    "            scores = model(xi)\n",
    "            # funcion cost\n",
    "            cost = F.cross_entropy(input= scores, target=yi.squeeze())\n",
    "            optimiser.zero_grad()\n",
    "            cost.backward()\n",
    "            optimiser.step()\n",
    "        if epoch%20 == 0:    \n",
    "            print(f'Epoch: {epoch}, costo: {cost.item()}, accuracy: {accuracy(model, x_val_tensor, y_val_tensor, mb_size)}')\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modelo usando Sequential"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0, costo: 0.9611910581588745, accuracy: 0.669189453125\n",
      "Epoch: 20, costo: 0.10150480270385742, accuracy: 0.974853515625\n",
      "Epoch: 40, costo: 0.04186346009373665, accuracy: 0.979736328125\n",
      "Epoch: 60, costo: 0.019792571663856506, accuracy: 0.979736328125\n",
      "Epoch: 80, costo: 0.012831888161599636, accuracy: 0.981689453125\n",
      "con lr: 0.338 accuracy:0.982177734375\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Instanciar modelo\n",
    "hidden1 = 1000 \n",
    "hidden = 1000\n",
    "epochs = 100\n",
    "mb_size = 4096\n",
    "# models = {}\n",
    "# buscar en intervalo [0.001, 1]\n",
    "# for i in range(5):\n",
    "#     j = -3*np.random.rand() # [0, 1]\n",
    "#     lr = 10**j\n",
    "lr = 0.338\n",
    "# lr = random.randrange(200, 400)/1000\n",
    "model1 = nn.Sequential(nn.Linear(in_features=784, out_features=hidden1), nn.ReLU(),\n",
    "                       nn.Linear(in_features=hidden1, out_features=hidden), nn.ReLU(),\n",
    "                       nn.Linear(in_features=hidden, out_features=10))\n",
    "optimiser = torch.optim.SGD(model1.parameters(), lr=lr)\n",
    "train(model1, optimiser, mb_size, epochs)\n",
    "acc = accuracy(model1, x_val_tensor, y_val_tensor, mb_size)\n",
    "print(f'con lr: {lr} accuracy:{acc}')\n",
    "print()\n",
    "# models[lr] = acc    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9775390625"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy(model1, x_test_tensor, y_test_tensor, mb_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'models' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-19-cde94b991919>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmodels_ord\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msorted\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodels\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreverse\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'models' is not defined"
     ]
    }
   ],
   "source": [
    "models_ord = sorted(models.items(), key=lambda x: x[1], reverse = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "models_ord"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Guardar Modelo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_path = './modelMNIST2.pth'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.save(\n",
    "    model1.state_dict(),\n",
    "    model_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model1.state_dict()['0.bias'].shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cargar Modelo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "hidden1 = 1000 \n",
    "hidden = 1000\n",
    "modelMNIST = nn.Sequential(nn.Linear(in_features=784, out_features=hidden1), nn.ReLU(),\n",
    "                       nn.Linear(in_features=hidden1, out_features=hidden), nn.ReLU(),\n",
    "                       nn.Linear(in_features=hidden, out_features=10))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Sequential(\n",
       "  (0): Linear(in_features=784, out_features=1000, bias=True)\n",
       "  (1): ReLU()\n",
       "  (2): Linear(in_features=1000, out_features=1000, bias=True)\n",
       "  (3): ReLU()\n",
       "  (4): Linear(in_features=1000, out_features=10, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "modelMNIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "modelMNIST.load_state_dict(torch.load(model_path))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Sequential(\n",
       "  (0): Linear(in_features=784, out_features=1000, bias=True)\n",
       "  (1): ReLU()\n",
       "  (2): Linear(in_features=1000, out_features=1000, bias=True)\n",
       "  (3): ReLU()\n",
       "  (4): Linear(in_features=1000, out_features=10, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "modelMNIST = modelMNIST.to(device = 'cuda')\n",
    "modelMNIST.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10000"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_test.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sample_image():\n",
    "    rnd_idx = np.random.randint(10000)\n",
    "    image = x_test[rnd_idx].reshape(1, 28, 28)\n",
    "    plot_number(image)\n",
    "    return torch.tensor(image).to(device='cuda', dtype=torch.float).view(1, 784)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El num es: 0\n"
     ]
    }
   ],
   "source": [
    "image = sample_image()\n",
    "_, pred = modelMNIST(image).max(1)\n",
    "print(f'El num es: {pred[0]}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.8.3"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}