DL4CV_Assignment_3_2023.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fEIKuiL9V7G3"
      },
      "source": [
        "\n",
        "\n",
        "# Week 7"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QCYZMNB89n6C"
      },
      "source": [
        "**Welcome to Assignment 4 on Deep Learning for Computer Vision.**\n",
        "\n",
        "This assignment is based on the content you learned in Week-7 of the course.\n",
        "\n",
        "\n",
        "#### **Instructions**\n",
        "1. Use Python 3.x to run this notebook\n",
        "2. Write your code only in between the lines 'YOUR CODE STARTS HERE' and 'YOUR CODE ENDS HERE'.\n",
        "you should not change anything else in the code cells, if you do, the answers you are supposed to get at the end of this assignment might be wrong.\n",
        "3. Read documentation of each function carefully.\n",
        "4. All the Best!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AtVEfKH7dqbu"
      },
      "source": [
        "## Triplet loss:\n",
        "\n",
        "In this question you will implement triplet loss for MNIST dataset."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "metadata": {
        "id": "yEOowOYw9Uxo"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "from torchvision import datasets, transforms\n",
        "import torch.nn.functional as F\n",
        "from torch.utils.data import Dataset\n",
        "from torch.utils.data.sampler import BatchSampler\n",
        "from torch.optim import lr_scheduler\n",
        "from PIL import Image\n",
        "import timeit\n",
        "from torchvision.datasets import MNIST\n",
        "from torchvision import transforms\n",
        "import cv2\n",
        "# from google.colab.patches import cv2_imshow\n",
        "\n",
        "## Please DONOT remove these lines.\n",
        "torch.manual_seed(0)\n",
        "torch.backends.cudnn.deterministic = True\n",
        "torch.backends.cudnn.benchmark = False\n",
        "np.random.seed(0)\n",
        "########################\n",
        "\n",
        "cuda = torch.cuda.is_available()\n",
        "#### YOUR CODE STARTS HERE ####\n",
        "# Check availability of GPU and set the device accordingly\n",
        "device = torch.device(\"cuda\" if cuda else \"cpu\")\n",
        "#### YOUR CODE ENDS HERE ####\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "metadata": {
        "id": "n9TiTCF5CXCQ"
      },
      "outputs": [],
      "source": [
        "\n",
        "#Prepare dataset\n",
        "train_dataset = MNIST('../data/MNIST', train=True, download=True,\n",
        "                             transform=transforms.Compose([\n",
        "                                 transforms.ToTensor(),\n",
        "                                 transforms.Normalize((0.1307,), (0.3081,))\n",
        "                             ]))\n",
        "test_dataset = MNIST('../data/MNIST', train=False, download=True,\n",
        "                            transform=transforms.Compose([\n",
        "                                transforms.ToTensor(),\n",
        "                                transforms.Normalize((0.1307,), (0.3081,))\n",
        "                            ]))\n",
        "n_classes = 10\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V8XloNEneiOa"
      },
      "source": [
        "###Create dataset for Triplet Network"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {
        "id": "_BulQt1C_FJD"
      },
      "outputs": [],
      "source": [
        "class TripletDataset(Dataset):\n",
        "    \"\"\"\n",
        "    This program returns anchor, positive and negative sample for training\n",
        "    Creates fixed triplets for testing\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, mnist_dataset):\n",
        "        self.mnist_dataset = mnist_dataset\n",
        "        self.train = self.mnist_dataset.train\n",
        "        self.transform = self.mnist_dataset.transform\n",
        "        # Prepare labels and data for extracting positive and negative samples during training\n",
        "        if self.train:\n",
        "            self.train_labels = self.mnist_dataset.train_labels\n",
        "            self.train_data = self.mnist_dataset.train_data\n",
        "            self.labels_set = set(self.train_labels.numpy())\n",
        "            self.label_to_indices = {label: np.where(self.train_labels.numpy() == label)[0]\n",
        "                                     for label in self.labels_set}\n",
        "        #### YOUR CODE STARTS HERE ####\n",
        "        # Refering to the above code where we prepared labels and data for testing, please prepare test samples\n",
        "        else:\n",
        "            self.test_labels = self.mnist_dataset.test_labels\n",
        "            self.test_data = self.mnist_dataset.test_data\n",
        "            self.labels_set = set(self.test_labels.numpy())\n",
        "            self.label_to_indices = {label: np.where(self.test_labels.numpy() == label)[0]\n",
        "                                     for label in self.labels_set}\n",
        "\n",
        "       #### YOUR CODE ENDS HERE ####\n",
        "            random_state = np.random.RandomState(29)\n",
        "\n",
        "            triplets = [[i,\n",
        "                         random_state.choice(self.label_to_indices[self.test_labels[i].item()]),\n",
        "                         random_state.choice(self.label_to_indices[\n",
        "                                                 np.random.choice(\n",
        "                                                     list(self.labels_set - set([self.test_labels[i].item()]))\n",
        "                                                 )\n",
        "                                             ])\n",
        "                         ]\n",
        "                        for i in range(len(self.test_data))]\n",
        "            self.test_triplets = triplets\n",
        "\n",
        "    def __getitem__(self, index):\n",
        "        if self.train:\n",
        "          #### YOUR CODE STARTS HERE ####\n",
        "            # assign train_data[index] to anchor and train_label[index] item() to label1\n",
        "            anchor, label1 = self.train_data[index], self.train_labels[index].item()\n",
        "          #### YOUR CODE ENDS HERE ####\n",
        "            positive_index = index\n",
        "            while positive_index == index:\n",
        "                positive_index = np.random.choice(self.label_to_indices[label1])\n",
        "            negative_label = np.random.choice(list(self.labels_set - set([label1])))\n",
        "            negative_index = np.random.choice(self.label_to_indices[negative_label])\n",
        "            positive = self.train_data[positive_index]\n",
        "            negative = self.train_data[negative_index]\n",
        "        else:\n",
        "           #### YOUR CODE STARTS HERE ####\n",
        "             # assign test data at test_triplets[index][0] to anchor, test data at test_triplets[index][1] to positive sample and test data at test_triplets[index][2] to negative sample\n",
        "            anchor = self.test_data[self.test_triplets[index][0]]\n",
        "            positive = self.test_data[self.test_triplets[index][1]]\n",
        "            negative = self.test_data[self.test_triplets[index][2]]\n",
        "           #### YOUR CODE ENDS HERE ####\n",
        "\n",
        "        anchor = Image.fromarray(anchor.numpy(), mode='L')\n",
        "        positive = Image.fromarray(positive.numpy(), mode='L')\n",
        "        negative = Image.fromarray(negative.numpy(), mode='L')\n",
        "        if self.transform is not None:\n",
        "            anchor = self.transform(anchor)\n",
        "            positive = self.transform(positive)\n",
        "            negative = self.transform(negative)\n",
        "        return (anchor, positive, negative), []\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.mnist_dataset)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "metadata": {
        "id": "0nsYlOiuDLAw"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "c:\\Users\\ajays\\anaconda3\\envs\\torch\\Lib\\site-packages\\torchvision\\datasets\\mnist.py:65: UserWarning: train_labels has been renamed targets\n",
            "  warnings.warn(\"train_labels has been renamed targets\")\n",
            "c:\\Users\\ajays\\anaconda3\\envs\\torch\\Lib\\site-packages\\torchvision\\datasets\\mnist.py:75: UserWarning: train_data has been renamed data\n",
            "  warnings.warn(\"train_data has been renamed data\")\n",
            "c:\\Users\\ajays\\anaconda3\\envs\\torch\\Lib\\site-packages\\torchvision\\datasets\\mnist.py:70: UserWarning: test_labels has been renamed targets\n",
            "  warnings.warn(\"test_labels has been renamed targets\")\n",
            "c:\\Users\\ajays\\anaconda3\\envs\\torch\\Lib\\site-packages\\torchvision\\datasets\\mnist.py:80: UserWarning: test_data has been renamed data\n",
            "  warnings.warn(\"test_data has been renamed data\")\n"
          ]
        }
      ],
      "source": [
        "#### YOUR CODE STARTS HERE ####\n",
        "# Define the training and test sets\n",
        "# Use TripletDataset\n",
        "# Pass train_dataset for triplet_train_dataset and test_datset for triplet_test_dataset\n",
        "triplet_train_dataset = TripletDataset(train_dataset)\n",
        "triplet_test_dataset = TripletDataset(test_dataset)\n",
        "#### YOUR CODE ENDS HERE ####\n",
        "batch_size = 128\n",
        "triplet_train_loader = torch.utils.data.DataLoader(triplet_train_dataset, batch_size=batch_size, shuffle=True)\n",
        "triplet_test_loader = torch.utils.data.DataLoader(triplet_test_dataset, batch_size=batch_size, shuffle=False)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "metadata": {
        "id": "IuBgY8H3ABps"
      },
      "outputs": [],
      "source": [
        "class EmbeddingNet(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(EmbeddingNet, self).__init__()\n",
        "        #### YOUR CODE STARTS HERE ####\n",
        "        # Define a sequential block as per the instructions below:\n",
        "        # Build three blocks with each block containing: Conv->PReLU->Maxpool layers\n",
        "        # Three conv layers should have 32, 128, 32 output channels respectively\n",
        "        # Use convolution kernel size 5, 5, 3 respectively\n",
        "        # For maxpool use a kernel size of 2 and stride of 2\n",
        "\n",
        "        self.convnet = nn.Sequential(\n",
        "            nn.Conv2d(in_channels=1, out_channels=32, kernel_size=5),\n",
        "            nn.PReLU(),\n",
        "            nn.MaxPool2d(kernel_size=2, stride=2),\n",
        "            nn.Conv2d(in_channels=32, out_channels=128, kernel_size=5),\n",
        "            nn.PReLU(),\n",
        "            nn.MaxPool2d(kernel_size=2, stride=2),\n",
        "            nn.Conv2d(in_channels=128, out_channels=32, kernel_size=3),\n",
        "            nn.PReLU(),\n",
        "            nn.MaxPool2d(kernel_size=2, stride=2)\n",
        "        )\n",
        "\n",
        "\n",
        "        # Define linear->PReLU->linear->PReLU->linear\n",
        "        # The first two linear layers should have 256 and 128 output nodes\n",
        "        # The final FC layer should have 2 nodes\n",
        "        self.fc =nn.Sequential(\n",
        "            nn.Linear(32, 256),\n",
        "            nn.PReLU(),\n",
        "            nn.Linear(256, 128),\n",
        "            nn.PReLU(),\n",
        "            nn.Linear(128, 2)\n",
        "        )\n",
        "\n",
        "        #### YOUR CODE ENDS HERE ####\n",
        "\n",
        "    def forward(self, x):\n",
        "      #### YOUR CODE STARTS HERE ####\n",
        "        # Define the forward pass, convnet -> Reshape -> fc\n",
        "        output = self.convnet(x)\n",
        "        output = output.view(output.size()[0], -1)\n",
        "        output = self.fc(output)\n",
        "        #### YOUR CODE ENDS HERE ####\n",
        "        return output"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 36,
      "metadata": {
        "id": "Ywj6s1xrAiqi"
      },
      "outputs": [],
      "source": [
        "class TripletNet(nn.Module):\n",
        "    def __init__(self, embedding_net):\n",
        "        super(TripletNet, self).__init__()\n",
        "        self.embedding_net = embedding_net\n",
        "\n",
        "    def forward(self, x1, x2, x3):\n",
        "      #### YOUR CODE STARTS HERE ####\n",
        "      # Call the embedding network for anchor, positive and negative samples (x1,x2,x3)\n",
        "        output1 = self.embedding_net(x1)\n",
        "        output2 = self.embedding_net(x2)\n",
        "        output3 = self.embedding_net(x3)\n",
        "      #### YOUR CODE ENDS HERE ####\n",
        "        return output1, output2, output3\n",
        "\n",
        "    def get_embedding(self, x):\n",
        "        return self.embedding_net(x)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 37,
      "metadata": {
        "id": "nxDUKVD1_JqE"
      },
      "outputs": [],
      "source": [
        "class TripletLoss(nn.Module):\n",
        "    \"\"\"\n",
        "    Triplet loss\n",
        "    Takes embeddings of an anchor sample, a positive sample and a negative sample\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, margin):\n",
        "        super(TripletLoss, self).__init__()\n",
        "        self.margin = margin\n",
        "\n",
        "    def forward(self, anchor, positive, negative, size_average=True):\n",
        "      #### YOUR CODE STARTS HERE ####\n",
        "        # Calculate the squared eucledian distance between anchor and positive sample\n",
        "        positive_distance = (anchor - positive).pow(2).sum(1)\n",
        "        # Calculate the squared eucledian distance between anchor and negative sample\n",
        "        negative_distance = (anchor - negative).pow(2).sum(1)\n",
        "      #### YOUR CODE ENDS HERE ####\n",
        "        losses = F.relu(positive_distance - negative_distance + self.margin)\n",
        "        return losses.mean() if size_average else losses.sum()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 38,
      "metadata": {
        "id": "ppTNLyiPDpqn"
      },
      "outputs": [],
      "source": [
        "margin = 1.\n",
        "embedding_net = EmbeddingNet()\n",
        "model = TripletNet(embedding_net)\n",
        "if cuda:\n",
        "    model.cuda()\n",
        "loss_fn = TripletLoss(margin)\n",
        "optimizer = optim.Adam(model.parameters(), lr=1e-3)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 39,
      "metadata": {
        "id": "mjM2ofUage9X"
      },
      "outputs": [],
      "source": [
        "def train_epoch(train_loader, model, loss_fn, optimizer, cuda):\n",
        "    model.train()\n",
        "    total_loss = 0\n",
        "\n",
        "    for batch_idx, (data, target) in enumerate(train_loader):\n",
        "        target = target if len(target) > 0 else None\n",
        "        if not type(data) in (tuple, list):\n",
        "            data = (data,)\n",
        "        if cuda:\n",
        "            data = tuple(d.cuda() for d in data)\n",
        "            if target is not None:\n",
        "                target = target.cuda()\n",
        "\n",
        "        optimizer.zero_grad()\n",
        "        outputs = model(*data)\n",
        "\n",
        "        if type(outputs) not in (tuple, list):\n",
        "            outputs = (outputs,)\n",
        "\n",
        "        loss_inputs = outputs\n",
        "        if target is not None:\n",
        "            target = (target,)\n",
        "            loss_inputs += target\n",
        "\n",
        "        loss_outputs = loss_fn(*loss_inputs)\n",
        "        loss = loss_outputs[0] if type(loss_outputs) in (tuple, list) else loss_outputs\n",
        "        total_loss += loss.item()\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "    total_loss /= (batch_idx + 1)\n",
        "    return total_loss"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 40,
      "metadata": {
        "id": "8fSErkFDgf5W"
      },
      "outputs": [],
      "source": [
        "def test_epoch(val_loader, model, loss_fn, cuda):\n",
        "    with torch.no_grad():\n",
        "        model.eval()\n",
        "        val_loss = 0\n",
        "        for batch_idx, (data, target) in enumerate(val_loader):\n",
        "            target = target if len(target) > 0 else None\n",
        "            if not type(data) in (tuple, list):\n",
        "                data = (data,)\n",
        "            if cuda:\n",
        "                data = tuple(d.cuda() for d in data)\n",
        "                if target is not None:\n",
        "                    target = target.cuda()\n",
        "\n",
        "            outputs = model(*data)\n",
        "\n",
        "            if type(outputs) not in (tuple, list):\n",
        "                outputs = (outputs,)\n",
        "            loss_inputs = outputs\n",
        "            if target is not None:\n",
        "                target = (target,)\n",
        "                loss_inputs += target\n",
        "\n",
        "            loss_outputs = loss_fn(*loss_inputs)\n",
        "            loss = loss_outputs[0] if type(loss_outputs) in (tuple, list) else loss_outputs\n",
        "            val_loss += loss.item()\n",
        "\n",
        "\n",
        "\n",
        "    return val_loss"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 41,
      "metadata": {
        "id": "M1cPjWocgycA"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "Epoch: 1/2. Training: Average loss: 0.1678\n",
            "\n",
            "Epoch: 1/2. Testing: Average loss: 0.0929\n",
            "\n",
            "Epoch: 2/2. Training: Average loss: 0.0658\n",
            "\n",
            "Epoch: 2/2. Testing: Average loss: 0.0496\n"
          ]
        }
      ],
      "source": [
        "n_epochs=2\n",
        "for epoch in range(n_epochs):\n",
        "        train_loss= train_epoch(triplet_train_loader, model, loss_fn, optimizer, cuda)\n",
        "        print('\\nEpoch: {}/{}. Training: Average loss: {:.4f}'.format(epoch + 1, n_epochs, train_loss))\n",
        "        test_loss= test_epoch(triplet_test_loader, model, loss_fn, cuda)\n",
        "        test_loss /= len(triplet_test_loader)\n",
        "        print('\\nEpoch: {}/{}. Testing: Average loss: {:.4f}'.format(epoch + 1, n_epochs,test_loss))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RVHDOS1HCHXo"
      },
      "source": [
        "## Question 1:\n",
        "\n",
        "What is the average test loss obtained after training MNIST on triplet loss for two epochs ?\n",
        "\n",
        "a) 0.1676 \\\\\n",
        "b) 0.0860 \\\\\n",
        "c) 0.0669 \\\\\n",
        "d) 0.0538"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aokdJpS0cUk6"
      },
      "source": [
        "We will next create a function that will calculate the IOU given a ground truth box and a predicted box according to the formula as shown below\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mVYcVVFtcxQP"
      },
      "source": [
        "![nptel_2.png](data:image/png;base64,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)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DTWbvIMQwFn3"
      },
      "source": [
        "IOU is calculated as follows\n",
        "\n",
        "1. Calculate the area of intersection, height * width \\(as bounding box is a rectangle/)\n",
        "\n",
        "2. Calculate the area of union as follows area\\_union = groundtruth\\_area + predicted\\_area - area of intersection\n",
        "\n",
        "3. Calculate the IOU value and store it in the variable 'iou'"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "rBVp_WDxbtvL"
      },
      "outputs": [],
      "source": [
        "def get_iou(ground_truth, pred):\n",
        "\n",
        "    ix1 = np.maximum(ground_truth[0], pred[0])\n",
        "    iy1 = np.maximum(ground_truth[1], pred[1])\n",
        "    ix2 = np.minimum(ground_truth[2], pred[2])\n",
        "    iy2 = np.minimum(ground_truth[3], pred[3])\n",
        "\n",
        "    ## YOUR CODE STARTS HERE ##\n",
        "\n",
        "    # Calculate area of intersection\n",
        "    i_height = iy2-iy1+1\n",
        "    i_width = ix2-ix1+1\n",
        "    area_of_intersection = i_height*i_width\n",
        "\n",
        "    # Calculate Ground Truth Height and Width\n",
        "    gt_height = ground_truth[2]-ground_truth[0]+1\n",
        "    gt_width = ground_truth[3]-ground_truth[1]+1\n",
        "\n",
        "    # Calculate Predicted Height and Width\n",
        "    pd_height = pred[2]-pred[0]+1\n",
        "    pd_width = pred[3]-pred[1]+1\n",
        "\n",
        "    # Calculate Area of Union\n",
        "    area_of_union = gt_height*gt_width + pd_height*pd_width - area_of_intersection\n",
        "\n",
        "    # Calculate iou\n",
        "    iou = area_of_intersection/area_of_union\n",
        "\n",
        "    ## YOUR CODE ENDS HERE ##\n",
        "    return iou"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "QhMfA9tbb07T"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "IOU:  0.43389307076627287\n"
          ]
        }
      ],
      "source": [
        "\n",
        "ground_truth_bbox = np.array([1100, 113, 1450, 768], dtype=np.float32)\n",
        "\n",
        "prediction_bbox = np.array([1262.0001, 102.0021, 1519.9832, 794.0033], dtype=np.float32)\n",
        "\n",
        "iou = get_iou(ground_truth_bbox, prediction_bbox)\n",
        "print('IOU: ', iou)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O6HuofmmvzrJ"
      },
      "source": [
        "## Question 2\n",
        "\n",
        "What is the IOU of the given ground truth and predicted bounding box? (Rounded off to 4 digits)\n",
        "\n",
        "a) 0.4339 \\\\\n",
        "b) 0.4353 \\\\\n",
        "c) 0.4354 \\\\\n",
        "d) 0.4369"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PVr-wObinzBb"
      },
      "source": [
        "\n",
        "\n",
        "We will implement Multi-Task Loss for Fast R-CNN by extending the nn class of pythorch. Given the predicted logits, one-hot encoding of actual class labels, ground truth bounding box regression targets and predicted bounding box regression offsets it should return the loss value\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 43,
      "metadata": {
        "id": "MaoqISqkpV7K"
      },
      "outputs": [],
      "source": [
        "class MultiTaskLoss(nn.Module):\n",
        "\n",
        "    def __init__(self, alpha = 0.1):\n",
        "        super().__init__()\n",
        "        self.alpha = alpha\n",
        "        #### YOUR CODE STARTS HERE ####\n",
        "        # Initialize a SmoothL1Loss function from the nn class of pytorch with 'sum' as reduction parameter\n",
        "        self.smooth_l1_loss = nn.SmoothL1Loss(reduction='sum')\n",
        "        #### YOUR CODE ENDS HERE ####\n",
        "\n",
        "    def forward(self, pred_logits, true_class, bounding_box_offsets, bounding_box_target): # refer the later code for interpretation of the params\n",
        "        #### YOUR CODE STARTS HERE ####\n",
        "        # Calculate predicted class probabilities by taking softmax of predicted logits\n",
        "        pred = torch.softmax(pred_logits, dim=-1)\n",
        "\n",
        "        # Calculate the classification loss(Cross Entropy)\n",
        "        true_class_index = torch.argmax(true_class)  #index of the true class\n",
        "        L_cls = -torch.log(pred[true_class_index])  #classification loss\n",
        "\n",
        "        # Get the bounding box regression offsets for true class\n",
        "        t_u = bounding_box_offsets[true_class_index]\n",
        "        L_loc = 0  # Localization Loss\n",
        "        # Calculate localization loss only for non background class\n",
        "        if true_class_index > 0: # give appropiate condition\n",
        "          # Calculate the localization loss(smooth L1 loss) between the true bounding box regression targets\n",
        "          # and the bounding box offsets computed above while applying the smooth_l1_loss function initialised above\n",
        "          L_loc = self.smooth_l1_loss(bounding_box_target, t_u)\n",
        "\n",
        "        # Calculate the Multi Task loss from the two losses while using alpha as the scaling factor for the localization loss\n",
        "        Loss = L_cls + self.alpha * L_loc\n",
        "        #### YOUR CODE ENDS HERE ####\n",
        "        return Loss"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 44,
      "metadata": {
        "id": "0lVF6l-3F13s"
      },
      "outputs": [],
      "source": [
        "# create an object of MultiTaskLoss\n",
        "mt_loss=MultiTaskLoss(alpha = 0.01)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 45,
      "metadata": {
        "id": "Xk_fkUWM89IV"
      },
      "outputs": [],
      "source": [
        "# Assume predicted are the predicted logits\n",
        "predicted_logits=torch.tensor([1.4315, 2.9862, 0.4019, 1.5501])\n",
        "#One hot encoding of the true class\n",
        "true_class=torch.tensor([0., 1., 0., 0.])\n",
        "# Class wise predicted bounding box offsets\n",
        "bounding_box_offsets = torch.tensor([[25., 51., 82., 120.],[63., 42., 103., 75.],[158., 26., 94., 56.],[15., 86., 44., 80.]])\n",
        "# Bounding box regression target\n",
        "bounding_box_target = torch.tensor([58., 35., 108., 81.])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 46,
      "metadata": {
        "id": "U3tW2GwAFmZa"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "tensor(0.6317)\n"
          ]
        }
      ],
      "source": [
        "# Calculate multi task loss based on the above values\n",
        "# Use the MultiTaskLossMultiTaskLoss object created above\n",
        "# Print the value\n",
        "print(mt_loss(predicted_logits,true_class, bounding_box_offsets, bounding_box_target))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UKU4IRvwmK6D"
      },
      "source": [
        "## Question 3:\n",
        "\n",
        "What is the value of the multi-task loss obtained above ?\n",
        "\n",
        "a) 0.6317 \\\\\n",
        "b) 0.7329 \\\\\n",
        "c) 1.0435 \\\\\n",
        "d) 0.8226\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q1YdHk_gdsdP"
      },
      "source": [
        "# WEEK 8"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eAEAWaXWeC5l"
      },
      "source": [
        "**Welcome to Assignment 8 on Deep Learning for Computer Vision.**\n",
        "\n",
        "This assignment is based on the content you learned in Week-8 of the course.\n",
        "\n",
        "\n",
        "#### **Instructions**\n",
        "1. Use Python 3.x to run this notebook\n",
        "2. Write your code only in between the lines 'YOUR CODE STARTS HERE' and 'YOUR CODE ENDS HERE'. You should not change anything else in the code cells. If you do, the answers you are supposed to get at the end of this assignment might be wrong.\n",
        "3. Read documentation of each function carefully.\n",
        "4. All the Best!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BtNaqMjcX8Nn"
      },
      "source": [
        "In this assignment, we will be fitting an LSTM to a cosine wave."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "Ow8qf6dxrGgA"
      },
      "outputs": [],
      "source": [
        "# Please DO NOT modify this cell.\n",
        "\n",
        "import os\n",
        "import os.path as osp\n",
        "import random\n",
        "\n",
        "import numpy as np\n",
        "import torch\n",
        "\n",
        "def set_seed(seed: int):\n",
        "\n",
        "    random.seed(seed)\n",
        "    np.random.seed(seed)\n",
        "    torch.manual_seed(seed)\n",
        "    if torch.cuda.is_available():\n",
        "        torch.cuda.manual_seed(seed)\n",
        "        torch.cuda.manual_seed_all(seed)\n",
        "        torch.backends.cudnn.deterministic = True\n",
        "        torch.backends.cudnn.benchmark = False\n",
        "    os.environ[\"PYTHONHASHSEED\"] = str(seed)\n",
        "\n",
        "set_seed(1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "reH70kE4XgxA"
      },
      "outputs": [],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import torch.nn as nn"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TbmCW28UrGgJ"
      },
      "source": [
        "## Prepare the training and testing dataset."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "6Rl7DeDfrGgL",
        "scrolled": true
      },
      "outputs": [],
      "source": [
        "# Please DO NOT modify this cell.\n",
        "\n",
        "def get_data():\n",
        "\n",
        "    train_x = np.arange(0, 100, 0.5)\n",
        "    train_data = np.cos(train_x)\n",
        "\n",
        "    test_x = np.arange(100, 200, 0.5)\n",
        "    test_data = np.cos(test_x)\n",
        "\n",
        "    return train_x, train_data, test_x, test_data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "912YarlQrGgO"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 2000x400 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Please DO NOT modify this cell.\n",
        "\n",
        "train_x, train_data, test_x, test_data = get_data()\n",
        "\n",
        "plt.figure(figsize = (20, 4))\n",
        "plt.plot(train_x, train_data, label = 'Train')\n",
        "plt.plot(test_x, test_data, label = 'Test')\n",
        "\n",
        "plt.legend(loc = \"lower left\")\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "VpTC-g2YrGgU"
      },
      "outputs": [],
      "source": [
        "# Please DO NOT modify this cell.\n",
        "\"\"\"\n",
        "Functions for creating sliding windows from the data, this is a useful function\n",
        "to understand for any time-series prediction task\n",
        "\"\"\"\n",
        "\n",
        "def sliding_windows(data, seq_length):\n",
        "\n",
        "    x = []\n",
        "    y = []\n",
        "\n",
        "    for i in range(len(data)-seq_length-1):\n",
        "        _x = data[i:(i+seq_length)]\n",
        "        _y = data[i+seq_length]\n",
        "        x.append(_x)\n",
        "        y.append(_y)\n",
        "\n",
        "    return np.array(x), np.array(y)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "tkk_eNLJrGgX"
      },
      "outputs": [],
      "source": [
        "# Please DO NOT modify this cell.\n",
        "\n",
        "\"\"\"\n",
        "Create sliding windows\n",
        "\"\"\"\n",
        "\n",
        "seq_length = 5\n",
        "x_train, y_train = sliding_windows(train_data, seq_length)\n",
        "x_test, y_test = sliding_windows(test_data, seq_length)\n",
        "\n",
        "x_train = torch.Tensor(x_train)\n",
        "y_train = torch.Tensor(y_train).reshape(-1, 1)\n",
        "\n",
        "x_test = torch.Tensor(x_test)\n",
        "y_test = torch.Tensor(y_test).reshape(-1, 1)\n",
        "\n",
        "x_train = x_train[:, :, np.newaxis]\n",
        "x_test = x_test[:, :, np.newaxis]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6-fbsv6_xVhu"
      },
      "source": [
        "## Create the model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "KC_5L1NIxUsR"
      },
      "outputs": [],
      "source": [
        "class LSTM(nn.Module):\n",
        "\n",
        "    def __init__(self, num_classes, input_size, hidden_size, num_layers):\n",
        "        super(LSTM, self).__init__()\n",
        "\n",
        "        self.num_classes = num_classes\n",
        "        self.num_layers = num_layers\n",
        "        self.input_size = input_size\n",
        "        self.hidden_size = hidden_size\n",
        "\n",
        "        #### YOUR CODE STARTS HERE ####\n",
        "\n",
        "        # Define a LSTM block and a Linear block\n",
        "        # Set batch_first = True\n",
        "\n",
        "        self.lstm = nn.LSTM(input_size=input_size, hidden_size=hidden_size, num_layers=num_layers, batch_first = True)\n",
        "\n",
        "        self.fc = nn.Linear(in_features=hidden_size, out_features=num_classes)\n",
        "\n",
        "        #### YOUR CODE ENDS HERE ####\n",
        "\n",
        "    def forward(self, x):\n",
        "\n",
        "        #### YOUR CODE STARTS HERE ####\n",
        "\n",
        "        # Propagate input through LSTM\n",
        "\n",
        "\n",
        "        output, (hidden_out, cell_out) = self.lstm(x)\n",
        "\n",
        "        # Flatten hidden_out and pass it through fc layer\n",
        "\n",
        "        hidden_out = hidden_out.view(-1, self.hidden_size) #torch.flatten(hidden_out)\n",
        "        out = self.fc(hidden_out)\n",
        "\n",
        "        #### YOUR CODE ENDS HERE ####\n",
        "\n",
        "        return out"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sQKOnThFxxuJ"
      },
      "source": [
        "## Training"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "vlj9F1Z6xxFR"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch 10/350, loss: 0.53\n",
            "Epoch 20/350, loss: 0.51\n",
            "Epoch 30/350, loss: 0.50\n",
            "Epoch 40/350, loss: 0.49\n",
            "Epoch 50/350, loss: 0.48\n",
            "Epoch 60/350, loss: 0.47\n",
            "Epoch 70/350, loss: 0.46\n",
            "Epoch 80/350, loss: 0.45\n",
            "Epoch 90/350, loss: 0.44\n",
            "Epoch 100/350, loss: 0.43\n",
            "Epoch 110/350, loss: 0.42\n",
            "Epoch 120/350, loss: 0.41\n",
            "Epoch 130/350, loss: 0.40\n",
            "Epoch 140/350, loss: 0.39\n",
            "Epoch 150/350, loss: 0.37\n",
            "Epoch 160/350, loss: 0.35\n",
            "Epoch 170/350, loss: 0.33\n",
            "Epoch 180/350, loss: 0.30\n",
            "Epoch 190/350, loss: 0.27\n",
            "Epoch 200/350, loss: 0.24\n",
            "Epoch 210/350, loss: 0.21\n",
            "Epoch 220/350, loss: 0.17\n",
            "Epoch 230/350, loss: 0.14\n",
            "Epoch 240/350, loss: 0.11\n",
            "Epoch 250/350, loss: 0.08\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch 260/350, loss: 0.06\n",
            "Epoch 270/350, loss: 0.05\n",
            "Epoch 280/350, loss: 0.03\n",
            "Epoch 290/350, loss: 0.03\n",
            "Epoch 300/350, loss: 0.02\n",
            "Epoch 310/350, loss: 0.01\n",
            "Epoch 320/350, loss: 0.01\n",
            "Epoch 330/350, loss: 0.01\n",
            "Epoch 340/350, loss: 0.01\n",
            "Epoch 350/350, loss: 0.01\n"
          ]
        }
      ],
      "source": [
        "num_epochs = 350\n",
        "learning_rate = 0.001\n",
        "\n",
        "input_size = 1\n",
        "hidden_size = 4\n",
        "num_layers = 1\n",
        "\n",
        "num_classes = 1\n",
        "\n",
        "# Define LSTM model\n",
        "lstm_model = LSTM(num_classes, input_size, hidden_size, num_layers)\n",
        "\n",
        "# Set MSE loss as criterion\n",
        "criterion = torch.nn.MSELoss()\n",
        "\n",
        "# Use Adam optimizer\n",
        "optimizer = torch.optim.Adam(lstm_model.parameters(), lr = learning_rate)\n",
        "\n",
        "# Train the model\n",
        "\n",
        "for epoch in range(1, num_epochs+1):\n",
        "\n",
        "    #### YOUR CODE STARTS HERE ####\n",
        "\n",
        "    # Pass x_train as input to the lstm network\n",
        "    train_predict = lstm_model(x_train)\n",
        "\n",
        "    # Clear gradients in the optimizer\n",
        "    optimizer.zero_grad()\n",
        "\n",
        "    # Calculate loss using criterion function\n",
        "    loss = criterion(train_predict, y_train)\n",
        "\n",
        "    # Calculate gradients with respect to the loss\n",
        "    loss.backward()\n",
        "\n",
        "    # Update parameters\n",
        "    optimizer.step()\n",
        "\n",
        "    #### YOUR CODE ENDS HERE ####\n",
        "\n",
        "    if epoch % 10 == 0:\n",
        "        print(f\"Epoch {epoch}/{num_epochs}, loss: {loss.item():.2f}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "JvEkSzwjrGgo"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "117\n"
          ]
        }
      ],
      "source": [
        "print(sum(p.numel() for p in lstm_model.parameters()))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hxBMnRiMapJk"
      },
      "source": [
        "## Question 4:\n",
        "\n",
        "How many parameters are there in the model?\n",
        "\n",
        "a) 117 \\\\\n",
        "b) 234 \\\\\n",
        "c) 115 \\\\\n",
        "d) 236 \\\\\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "YucaWnbcrGgv"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Test Loss: 0.0059\n"
          ]
        }
      ],
      "source": [
        "lstm_model.eval()\n",
        "\n",
        "with torch.no_grad():\n",
        "    pred = lstm_model(x_test)\n",
        "\n",
        "test_loss = criterion(pred, y_test)\n",
        "print(f\"Test Loss: {test_loss.item():.4f}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1DOKPz6irGgu"
      },
      "source": [
        "## Question 5:\n",
        "\n",
        "What is the mean squared error loss on the test set? (select the nearest value)\n",
        "\n",
        "a) 0.2187 \\\\\n",
        "b) 0.0059 \\\\\n",
        "c) 1.9696 \\\\\n",
        "d) 0.5497\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fud8udFhx4e1"
      },
      "source": [
        "We will now create function that calculates the GRU cell operations as shown below"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LnXrUjaXSHL3"
      },
      "source": [
        "![nptel_1.png](data:image/png;base64,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)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "f8EBTB2uR_rQ"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import torch\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "wqXytOsrSWpa"
      },
      "outputs": [],
      "source": [
        "## DO NOT CHANGE THIS ##\n",
        "h_size = 20\n",
        "N = 60\n",
        "\n",
        "torch.manual_seed(0)\n",
        "\n",
        "Wz = torch.rand((h_size, N))\n",
        "\n",
        "Wr = torch.rand((h_size, N))\n",
        "\n",
        "Wh = torch.rand((h_size, N))\n",
        "\n",
        "x = torch.randn((40, 1))\n",
        "h_prev = torch.randn((20,1))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JNBwdpsYyRXw"
      },
      "source": [
        "Step 1: Append the h_prev and input x  along the row dimension.\n",
        "\n",
        "Step 2: Calculate zt as shown in the above equation using sigmoid function and matrix multiplication and store it in variable 'z'\n",
        "\n",
        "Step 3: Calculate rt as shown in the above equation using sigmoid function and matrix multiplication and store it in variable 'r'\n",
        "\n",
        "Step 4: Calculate h_hat using tanh function as shown in third equation in the above picture and also make sure you perform elementwise mutliplication of r and h_prev before appending this to input x\n",
        "\n",
        "Step 5: Calculate ht as shown in the last equation of the above picture, using elemetwise multiplication operation, and store it in the variable 'h_t'"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 42,
      "metadata": {
        "id": "sxAajJo6TsCe"
      },
      "outputs": [],
      "source": [
        "## YOUR CODE STARTS HERE##\n",
        "\n",
        "input = torch.cat((h_prev, x))\n",
        "\n",
        "z = torch.sigmoid(torch.matmul(Wz, input))\n",
        "\n",
        "r = torch.sigmoid(torch.matmul(Wr, input))\n",
        "\n",
        "# Concat x with elementwise multiplication of r and h_prev and store in temp.\n",
        "temp = torch.cat((x, r * h_prev))\n",
        "\n",
        "h_hat = torch.tanh(torch.matmul(Wh, temp))\n",
        "\n",
        "h_t = (1 - z) * h_prev + z * h_hat\n",
        "\n",
        "## YOUR CODE ENDS HERE"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 43,
      "metadata": {
        "id": "tqLK9p47Vgi1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "tensor(-0.3015)\n"
          ]
        }
      ],
      "source": [
        "print(torch.mean(h_t))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4RLGfa6RbV7U"
      },
      "source": [
        "## Question 6\n",
        "\n",
        "What is the mean of the above h_t tensor?\n",
        "\n",
        "a) -0.3914 \\\\\n",
        "b) -0.3051 \\\\\n",
        "c) -0.3015 \\\\\n",
        "d) -0.3593"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {},
      "outputs": [],
      "source": [
        "def softmax(x):\n",
        "    return np.exp(x) / np.sum(np.exp(x), axis=0)\n",
        "\n",
        "def sigmoid(x):\n",
        "    return 1 / (1 + np.exp(-x))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 72,
      "metadata": {},
      "outputs": [],
      "source": [
        "X1 = np.array([5, 6])\n",
        "X2 = np.array([7, 8])\n",
        "X3 = np.array([-7, 9])\n",
        "\n",
        "U1 = np.array([[-1.3, 0.5, 0.2],\n",
        "              [1.4, -0.7, 1.3]])\n",
        "\n",
        "U2 = np.array([[-0.1, 1.5, 0.2, 0.4],\n",
        "              [2.4, 1.7, 1.3, 0.5],\n",
        "              [-1.7, 0.1, 0.3, 0.6]])\n",
        "\n",
        "V1 = np.array([[-0.1, 1.5, 0.2],\n",
        "              [0.4, -1.7, -1.3],\n",
        "              [-1.8, 1.1, 1.3]])\n",
        "\n",
        "V2 = np.array([[-0.1, 1.5, 0.7, 0.4],\n",
        "              [-1.4, -1.8, -0.3, 0.5],\n",
        "              [-1.8, 1.2, 0.3, 0.6],\n",
        "              [-1.4, 1.8, -0.7, 0.2]])\n",
        "\n",
        "W = np.array([[-1.1, 1.7, 0.3],\n",
        "              [-1.2, -0.8, 0.4],\n",
        "              [-1.7, -1.2, 0.5],\n",
        "              [-2.1, 0.2, 0.6]])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 73,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([0.16155463, 0.08042147, 0.7580239 ])"
            ]
          },
          "execution_count": 73,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "layer1_in = []\n",
        "layer1_out = []\n",
        "layer2_in = []\n",
        "layer2_out = []\n",
        "\n",
        "layer1_in = [X1 @ U1, X2 @ U1, X3 @ U1]\n",
        "\n",
        "# layer1_out.append(np.tanh((layer1_in[0]+0) @ V1))\n",
        "# for i in range(1, 3):\n",
        "#     layer1_out.append(np.tanh((layer1_in[i] + layer1_out[i-1]) @ V1))\n",
        "\n",
        "layer1_out.append(np.tanh((layer1_in[0])))\n",
        "for i in range(1, 3):\n",
        "    layer1_out.append(np.tanh((layer1_in[i] + layer1_out[i-1] @ V1)))\n",
        "\n",
        "\n",
        "layer2_in = [layer1_out[0] @ U2, layer1_out[1] @ U2, layer1_out[2] @ U2]\n",
        "\n",
        "# layer2_out.append(np.tanh((layer2_in[0]+0) @ V2))\n",
        "# for i in range(1, 3):\n",
        "#     layer2_out.append(np.tanh((layer2_in[i] + layer2_out[i-1]) @ V2))\n",
        "\n",
        "layer2_out.append(np.tanh((layer2_in[0])))\n",
        "for i in range(1, 3):\n",
        "    layer2_out.append(np.tanh((layer2_in[i] + layer2_out[i-1] @ V2)))\n",
        "\n",
        "output = softmax(layer2_out[2] @ W)\n",
        "output"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 74,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(0.9677045353015495,\n",
              " 0.03557118927263617,\n",
              " 0.11920292202211755,\n",
              " -0.9981778976111987,\n",
              " -0.5193586425744647,\n",
              " -0.056884213612821345)"
            ]
          },
          "execution_count": 74,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "input = np.array([2, 7])\n",
        "W_f = np.array([0.2, 0.4])\n",
        "b_f = 0.2\n",
        "W_i = np.array([-0.1, -0.3])\n",
        "b_i = -1\n",
        "W_o = np.array([-0.4, -0.6])\n",
        "b_o = 3\n",
        "W_c = np.array([5, -2])\n",
        "b_c = 0.5\n",
        "C = -0.5\n",
        "\n",
        "f_t = sigmoid(input @ W_f + b_f)\n",
        "i_t = sigmoid(input @ W_i + b_i)\n",
        "o_t = sigmoid(input @ W_o + b_o)\n",
        "c_t = np.tanh(input @ W_c + b_c)\n",
        "C_t = f_t * C + i_t * c_t\n",
        "h_t = o_t * np.tanh(C_t)\n",
        "\n",
        "f_t, i_t, o_t, c_t, C_t, h_t"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 80,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(0.9677045353015495,\n",
              " 0.016302499371440946,\n",
              " -0.9983475469261701,\n",
              " -1.0629918430629828)"
            ]
          },
          "execution_count": 80,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "input = np.array([-3, 5])\n",
        "W_z = np.array([1.2, 1.4])\n",
        "W_r = np.array([-1.3, -1.6])\n",
        "W = np.array([-1, -0.7])\n",
        "\n",
        "z_t = sigmoid(input @ W_z)\n",
        "r_t = sigmoid(input @ W_r)\n",
        "h_t_tilda = np.tanh(np.array([r_t*3, 5]) @ W)\n",
        "h_t = (1-z_t) * -3 + z_t * h_t_tilda\n",
        "\n",
        "z_t, r_t, h_t_tilda, h_t"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 79,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "0.9677045353015494"
            ]
          },
          "execution_count": 79,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "sigmoid(3.4)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "0.4"
            ]
          },
          "execution_count": 30,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "np.round(0.3999999, 3)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "0.4399"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "gpuType": "T4",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "torch",
      "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.11.4"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}