02b_advanced_networks.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Music machine learning - Advanced neural networks\n",
    "\n",
    "### Author: Philippe Esling (esling@ircam.fr)\n",
    "\n",
    "In this course we will cover\n",
    "1. An introduction to [convolutions](#convolution) and how they can be used\n",
    "2. Defining a [Convolutional Neural Network](#cnn) in Pytorch for image classification \n",
    "3. Coding our own [convolutional layer](#layer)\n",
    "4. An explanation on [recurrent networks](#rnn) in practice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"convolution\"></a>\n",
    "## Convolutions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In purely mathematical terms, convolution is a function derived from two given functions by integration which expresses how the shape of one is modified by the other. In simpler (discrete) terms, the convolution product of a matrix by a smaller one can be seen as _filtering_ the large matrix. Hence we slide the small matrix over the large one and compute local products at each position. Therefore the convolution operator $\\star$ computes at each position $n$\n",
    "\n",
    "$$\n",
    "(f \\star g)[n]=\\sum _{m=-M}^{M}f[n-m]g[m].\n",
    "$$\n",
    "\n",
    "An example of this operation is shown here\n",
    "\n",
    "<img src=\"images/02_convolution.png\" align=\"center\"/>\n",
    "\n",
    "This operation can be used to _filter_ the image (as in the _gaussian blur_ operator), or _detect_ features (such as edges). \n",
    "\n",
    "Given an 32x32 image with RGB channels, we can represent it as a tensor of shape `(32, 32, 3)` which is (height, width, channels). When we perform convolution, we need a filter that has the same channel depth as the image. For example, we can use a 5x5 filter which is of shape `(5, 5, 3)` and slide it across the image left to right, top to bottom with a stride of 1 to perform convolution. We are going to perform this in numpy, depending on a certain amount of parameters, which define the behavior of our convolution\n",
    "\n",
    "* `height` and `width`: spatial extend of the filters\n",
    "* `S`: stride size (number of steps to jump to the next position)\n",
    "* `P`: amount of padding (adding zeros in the original matrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Padding\n",
    "pad = 2\n",
    "stride = 1\n",
    "height, width = 5, 5\n",
    "\n",
    "# A random fake image\n",
    "x = np.random.randn(3, 32, 32)\n",
    "x_h, x_w = x.shape[1:]\n",
    "\n",
    "# Our convolution kernel\n",
    "weight = np.random.randn(3, 5, 5)\n",
    "\n",
    "# Padding the original image\n",
    "x_pad = np.pad(x, pad_width=((0, 0,), (pad, pad), (pad, pad)), mode='constant', constant_values=0)\n",
    "\n",
    "# We can expect the output size to be\n",
    "h_out = int(1 + (x_h + 2 * pad - height) / stride)\n",
    "w_out = int(1 + (x_w + 2 * pad - width) / stride)\n",
    "\n",
    "# So we will store our result in\n",
    "y = np.zeros((1, h_out, w_out))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Computing the convolution itself can be performed by using the following loop (which amounts to _slide_ our kernel across the large matrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sliding the kernel across the matrix\n",
    "for h in range(h_out):\n",
    "    for w in range(w_out):\n",
    "        i, j = h * stride, w * stride\n",
    "        conv_sum = np.sum(x_pad[:, i:i+height, j:j+width] * weight)\n",
    "        y[0, h, w] = conv_sum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can witness the effect of this operation with the following plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f9d05f190f0>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.imshow(y[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Convolutional Neural Networks (CNN)\n",
    "\n",
    "Convolutional NNs (CNNs) rely on convolution in place of general matrix multiplication. They are specialized for processing data with a known grid-like topology and are among the best performing systems in classification/recognition tasks. Each layer in a CNN consists in a set of $N$ _filters_ called _kernels_, that are convolved across the input. If we denote as $\\{k^l_n\\}_{n\\in[1;N]}$ the set of kernels for layer $l$, these all share a unique _kernel size_. By convolving each one of its $N$ kernels across a d-dimensional input $x$, a convolutional layer produces $N$ d-dimensional outputs called _feature maps_, denoted as $\\{a^l_n\\}_{n\\in[1;N]}$. Hence, the computation of the $n$-th activation map in layer $l$ for input $x$ is defined as:\n",
    "\n",
    "$$\n",
    "\\begin{equation}\n",
    "a^l_n = \\sum_{m=1}^{M} k^l_n \\star x_m + b^l_n\n",
    "\\end{equation}\n",
    "$$\n",
    "\n",
    "Thus, as depicted in the following Figure, the feature map corresponding to kernel $n$ consists in the sum of the d-dimensional discrete convolutions (denoted by the $\\star$ operator) between the kernel $n$ and each one of the d-dimensional data $\\{x_m\\}_{m\\in[1;M]}$, plus a bias $b$. A convolutional layer is thus a 3-dimensional tensor $h \\in \\mathcal{T}_{N,I,J}(\\mathbb{R})$ where $N$ is the number of features maps while $I$ and $J$ are respectively the _width_ and _height_ of the maps. \n",
    "\n",
    "<img src=\"images/02_cnns.png\" align=\"center\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This can be seen as replacing our _neurons_ by _feature detectors_ (the convolutional kernels), which will increasingly process the image. In the following, we will first use the high-level interface of `Pytorch` to define a CNN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"cnn\"></a>\n",
    "## Defining a CNN in Pytorch\n",
    "\n",
    "Defining a convolutional network in Pytorch is quite easy, as we can rely on the `nn` module, which contains all the required layers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the previous course, we have seen that we could define our network in a very simple way, by using the `Sequential` model definition. Here we define a CNN followed by a MLP, as seen in the previous course"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the input dimensions\n",
    "in_size = 1000\n",
    "\n",
    "# Use the nn package to define our model and loss function.\n",
    "model = nn.Sequential(\n",
    "    nn.Conv2d(3, 6, 5),\n",
    "    nn.ReLU(),\n",
    "    nn.MaxPool2d(2, 2),\n",
    "    nn.Conv2d(6, 16, 5),\n",
    "    nn.ReLU(),\n",
    "    nn.MaxPool2d(2, 2),\n",
    "    nn.Flatten(),\n",
    "    nn.Linear(16 * 5 * 5, 120),\n",
    "    nn.ReLU(),\n",
    "    nn.Linear(120, 84),\n",
    "    nn.ReLU(),\n",
    "    nn.Linear(84, 10),\n",
    "    nn.Softmax(dim=1)\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another way to implement the networks in Pytorch is to use the `functional` approach. In this version, each layer is seen as a function, that we apply on sucessive inputs. For instance, we can define one layer of fully-connected units and apply it to some inputs as follows.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn.functional as F\n",
    "\n",
    "# Define one layer\n",
    "layer = nn.Linear(100, 10)\n",
    "\n",
    "# Define the non-linearity\n",
    "activation = nn.ReLU()\n",
    "\n",
    "# Create some random input\n",
    "inputs = torch.rand(32, 100)\n",
    "\n",
    "# Apply our layers\n",
    "outputs = activation(layer(inputs))\n",
    "\n",
    "# Equivalently, as ReLU is parameter-free\n",
    "outputs = F.relu(layer(inputs))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now to make this even cleaner, we can define our own `nn.Module`, which is a `Pytorch` class representing models. To do so, we can define a sub-class, and implement the functions `__init__` (defining our layers) and `forward` (explaining how our forward pass will behave)\n",
    "\n",
    "***\n",
    "\n",
    "**Exercise**\n",
    "1. Implement a CNN in Pytorch using the `functional` library\n",
    "\n",
    "***\n",
    "\n",
    "<!--\n",
    "<div class=\"alert alert-info\" markdown=1><h4>Exercise</h4>\n",
    "1. Implement a CNN in Pytorch using the `functional` library\n",
    "</div>\n",
    "-->\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "class CNN(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(CNN, self).__init__()\n",
    "        self.conv1 = nn.Conv2d(3, 6, 5)\n",
    "        self.pool = nn.MaxPool2d(2, 2)\n",
    "        self.conv2 = nn.Conv2d(6, 16, 5)\n",
    "        self.fc1 = nn.Linear(16 * 5 * 5, 120)\n",
    "        self.fc2 = nn.Linear(120, 84)\n",
    "        self.fc3 = nn.Linear(84, 10)\n",
    "        self.flat = nn.Flatten()\n",
    "        self.relu = nn.ReLU()\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.pool(self.relu(self.conv1(x)))\n",
    "        x = self.pool(self.relu(self.conv2(x)))\n",
    "        x = self.flat(x)\n",
    "        x = self.relu(self.fc1(x))\n",
    "        x = self.relu(self.fc2(x))\n",
    "        x = self.fc3(x) # Pas de Softmax car compris dans la CrossEntropy Loss\n",
    "        return x\n",
    "\n",
    "cnn = CNN()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "net = cnn.to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training the network\n",
    "\n",
    "In order to test our CNN, we are going to try to perform image classification. To do so, we can use the simplifications for data loading contained in `torchvision`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torchvision\n",
    "import torchvision.transforms as transforms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `torchvision` package provides pre-coded simplification to download and use the major image datasets, notably `MNIST` and `CIFAR`, which are the baseline datasets for testing image ML models. The output of torchvision datasets are PILImage images of range [0, 1]. We transform them to Tensors of normalized range [-1, 1].\n",
    "\n",
    "In the following code, we are going to load the `CIFAR10` _train_ and _test_ sets. **Note that this code will automatically download the dataset if you did not have it before, and place it in the `data` folder, so this might take a bit of time**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n"
     ]
    }
   ],
   "source": [
    "# Transforms to apply to the images\n",
    "transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\n",
    "\n",
    "# Import the train dataset\n",
    "trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)\n",
    "# trainloader = torch.utils.data.DataLoader(trainset, batch_size=4, shuffle=True, num_workers=2)\n",
    "\n",
    "# Import the test dataset\n",
    "testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)\n",
    "testloader = torch.utils.data.DataLoader(testset, batch_size=4, shuffle=False, num_workers=2)\n",
    "\n",
    "# Classes in the CIFAR dataset\n",
    "classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Creation of another dataset and dataloader, the valid one"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "split_value = 0.9\n",
    "train_size = int(split_value * len(trainset))\n",
    "validation_size = len(trainset) - train_size\n",
    "\n",
    "trainset, validset = torch.utils.data.random_split(trainset, [train_size, validation_size])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainloader = torch.utils.data.DataLoader(trainset, batch_size=4, shuffle=True)\n",
    "validloader = torch.utils.data.DataLoader(validset, batch_size=4, shuffle=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using your knowledge from the previous course, you can now define an optimization problem, and implement the training loop for your model\n",
    "\n",
    "***\n",
    "\n",
    "**Exercise**\n",
    "1. Define a `criterion` and `optimizer`\n",
    "2. Fill in the training loop to train your model\n",
    "\n",
    "***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.optim as optim\n",
    "\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = optim.Adam(cnn.parameters(), lr=0.001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 1\n",
      "Training loss: 0.3892, acc 42.7178\n",
      "Validation loss: 0.3487, acc 49.5000\n",
      "Epoch: 2\n",
      "Training loss: 0.3258, acc 53.1622\n",
      "Validation loss: 0.3293, acc 52.5600\n",
      "Epoch: 3\n",
      "Training loss: 0.3034, acc 56.8978\n",
      "Validation loss: 0.3029, acc 58.0600\n",
      "Epoch: 4\n",
      "Training loss: 0.2858, acc 59.3822\n",
      "Validation loss: 0.3033, acc 57.3400\n",
      "Epoch: 5\n",
      "Training loss: 0.2737, acc 61.2111\n",
      "Validation loss: 0.2900, acc 59.8800\n",
      "Epoch: 6\n",
      "Training loss: 0.2632, acc 62.6111\n",
      "Validation loss: 0.2945, acc 59.5000\n",
      "Epoch: 7\n",
      "Training loss: 0.2538, acc 64.1889\n",
      "Validation loss: 0.2883, acc 60.4800\n",
      "Epoch: 8\n",
      "Training loss: 0.2473, acc 65.2622\n",
      "Validation loss: 0.3039, acc 59.3200\n",
      "Epoch: 9\n",
      "Training loss: 0.2401, acc 66.2133\n",
      "Validation loss: 0.2990, acc 59.9400\n",
      "Epoch: 10\n",
      "Training loss: 0.2359, acc 66.8800\n",
      "Validation loss: 0.2846, acc 61.7600\n"
     ]
    }
   ],
   "source": [
    "n_epochs = 10\n",
    "\n",
    "train_loss = []\n",
    "validation_loss = []\n",
    "\n",
    "train_correct = []\n",
    "validation_correct = []\n",
    "\n",
    "# training Loop\n",
    "for epoch in range(n_epochs):\n",
    "\n",
    "    running_loss, running_valid_loss = 0.0, 0.0\n",
    "    running_corrects, running_valid_corrects = 0.0, 0.0\n",
    "\n",
    "    for i, data in enumerate(trainloader, 0):\n",
    "        inputs, labels = data\n",
    "        inputs = inputs.to(device)\n",
    "        labels = labels.to(device)\n",
    "        \n",
    "        # zero the parameter gradients\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        # forward\n",
    "        outputs = cnn(inputs)\n",
    "        \n",
    "        # backward\n",
    "        loss = criterion(outputs, labels)\n",
    "        loss.backward()     \n",
    "        \n",
    "        # optimize weights and bias\n",
    "        optimizer.step()\n",
    "\n",
    "        # print statistics\n",
    "        _, preds = torch.max(outputs, 1)\n",
    "        running_loss += loss.item()\n",
    "        running_corrects += (preds == labels.data).sum()\n",
    "\n",
    "    with torch.no_grad(): \n",
    "        # torch.no_grad() because we don't want any update with this loop,\n",
    "        # just check the accuracy and loss to make sure the training is going well  \n",
    "        for i, data in enumerate(validloader, 0):\n",
    "            val_inputs, val_labels = data\n",
    "            val_inputs = val_inputs.to(device)\n",
    "            val_labels = val_labels.to(device)\n",
    "\n",
    "            # forward and calculate the loss\n",
    "            val_outputs = cnn(val_inputs)\n",
    "            val_loss = criterion(val_outputs, val_labels)\n",
    "\n",
    "            # print statistics\n",
    "            _, val_preds = torch.max(val_outputs, 1)\n",
    "            running_valid_loss += val_loss.item()\n",
    "            running_valid_corrects += torch.sum(val_preds == val_labels.data)\n",
    "\n",
    "    # calculating the average training and validation loss over epoch\n",
    "    epoch_loss = running_loss / len(trainset)\n",
    "    val_epoch_loss = running_valid_loss / len(validset)\n",
    "\n",
    "    epoch_acc = 100 * running_corrects / len(trainset)\n",
    "    val_epoch_acc = 100 * running_valid_corrects / len(validset)\n",
    "\n",
    "    # printing average training and average validation losses\n",
    "    print(\"Epoch: {}\".format(epoch+1))\n",
    "    print(\"Training loss: {:.4f}, acc {:.4f}\".format(epoch_loss, epoch_acc))\n",
    "    print(\"Validation loss: {:.4f}, acc {:.4f}\".format(val_epoch_loss, val_epoch_acc))\n",
    "\n",
    "    train_loss.append(epoch_loss)\n",
    "    train_correct.append(epoch_acc)\n",
    "    validation_loss.append(val_epoch_loss)\n",
    "    validation_correct.append(val_epoch_acc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that your model is trained, you can test it by feeding some new (unseen) images and see if it is able to classify them correctly"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accuracy of the model for the testset (unseen images)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of the network on test images: 61 %\n"
     ]
    }
   ],
   "source": [
    "correct = 0\n",
    "total = 0 \n",
    "\n",
    "correct_pred = {'plane': 0, 'car': 0, 'bird': 0, 'cat': 0, 'deer': 0, 'dog': 0, 'frog': 0, 'horse': 0, 'ship': 0, 'truck': 0}\n",
    "total_pred = {'plane': 0, 'car': 0, 'bird': 0, 'cat': 0, 'deer': 0, 'dog': 0, 'frog': 0, 'horse': 0, 'ship': 0, 'truck': 0}\n",
    "\n",
    "with torch.no_grad():\n",
    "    for data in testloader:\n",
    "        inputs, labels = data\n",
    "\n",
    "        # forward the data\n",
    "        predictions = net(inputs)\n",
    "\n",
    "        # calculate the total of samples\n",
    "        total += len(predictions)\n",
    "        \n",
    "        # calculate the total of samples that are correctly predicted\n",
    "        _, predictions = torch.max(predictions, 1)\n",
    "        correct += (predictions == labels).sum()\n",
    "        \n",
    "        # collect the correct predictions for each class\n",
    "        for label, prediction in zip(labels, predictions):\n",
    "            # for each label that are correct, add  1 to its corresponding place in the dict\n",
    "            if(label == prediction):\n",
    "                correct_pred[classes[label]] += 1\n",
    "                total_pred[classes[label]] += 1\n",
    "            else:\n",
    "                total_pred[classes[label]] += 1\n",
    "\n",
    "print('Accuracy of the network on test images: %d %%' % (100 * correct / total))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy for class plane is: 73.1 %\n",
      "Accuracy for class car   is: 81.5 %\n",
      "Accuracy for class bird  is: 43.3 %\n",
      "Accuracy for class cat   is: 39.2 %\n",
      "Accuracy for class deer  is: 64.0 %\n",
      "Accuracy for class dog   is: 50.1 %\n",
      "Accuracy for class frog  is: 68.0 %\n",
      "Accuracy for class horse is: 65.4 %\n",
      "Accuracy for class ship  is: 71.8 %\n",
      "Accuracy for class truck is: 58.1 %\n"
     ]
    }
   ],
   "source": [
    "# print accuracy for each class\n",
    "for classname, correct_count in correct_pred.items():\n",
    "    accuracy = 100 * float(correct_count) / total_pred[classname]\n",
    "    print(\"Accuracy for class {:5s} is: {:.1f} %\".format(classname, accuracy))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"layer\"></a>\n",
    "## Coding our own convolutional layer\n",
    "\n",
    "Although `Pytorch` comes packed with pre-implemented layers, we can also very easily define our own layers. This will be useful when you start doing research and propose your own way of processing the information. A large advantage of `Pytorch` is that it performs _automatic gradient differentiation_, this means that we simply have to define how the `forward` pass will work, and `Pytorch` will automatically infer the backpropagation equations, without us having to go through any complicated differentiation\n",
    "\n",
    "In the following, we are going to redefine the `Conv2d` layer, by computing the operation ourselves.\n",
    "\n",
    "***\n",
    "\n",
    "**Exercise**\n",
    "1. Complete the `forward` function to compute a convolution\n",
    "\n",
    "***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyConv2d(nn.Module):\n",
    "    def __init__(self, n_channels, out_channels, kernel_size, dilation=1, padding=0, stride=1):\n",
    "        super(MyConv2d, self).__init__()\n",
    "        self.kernel_size = (kernel_size, kernel_size)\n",
    "        self.kernal_size_number = kernel_size * kernel_size\n",
    "        self.out_channels = out_channels\n",
    "        self.dilation = (dilation, dilation)\n",
    "        self.padding = (padding, padding)\n",
    "        self.stride = (stride, stride)\n",
    "        self.n_channels = n_channels\n",
    "        self.weights = nn.Parameter(torch.Tensor(self.out_channels, self.n_channels, self.kernal_size_number))\n",
    "\n",
    "    def forward(self, x):\n",
    "        width = self.calculateNewWidth(x)\n",
    "        height = self.calculateNewHeight(x)\n",
    "        windows = self.calculateWindows(x)\n",
    "        \n",
    "        ######################\n",
    "        # YOUR CODE GOES HERE\n",
    "        ######################\n",
    "        \n",
    "        return result  \n",
    "\n",
    "    def calculateWindows(self, x):\n",
    "        windows = F.unfold(x, kernel_size=self.kernel_size, padding=self.padding, dilation=self.dilation, stride=self.stride)\n",
    "        windows = windows.transpose(1, 2).contiguous().view(-1, x.shape[1], self.kernal_size_number)\n",
    "        windows = windows.transpose(0, 1)\n",
    "        return windows\n",
    "\n",
    "    def calculateNewWidth(self, x):\n",
    "        return ((x.shape[2] + 2 * self.padding[0] - self.dilation[0] * (self.kernel_size[0] - 1) - 1) // self.stride[0]) + 1\n",
    "\n",
    "    def calculateNewHeight(self, x):\n",
    "        return ((x.shape[3] + 2 * self.padding[1] - self.dilation[1] * (self.kernel_size[1] - 1) - 1)// self.stride[1]) + 1\n",
    "\n",
    "# Testing the code directly\n",
    "conv = MyConv2d(3, 1, 3)\n",
    "x = torch.randn(1, 3, 24, 24)\n",
    "out = conv(x)\n",
    "out.mean().backward()\n",
    "\n",
    "# Check that we do have gradients\n",
    "print(conv.weights.grad)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now you can use your own `MyConv2d` layer, and use it in real-life scenarios, by trying to change your previous model to use your own layer instead."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Recurrent Neural Networks (RNN)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recurrent neural networks (RNNs) are a family of models designed to process time series and sequential data, which perform remarkably in applications such as speech recognition or machine translation. The ability of RNNs to model correlations between successive computations through recurrent connection make them efficient for temporal problem as they provide a form of _memory_. \n",
    "\n",
    "To model structured sequential data, NNs can be augmented with recurrent loops, which allow to retain information across time steps. Considering a sequence $\\mathbf{X}=\\{\\mathbf{x}_t\\}$, dependencies between elements are managed by having a recurrent hidden state $\\mathbf{h}_t$ at time $t$ in the network. The value of $\\mathbf{h}_t$ at each time depends of the previous time and the input, as depicted in the following figure. \n",
    "\n",
    "<img src=\"images/02_rnn.png\" align=\"center\"/>\n",
    "\n",
    "Formally, each hidden state is updated as\n",
    "\n",
    "$$\n",
    "\\begin{equation}\n",
    "\\mathbf{h}_t = \n",
    "\\begin{cases} \n",
    "\\phi_{\\mathbf{\\mathbf{\\theta}}}(\\mathbf{x}_0) & \\text{if } t=0 \\\\ \n",
    "\\phi_{\\mathbf{\\mathbf{\\theta}}}(\\mathbf{h}_{t-1},\\mathbf{x}_t), & \\text{otherwise} \n",
    "\\end{cases}\n",
    "\\end{equation}\n",
    "$$ "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementing a simple rnn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's a simple one-to-many vanilla recurrent neural network example in functional form. If we were to produce `h[t]`, we need some weight matrices, `h[t-1]`, `x[t]` and a non-linearity `tanh`.\n",
    "\n",
    "$$\n",
    "h_{t} = tanh(W_{hh}h_{t-1} + W_{xh}x_{t} + B_{h})\n",
    "$$\n",
    "\n",
    "Since this is a **one-to-many** network, we'd want to produce an output `y[t]` at every timestep, thus, we need another weight matrix that accepts a hidden state and project it to an output.\n",
    "\n",
    "$$\n",
    "y_{t} = W_{hy}h_{t} + B_{y}\n",
    "$$\n",
    "\n",
    "Now that we know how to use the `Functional` library of `Pytorch`, we are going to implement our own simple RNN layer as previously. This time, we do not provide the content of the `__init__` function, so think carefully of what parameters you will need and how you need to define them.\n",
    "\n",
    "***\n",
    "\n",
    "**Exercise**\n",
    "1. Complete the `__init__` function to instantiate all required parameters\n",
    "1. Complete the `forward` function to compute the forward pass\n",
    "\n",
    "***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "class RecurrentNetwork(nn.Module):\n",
    "    \n",
    "    def __init__(self, input_size, hidden_size, output_size):\n",
    "        \"\"\" Defines the required variables \"\"\"\n",
    "        super(RecurrentNetwork, self).__init__()\n",
    "        \n",
    "        ######################\n",
    "        # YOUR CODE GOES HERE\n",
    "        ######################\n",
    "\n",
    "    \n",
    "    def forward(self, x):\n",
    "        \"\"\" Computes the forward pass \"\"\"\n",
    "        \n",
    "        ######################\n",
    "        # YOUR CODE GOES HERE\n",
    "        ######################\n",
    "        \n",
    "        return output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can then forward propagate our information inside our network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "in_size = 4\n",
    "input_vector = torch.ones(16, in_size)\n",
    "simple_network = RecurrentNetwork(in_size, 10, 5)\n",
    "\n",
    "# Notice that same input, but leads to different ouptut at every single time step.\n",
    "print(simple_network(input_vector))\n",
    "print(simple_network(input_vector))\n",
    "print(simple_network(input_vector))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As usual, `Pytorch` also comes packed with some pre-coded recurrent layers. You can go check the documentation to find how to use these."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.4 ('atiam_ml')",
   "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.10.4"
  },
  "vscode": {
   "interpreter": {
    "hash": "19d703e906ada558fae81aed9eb14243028cc1b26072879ea22a3f4f6919ed00"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}