firstNotebook_workshop.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fundamentos de Deep Learning con PyTorch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MNIST"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"mnist.png\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The predicted class is: 9\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 460.8x403.2 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## Solo para probar el modelo ya entrenado, si se trata de ejecutar al inicio marcará error\n",
    "# image=sample_number()\n",
    "# _, class_is = loaded_model(image).max(1)\n",
    "# print(f'The predicted class is: {class_is[0]}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importar librerías"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Para graficar\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "# Las principales de PyTorch\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "# Otras más de PyTorch\n",
    "from torch.utils.data import DataLoader #Para dividir nuestros datos\n",
    "from torch.utils.data import sampler # Para muestrar datos\n",
    "import torchvision.datasets as dataset # Para importar DataSets\n",
    "import torchvision.transforms as T # Para aplicar transformaciones a nuestros datos\n",
    "# No es importante, sólo si tienen Jupyter Themes. Nothing to do with Deep Learning\n",
    "from jupyterthemes import jtplot\n",
    "jtplot.style()\n",
    "\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importar MNIST Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "NUM_TRAIN = 55000\n",
    "BATCH_SIZE = 512\n",
    "\n",
    "# Get our training, validation and test data.\n",
    "# data_path = '/media/josh/MyData/Databases/' #use your own data path, you may use an existing data path to avoid having to download the data again.\n",
    "data_path = '/media/josh/MyData/Databases/mnist'\n",
    "mnist_train = dataset.MNIST(data_path, train=True, download=True,\n",
    "                             transform=T.ToTensor())\n",
    "loader_train = DataLoader(mnist_train, batch_size=BATCH_SIZE, \n",
    "                          sampler=sampler.SubsetRandomSampler(range(NUM_TRAIN)))\n",
    "\n",
    "mnist_val = dataset.MNIST(data_path, train=True, download=True,\n",
    "                           transform=T.ToTensor())\n",
    "loader_val = DataLoader(mnist_val, batch_size=BATCH_SIZE, \n",
    "                        sampler=sampler.SubsetRandomSampler(range(NUM_TRAIN, 60000)))\n",
    "\n",
    "mnist_test = dataset.MNIST(data_path, train=False, download=True, \n",
    "                            transform=T.ToTensor())\n",
    "loader_test = DataLoader(mnist_test, batch_size=BATCH_SIZE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cómo usar un DataLoader?\n",
    "\n",
    "Un [DataLoader](https://pytorch.org/docs/stable/data.html) de PyTorch es un objeto Iterable de Python, sobre nuestro Dataset!\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([10000])\n",
      "torch.Size([10000, 28, 28])\n"
     ]
    }
   ],
   "source": [
    "y_test=loader_test.dataset.targets\n",
    "x_test=loader_test.dataset.data\n",
    "print(y_test.shape)\n",
    "print(x_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for it, (x, y) in enumerate(loader_test):\n",
    "    print(f'{it} X.shape is {x.shape}, y.shape is {y.shape}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_features = len(torch.flatten(x_test[0]))\n",
    "input_features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_number(image):\n",
    "    jtplot.style(grid=False)\n",
    "    plt.imshow(image.squeeze(), cmap=plt.get_cmap('gray'))\n",
    "#     plt.show()\n",
    "    plt.axis('off')\n",
    "    jtplot.style(grid=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_mnist_grid():\n",
    "    y_test=loader_test.dataset.targets\n",
    "    x_test=loader_test.dataset.data\n",
    "    samples = 8\n",
    "    plt.rcParams['figure.figsize'] = (15.0, 15.0) # set default size of plots\n",
    "    classes = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']\n",
    "    for label, example in enumerate(classes):\n",
    "    #     random_idx = np.random.randint(0,len(mnist_test))\n",
    "        plt_idxs = np.flatnonzero(y_test == label) # get all data equal to label\n",
    "        plt_idxs = np.random.choice(plt_idxs, samples, replace=False) #muestrea samples muestras de plt_idx\n",
    "    #     print(plt_idxs)\n",
    "        for i, idx in enumerate(plt_idxs):\n",
    "            plt_idx = i*len(classes) + label + 1 #plot index starts at 1\n",
    "            plt.subplot(samples, len(classes), plt_idx)\n",
    "    #         print(example, i, plt_idx)\n",
    "    #         plt.imshow(x_test[idx].type(torch.float32).reshape(28,28))\n",
    "    #         plt.axis('off')\n",
    "            plot_number(x_test[idx])\n",
    "            if i == 0:\n",
    "                plt.title(example)\n",
    "\n",
    "    plt.show()\n",
    "plot_mnist_grid()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rnd_idx = np.random.randint(len(y_test))\n",
    "print(f'La imagen muestreada representa un: {y_test[rnd_idx]}')\n",
    "plot_number(x_test[rnd_idx])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## GPUs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "using device: cuda\n"
     ]
    }
   ],
   "source": [
    "dtype = torch.float32\n",
    "if torch.cuda.is_available():\n",
    "    device = torch.device('cuda')\n",
    "else:\n",
    "    device = torch.device('cpu')\n",
    "\n",
    "print('using device:', device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compute Accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_acc(loader, model, eval_mode=False):\n",
    "    num_correct = 0\n",
    "    num_total = 0\n",
    "    if eval_mode: model.eval()\n",
    "    with torch.no_grad():\n",
    "        for x, y in loader:\n",
    "            x = x.to(device=device, dtype=dtype)\n",
    "            y = y.to(device=device, dtype=torch.long)\n",
    "            scores = model(x)\n",
    "            _, pred = scores.max(1)\n",
    "            assert pred.shape == y.shape, 'Label shape and prediction shape does not match'\n",
    "            num_correct += (pred==y).sum()\n",
    "            num_total += pred.size(0)           \n",
    "            \n",
    "        return float(num_correct)/num_total"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## High level model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_features = len(torch.flatten(x_test[0]))\n",
    "hidden = 1000\n",
    "num_classes = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model1 = nn.Sequential(\n",
    "\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_loss(losses):  \n",
    "    fig = plt.figure()\n",
    "    f1 = fig.add_subplot()\n",
    "    f1.set_ylabel(\"Cost\")\n",
    "    f1.set_xlabel(\"Epoch\")\n",
    "    f1.set_title(\"Cost vs Epoch\")\n",
    "    f1.plot(losses)\n",
    "    plt.show()\n",
    "    \n",
    "def train(model, optimizer, epochs=100):\n",
    "    model = model.to(device=device)\n",
    "    losses = []\n",
    "    \n",
    "    num_batches = len(loader_train)\n",
    "    for epoch in range(epochs):\n",
    "        accum_loss = 0.\n",
    "        for i, (x, y) in enumerate(loader_train):\n",
    "            #poner modelo en modo de entrenamiento\n",
    "            model.train()\n",
    "            #mover a GPU\n",
    "            x = x.to(device=device, dtype=dtype)\n",
    "            y = y.to(device=device, dtype=torch.long)\n",
    "            \n",
    "            #calcular scores\n",
    "\n",
    "            #calcular gradients\n",
    "\n",
    "            \n",
    "            #actualizar parametros\n",
    "\n",
    "            \n",
    "            #guardar pérdida\n",
    "            accum_loss += cost.item()\n",
    "        losses.append(accum_loss / num_batches)\n",
    "            \n",
    "        print(f'Epoch: {epoch}, loss: {cost.item()}, val accuracy: {compute_acc(loader_val, model, True)} ')\n",
    "        print()\n",
    "    plot_loss(losses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#entrenar el modelo\n",
    "learning_rate = 1e-2\n",
    "epochs = 10\n",
    "optimiser = torch.optim.SGD(model1.parameters(), lr=learning_rate)\n",
    "train(model1, optimiser, epochs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More elegant high level model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class FC_model(nn.Module):\n",
    "    def __init__(self, input_features, hidden = 1000, num_classes=10):\n",
    "        super().__init__()\n",
    "#         self.model =\n",
    "    def forward(self, x):\n",
    "        None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Entrenar modelo\n",
    "input_features = len(torch.flatten(x_test[0]))\n",
    "hidden = 1000\n",
    "num_classes = 10\n",
    "learning_rate = 1e-2\n",
    "epochs = 10\n",
    "model2 = FC_model(input_features)\n",
    "optimiser = torch.optim.Adam(model2.parameters(), lr = learning_rate)\n",
    "# optimiser = torch.optim.SGD(model2.parameters(), lr = learning_rate)\n",
    "train(model2, optimiser, epochs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "compute_acc(loader_test, model2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Guardando el modelo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_path = '/media/josh/MyData/Databases/mnist/FC_model1st.pth'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.save(model2.state_dict(), model_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "FC_model(\n",
       "  (model): Sequential(\n",
       "    (0): Flatten()\n",
       "    (1): Linear(in_features=784, out_features=1000, bias=True)\n",
       "    (2): ReLU()\n",
       "    (3): Linear(in_features=1000, out_features=10, bias=True)\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "input_features = len(torch.flatten(x_test[0]))\n",
    "loaded_model = FC_model(input_features=input_features)\n",
    "loaded_model.load_state_dict(torch.load(model_path))\n",
    "loaded_model = loaded_model.to(device=device)\n",
    "loaded_model.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sample_number():\n",
    "    rnd_idx = np.random.randint(10000)\n",
    "#     print(f'{y_test[rnd_idx]}')\n",
    "    image2 = x_test[rnd_idx][None, :,:]\n",
    "    plot_number(image2)\n",
    "    image2 = image2.type(torch.float32)\n",
    "    return image2.to(device=device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "image=sample_number()\n",
    "_, class_is = loaded_model(image).max(1)\n",
    "print(f'The predicted class is: {class_is[0]}')"
   ]
  },
  {
   "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": "markdown",
   "metadata": {},
   "source": [
    "## Red Neuronal con módulos básicos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def flatten(x):\n",
    "    N = x.shape[0]\n",
    "    return x.view(N, -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class FC_other():\n",
    "    def __init__(self, in_features, hidden=1000, num_classes = 10):\n",
    "        None\n",
    "        \n",
    "#     def forward(self, x):\n",
    "    def __call__(self, x):\n",
    "        None\n",
    "\n",
    "                "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample1 = x_test[0][None, :, :].to(device=device, dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hidden = 1000\n",
    "num_classes = 10\n",
    "model3 = FC_other(input_features, hidden, num_classes)\n",
    "# print(model3.forward(sample1).shape)\n",
    "print(model3(sample1).shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_loop(model, epochs=10, learning_rate = 1e-6):\n",
    "#     model = model.to(device=device)\n",
    "    losses = []\n",
    "    num_batches = len(loader_train)\n",
    "    for epoch in range(epochs):\n",
    "        acum_loss = 0.\n",
    "        for it, (x, y) in enumerate(loader_train):\n",
    "            #Move to selected device\n",
    "            x=x.to(device=device, dtype=dtype)\n",
    "            y=y.to(device=device, dtype=torch.long)\n",
    "#             print(x.shape)\n",
    "            #compute scores\n",
    "#             scores = model.forward(x)\n",
    "            scores = model(x)\n",
    "            #compute cost\n",
    "            cost = F.cross_entropy(input=scores, target=y)\n",
    "            #compute gradient\n",
    "            cost.backward()\n",
    "            \n",
    "            #update parameters\n",
    "            with torch.no_grad():\n",
    "                model.W1 -= learning_rate * model.W1.grad\n",
    "                model.b1 -= learning_rate * model.b1.grad\n",
    "                \n",
    "                model.W2 -= learning_rate * model.W2.grad\n",
    "                model.b2 -= learning_rate * model.b2.grad\n",
    "                \n",
    "                #zero grads\n",
    "                model.W1.grad.zero_()\n",
    "                model.b1.grad.zero_()\n",
    "                model.W2.grad.zero_()\n",
    "                model.b2.grad.zero_()            \n",
    "            \n",
    "            acum_loss += cost.item()\n",
    "        losses.append(acum_loss/num_batches)\n",
    "        print(f'Epoch: {epoch}, loss: {cost.item()}, val accuracy: {compute_acc(loader_val, model)} ')\n",
    "        print()\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "learning_rate = 1e-2\n",
    "epochs = 20\n",
    "hidden = 1000\n",
    "num_classes = 10\n",
    "model_fc1 = FC_other(input_features, hidden, num_classes)\n",
    "# print(model_fc1.forward(x1).shape)\n",
    "\n",
    "train_loop(model_fc1, epochs, learning_rate)"
   ]
  },
  {
   "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
}