Classification_Pipeline.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/JNPauli/GenericObjectDecoding/blob/master/Classification_Pipeline.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f3485813"
      },
      "source": [
        "0. This notebook is the continuation to the preprocessing.ipynb notebook."
      ],
      "id": "f3485813"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b60fcc27"
      },
      "source": [
        "1. Import all neccessary modules "
      ],
      "id": "b60fcc27"
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "73af1d9d"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "from sklearn.model_selection import train_test_split\n",
        "import gc"
      ],
      "id": "73af1d9d"
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xwWpOPN-SkYk",
        "outputId": "43b97a57-ae36-48b1-8f44-997fcd499d85"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ],
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "id": "xwWpOPN-SkYk"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0bab0d03"
      },
      "source": [
        "2. Import X and y"
      ],
      "id": "0bab0d03"
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "0e61570a"
      },
      "outputs": [],
      "source": [
        "import torchvision\n",
        "from torchvision import transforms\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "from torch.utils.data import Dataset, DataLoader\n",
        "from PIL import Image"
      ],
      "id": "0e61570a"
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "Q822x4HZTzzr"
      },
      "outputs": [],
      "source": [
        "os.chdir('/content/drive/MyDrive/Thesis')"
      ],
      "id": "Q822x4HZTzzr"
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "99428f03"
      },
      "outputs": [],
      "source": [
        "y = np.load('train_con.npy')"
      ],
      "id": "99428f03"
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "986e4ca0"
      },
      "outputs": [],
      "source": [
        "y_ = y[0:10000]\n",
        "y_frames = y[14276:]"
      ],
      "id": "986e4ca0"
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "hkGr-adRJKPY"
      },
      "outputs": [],
      "source": [
        "y_all = np.concatenate((y_,y_frames))"
      ],
      "id": "hkGr-adRJKPY"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "daf7012a"
      },
      "source": [
        "NEW APPROACH:\n",
        "\n",
        "Fit CNN on X"
      ],
      "id": "daf7012a"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4fdc2364"
      },
      "source": [
        "1. Read `n-rows`from X."
      ],
      "id": "4fdc2364"
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "r367TL-IeTgB",
        "outputId": "b75c8ba9-ef38-40ca-93d8-171877baec85"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "cuda\n"
          ]
        }
      ],
      "source": [
        "if torch.cuda.is_available():\n",
        "  device = torch.device(\"cuda\")\n",
        "else:\n",
        "  device = torch.device(\"cpu\")\n",
        "\n",
        "print(device)"
      ],
      "id": "r367TL-IeTgB"
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "27e2352f"
      },
      "outputs": [],
      "source": [
        "X = np.load('X_npy.npy')"
      ],
      "id": "27e2352f"
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "PsyUuoBPLir0"
      },
      "outputs": [],
      "source": [
        "X_train_,X_test_,y_train_,y_test_ = train_test_split(X,y_,test_size=0.2,random_state=42)"
      ],
      "id": "PsyUuoBPLir0"
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eKWPUYNJJPA6",
        "outputId": "ce82ed23-ad84-48e7-f5e0-ec0e22c457be"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "22"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ],
      "source": [
        "del X,y_\n",
        "gc.collect()"
      ],
      "id": "eKWPUYNJJPA6"
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "dr2axO3gX8gV"
      },
      "outputs": [],
      "source": [
        "X_train_, X_val_, y_train_, y_val_ = train_test_split(X_train_,y_train_, test_size = 0.2,random_state=42)"
      ],
      "id": "dr2axO3gX8gV"
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "id": "m6MUfvXMLxdU"
      },
      "outputs": [],
      "source": [
        "X_frames = np.load('frames_npy.npy')"
      ],
      "id": "m6MUfvXMLxdU"
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "id": "Eokk-SMBLyv1"
      },
      "outputs": [],
      "source": [
        "X_train_f,X_test_f,y_train_f,y_test_f = train_test_split(X_frames,y_frames,test_size=0.2,random_state=42)"
      ],
      "id": "Eokk-SMBLyv1"
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "g4rrcEI-L7lO",
        "outputId": "469c5e19-e474-4c11-db84-e0ea6583c488"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "11"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ],
      "source": [
        "del X_frames,y_frames\n",
        "gc.collect()"
      ],
      "id": "g4rrcEI-L7lO"
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "id": "J0CTpvPgzB9e"
      },
      "outputs": [],
      "source": [
        "X_train_f, X_val_f, y_train_f, y_val_f = train_test_split(X_train_f,y_train_f, test_size = 0.2,random_state=42)"
      ],
      "id": "J0CTpvPgzB9e"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "43fc4d4d"
      },
      "source": [
        "Converting X to appropriate Datatype..."
      ],
      "id": "43fc4d4d"
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "95e21cb9",
        "outputId": "900911e6-5324-4357-b533-1225df6b85bf"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ],
      "source": [
        "X_tensor_train = torch.from_numpy(X_train_)\n",
        "del X_train_\n",
        "gc.collect()\n",
        "X_tensor_test = torch.from_numpy(X_test_)\n",
        "del X_test_\n",
        "gc.collect()\n",
        "X_tensor_val = torch.from_numpy(X_val_)\n",
        "del X_val_\n",
        "gc.collect()\n",
        "\n",
        "y_tensor_train = torch.from_numpy(y_train_)\n",
        "del y_train_\n",
        "gc.collect()\n",
        "y_tensor_test = torch.from_numpy(y_test_)\n",
        "del y_test_\n",
        "gc.collect()\n",
        "y_tensor_val = torch.from_numpy(y_val_)\n",
        "del y_val_\n",
        "gc.collect()"
      ],
      "id": "95e21cb9"
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "83ce427f",
        "outputId": "efb310ff-0e6c-489d-9174-e23e925f286c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-18-3ff54277ee2f>:1: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
            "  X_tensor_train = torch.tensor(X_tensor_train,dtype = torch.float32)\n",
            "<ipython-input-18-3ff54277ee2f>:2: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
            "  X_tensor_test = torch.tensor(X_tensor_test,dtype = torch.float32)\n",
            "<ipython-input-18-3ff54277ee2f>:3: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
            "  X_tensor_val = torch.tensor(X_tensor_val,dtype=torch.float32)\n"
          ]
        }
      ],
      "source": [
        "X_tensor_train = torch.tensor(X_tensor_train,dtype = torch.float32)\n",
        "X_tensor_test = torch.tensor(X_tensor_test,dtype = torch.float32)\n",
        "X_tensor_val = torch.tensor(X_tensor_val,dtype=torch.float32)\n",
        "\n",
        "y_tensor_train = y_tensor_train.type(torch.LongTensor)\n",
        "y_tensor_test = y_tensor_test.type(torch.LongTensor)\n",
        "y_tensor_val = y_tensor_val.type(torch.LongTensor)"
      ],
      "id": "83ce427f"
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "axPSV66iP70K",
        "outputId": "798b32e9-cb3a-48b3-c949-6e6d1305880a"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ],
      "source": [
        "X_tensor_train_ = torch.from_numpy(X_train_f)\n",
        "del X_train_f\n",
        "gc.collect()\n",
        "X_tensor_test_ = torch.from_numpy(X_test_f)\n",
        "del X_test_f\n",
        "gc.collect()\n",
        "X_tensor_val_ = torch.from_numpy(X_val_f)\n",
        "del X_val_f\n",
        "gc.collect()\n",
        "\n",
        "y_tensor_train_ = torch.from_numpy(y_train_f)\n",
        "del y_train_f\n",
        "gc.collect()\n",
        "y_tensor_test_ = torch.from_numpy(y_test_f)\n",
        "del y_test_f\n",
        "gc.collect()\n",
        "y_tensor_val_ = torch.from_numpy(y_val_f)\n",
        "del y_val_f\n",
        "gc.collect()"
      ],
      "id": "axPSV66iP70K"
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cu02Y4zGP721",
        "outputId": "2fce9a56-f82b-4d3a-af8f-6797b0a478e8"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-20-daeb6c2c99f4>:1: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
            "  X_tensor_train_ = torch.tensor(X_tensor_train_,dtype = torch.float32)\n",
            "<ipython-input-20-daeb6c2c99f4>:2: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
            "  X_tensor_test_ = torch.tensor(X_tensor_test_,dtype = torch.float32)\n",
            "<ipython-input-20-daeb6c2c99f4>:3: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
            "  X_tensor_val = torch.tensor(X_tensor_val_,dtype=torch.float32)\n"
          ]
        }
      ],
      "source": [
        "X_tensor_train_ = torch.tensor(X_tensor_train_,dtype = torch.float32)\n",
        "X_tensor_test_ = torch.tensor(X_tensor_test_,dtype = torch.float32)\n",
        "X_tensor_val = torch.tensor(X_tensor_val_,dtype=torch.float32)\n",
        "\n",
        "y_tensor_train_ = y_tensor_train_.type(torch.LongTensor)\n",
        "y_tensor_test_ = y_tensor_test_.type(torch.LongTensor)\n",
        "y_tensor_val = y_tensor_val_.type(torch.LongTensor)"
      ],
      "id": "cu02Y4zGP721"
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "id": "6YgbQB1WP8Gb"
      },
      "outputs": [],
      "source": [
        "X_tensor_train = torch.cat((X_tensor_train,X_tensor_train_),0)\n",
        "X_tensor_test = torch.cat((X_tensor_test,X_tensor_test_),0)\n",
        "X_tensor_val = torch.cat((X_tensor_val, X_tensor_val_),0)\n",
        "\n",
        "y_tensor_train = torch.cat((y_tensor_train,y_tensor_train_),0)\n",
        "y_tensor_test = torch.cat((y_tensor_test,y_tensor_test_),0)\n",
        "y_tensor_val = torch.cat((y_tensor_val,y_tensor_val_),0)"
      ],
      "id": "6YgbQB1WP8Gb"
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "w3CAcuLCulnT",
        "outputId": "053cbf72-2977-4b4b-c16f-8b83fae01d34"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "training shape X is torch.Size([11102, 1, 224, 224]), validation shape is torch.Size([2352, 1, 224, 224]), test shape X istorch.Size([3470, 1, 224, 224])\n"
          ]
        }
      ],
      "source": [
        "print('training shape X is {}, validation shape is {}, test shape X is{}'.format(X_tensor_train.shape,X_tensor_val.shape,X_tensor_test.shape))"
      ],
      "id": "w3CAcuLCulnT"
    },
    {
      "cell_type": "markdown",
      "source": [
        "To get max value of classN-1"
      ],
      "metadata": {
        "id": "T2DjZNYUrFdA"
      },
      "id": "T2DjZNYUrFdA"
    },
    {
      "cell_type": "code",
      "source": [
        "y_tensor_train = y_tensor_train-1\n",
        "y_tensor_test = y_tensor_test-1\n",
        "y_tensor_val = y_tensor_val-1"
      ],
      "metadata": {
        "id": "eFGPr_GdqDwY"
      },
      "id": "eFGPr_GdqDwY",
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5379ae48"
      },
      "source": [
        "Setup custom dataset class"
      ],
      "id": "5379ae48"
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "id": "76e13d73"
      },
      "outputs": [],
      "source": [
        "class SimpleDataset(Dataset):\n",
        "    def __init__(self, X, y,transform=None):\n",
        "        self.X = X\n",
        "        self.y = y\n",
        "        self.transform = transforms.Compose([transforms.Normalize(torch.mean(X), torch.std(X))])\n",
        "        \n",
        "    def __len__(self):\n",
        "        return len(self.X)\n",
        "    \n",
        "    def __getitem__(self, idx):\n",
        "        X = self.X[idx]\n",
        "        y = self.y[idx]\n",
        "\n",
        "        if self.transform:\n",
        "          X = self.transform(X)\n",
        " \n",
        "        return X, y"
      ],
      "id": "76e13d73"
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "id": "af6a5a92"
      },
      "outputs": [],
      "source": [
        "dataset_train = SimpleDataset(X_tensor_train,y_tensor_train,transform=True)\n",
        "dataloader_train = DataLoader(dataset_train, batch_size=32, shuffle=True)\n",
        "\n",
        "dataset_val = SimpleDataset(X_tensor_val,y_tensor_val,transform=True)\n",
        "dataloader_val = DataLoader(dataset_val,batch_size=32)\n",
        "\n",
        "dataset_test = SimpleDataset(X_tensor_test,y_tensor_test,transform=True)\n",
        "dataloader_test = DataLoader(dataset_test, batch_size = 32)#,shuffle=True)\n"
      ],
      "id": "af6a5a92"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9c4df5ea"
      },
      "source": [
        "Setting up the CNN."
      ],
      "id": "9c4df5ea"
    },
    {
      "cell_type": "code",
      "execution_count": 41,
      "metadata": {
        "id": "c5b23ab6"
      },
      "outputs": [],
      "source": [
        "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(1, 32, 3)\n",
        "        self.batch = nn.BatchNorm2d(32)\n",
        "        #self.conv2 = nn.Conv2d(32,64,3) #remove layer\n",
        "        self.dropout1 = nn.Dropout(0.25)\n",
        "        self.dropout2 = nn.Dropout(0.25)\n",
        "        self.fc1 = nn.Linear(394272, 128)\n",
        "        #self.fc2 = nn.Linear(128,10)\n",
        "        self.Arousal = nn.Linear(128,10) #3\n",
        "        self.Valence = nn.Linear(128,10)\n",
        "        self.Dominance = nn.Linear(128,10)\n",
        "        self.pool = nn.MaxPool2d(2)\n",
        "        \n",
        "    def forward(self, x):\n",
        "        x = self.conv1(x)\n",
        "        x = self.batch(x)\n",
        "        x = F.relu(x)\n",
        "        #x = self.conv2(x)\n",
        "        #x = F.relu(x)\n",
        "        x = self.pool(x)\n",
        "        x = self.dropout1(x)\n",
        "        x = torch.flatten(x, 1)\n",
        "        x = self.fc1(x)\n",
        "        x = F.relu(x)\n",
        "        x = self.dropout2(x)\n",
        "        #x = self.fc2(x)\n",
        "        Arousal = self.Arousal(x)\n",
        "        Valence = self.Valence(x)\n",
        "        Dominance = self.Dominance(x)\n",
        "        return Arousal, Valence, Dominance \n",
        "#removed "
      ],
      "id": "c5b23ab6"
    },
    {
      "cell_type": "code",
      "execution_count": 42,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ad94c3ad",
        "outputId": "5f0b9737-6b7d-4310-c07a-baff701ee6ff"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "CNN(\n",
              "  (conv1): Conv2d(1, 32, kernel_size=(3, 3), stride=(1, 1))\n",
              "  (batch): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "  (dropout1): Dropout(p=0.25, inplace=False)\n",
              "  (dropout2): Dropout(p=0.25, inplace=False)\n",
              "  (fc1): Linear(in_features=394272, out_features=128, bias=True)\n",
              "  (Arousal): Linear(in_features=128, out_features=10, bias=True)\n",
              "  (Valence): Linear(in_features=128, out_features=10, bias=True)\n",
              "  (Dominance): Linear(in_features=128, out_features=10, bias=True)\n",
              "  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
              ")"
            ]
          },
          "metadata": {},
          "execution_count": 42
        }
      ],
      "source": [
        "SalienceNet = CNN()\n",
        "SalienceNet.to(device)"
      ],
      "id": "ad94c3ad"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "bSEPAmQoJlkq"
      },
      "outputs": [],
      "source": [
        "class ContinuousLoss_L2(nn.Module):\n",
        "  ''' Class to measure loss between continuous emotion dimension predictions and labels. Using l2 loss as base. '''\n",
        "  def __init__(self, margin=1):\n",
        "    super(ContinuousLoss_L2, self).__init__()\n",
        "    self.margin = margin\n",
        "  \n",
        "  def forward(self, pred, target):\n",
        "    labs = torch.abs(pred - target)\n",
        "    loss = labs ** 2 \n",
        "    loss[ (labs < self.margin) ] = 0.0\n",
        "    return loss.sum()"
      ],
      "id": "bSEPAmQoJlkq"
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wpriQW4-Johz"
      },
      "outputs": [],
      "source": [
        "cont_loss = ContinuousLoss_L2()"
      ],
      "id": "wpriQW4-Johz"
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "metadata": {
        "id": "eMAlEzRt0VTw"
      },
      "outputs": [],
      "source": [
        "criterion = nn.CrossEntropyLoss()"
      ],
      "id": "eMAlEzRt0VTw"
    },
    {
      "cell_type": "code",
      "execution_count": 57,
      "metadata": {
        "id": "9997283d"
      },
      "outputs": [],
      "source": [
        "from tqdm import tqdm\n",
        "def train(net, loss_fn, dataloader_train,dataloader_val,\n",
        "          epoch=100, learning_rate=0.000001):\n",
        "    optimizer = torch.optim.Adam(net.parameters(), lr=learning_rate,weight_decay=1e-4) # weight decay as a regularization technique to defy overfitting\n",
        "    train_loss = []\n",
        "    val_loss = []\n",
        "    train_accuracy = []\n",
        "    val_accuracy = []\n",
        "    train_epoch_loss = []\n",
        "    val_epoch_loss = []\n",
        "    for i in range(epoch):\n",
        "        train_loop = tqdm(dataloader_train)\n",
        "        val_loop = tqdm(dataloader_val)\n",
        "        total = 0\n",
        "        correct_a,correct_v,correct_d=0,0,0\n",
        "        net.to(device)   \n",
        "        net.train()\n",
        "        for data, label in train_loop:\n",
        "            data, label = data.to(device), label.to(device)\n",
        "            #make prediction\n",
        "            Arousal,Valence,Dominance = net(data.float())\n",
        "\n",
        "            _a, y_pred_train_arousal = torch.max(Arousal,1)\n",
        "            _v, y_pred_train_valence = torch.max(Valence,1)\n",
        "            _d, y_pred_train_dominance = torch.max(Dominance,1)\n",
        "\n",
        "            total += label[:,0].size(0)+label[:,1].size(0)+label[:,2].size(0)\n",
        "\n",
        "            correct_a += (y_pred_train_arousal == label[:,0]).sum().item()\n",
        "            correct_v += (y_pred_train_valence == label[:,1]).sum().item()\n",
        "            correct_d += (y_pred_train_dominance == label[:,2]).sum().item()\n",
        "           \n",
        "            sum_correct = (correct_a+correct_v+correct_d)\n",
        "            # Zero out the gradients\n",
        "            optimizer.zero_grad()\n",
        "\n",
        "            # Calculate loss.\n",
        "            #loss = loss_fn(output,label)#torch.max(label.long(), 1)[0])\n",
        "            loss_arousal = loss_fn(Arousal,label[:,0])\n",
        "            loss_valence = loss_fn(Valence,label[:,1])\n",
        "            loss_dominance = loss_fn(Dominance,label[:,2])\n",
        "            loss=loss_arousal+loss_valence+loss_dominance\n",
        "\n",
        "      \n",
        "            # Backpropagation and gradient update.\n",
        "            loss.backward()# Calculate gradients. #retrain_graph=True\n",
        "\n",
        "            optimizer.step() # Apply gradient update\n",
        "            \n",
        "            train_loss.append(loss.item())\n",
        "            train_loop.set_description(f\"Epoch [{i+1}/{epoch}]\")\n",
        "\n",
        "        train_accuracy.append(sum_correct/total)\n",
        "        train_epoch_loss.append((np.array(train_loss).mean()))\n",
        "\n",
        "        #validation\n",
        "        net.eval()\n",
        "        val_total = 0\n",
        "        val_arousal,val_valence, val_dominance = 0,0,0\n",
        "        for data, labels in dataloader_val:\n",
        "            data, labels = data.to(device), labels.to(device)\n",
        "\n",
        "            Arousal_v,Valence_v,Dominance_v = net(data.float())\n",
        "\n",
        "            _a, y_pred_val_arousal = torch.max(Arousal_v,1)\n",
        "            _v, y_pred_val_valence = torch.max(Valence_v,1)\n",
        "            _d, y_pred_val_dominance = torch.max(Dominance_v,1)\n",
        "\n",
        "            val_total += labels[:,0].size(0)+labels[:,1].size(0)+labels[:,2].size(0)\n",
        "\n",
        "            val_arousal += (y_pred_val_arousal == labels[:,0]).sum().item()\n",
        "            val_valence += (y_pred_val_valence == labels[:,1]).sum().item()\n",
        "            val_dominance += (y_pred_val_dominance == labels[:,2]).sum().item()\n",
        "           \n",
        "            sum_correct_val = (val_arousal+val_valence+val_dominance)\n",
        "          \n",
        "            loss_arousal_v = loss_fn(Arousal_v,labels[:,0])\n",
        "            loss_valence_v = loss_fn(Valence_v,labels[:,1])\n",
        "            loss_dominance_v = loss_fn(Dominance_v,labels[:,2])\n",
        "\n",
        "            val_l=loss_arousal_v+loss_valence_v+loss_dominance_v\n",
        "        \n",
        "            val_loss.append(val_l.item())\n",
        "\n",
        "        val_epoch_loss.append((np.array(val_loss).mean()))\n",
        "\n",
        "        val_accuracy.append(sum_correct_val/val_total)\n",
        "\n",
        "\n",
        "    return train_loss,train_epoch_loss,val_loss,val_epoch_loss, train_accuracy,val_accuracy\n"
      ],
      "id": "9997283d"
    },
    {
      "cell_type": "code",
      "execution_count": 47,
      "metadata": {
        "id": "JvEWX6FyZGIk"
      },
      "outputs": [],
      "source": [
        "def test(net,loss_fn,dataloader_test):\n",
        "  net.eval()\n",
        "  test_loss = []\n",
        "  test_total,test_correct = 0,0\n",
        "  test_acc = []\n",
        "  test_loop = tqdm(dataloader_test)\n",
        "  i=0\n",
        "  for batch, (data, labels) in enumerate(test_loop):\n",
        "      print('testing...')\n",
        "\n",
        "      data, labels = data.to(device), labels.to(device)\n",
        "      arousal,valence,dominance = net(data.float())\n",
        "\n",
        "      arousal_t = loss_fn(arousal,labels[:,0])\n",
        "      valence_t = loss_fn(valence,labels[:,1])\n",
        "      dominance_t = loss_fn(dominance,labels[:,2])\n",
        "\n",
        "      test_l = arousal_t+valence_t+dominance_t\n",
        "\n",
        "      test_loss.append(test_l.item())\n",
        "      test_loop.set_description(f\"Batch [{i+1}/{batch}]\")\n",
        "      i=+1\n",
        "\n",
        "        #test_total += labels.size(0)\n",
        "        #test_correct += (y_pred_test==torch.max(labels,1)[0]).sum().item()\n",
        "        \n",
        "    #test_acc.append(test_correct/test_total)\n",
        "    #y_pred_test = torch.softmax(outputs,dim=1).argmax(dim=1)\n",
        "\n",
        "   # print('test acc is {}'.format(test_acc)\n",
        "  return test_loss"
      ],
      "id": "JvEWX6FyZGIk"
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "yDqIlocyWRYY",
        "outputId": "3393fd6c-3141-4526-c65a-1c2ae264d6d5"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Tesla T4'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 31
        }
      ],
      "source": [
        "torch.cuda.get_device_name(0)"
      ],
      "id": "yDqIlocyWRYY"
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "metadata": {
        "id": "7e318c98"
      },
      "outputs": [],
      "source": [
        "import matplotlib.pyplot as plt"
      ],
      "id": "7e318c98"
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 17
        },
        "id": "kGxhNDnUbZMD",
        "outputId": "9776af5f-af1b-49d7-a76e-830a4eb370fe"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "google.colab.output.setIframeHeight(0, true, {maxHeight: 300})"
            ]
          },
          "metadata": {}
        }
      ],
      "source": [
        "from IPython.display import Javascript\n",
        "\n",
        "display(Javascript('''google.colab.output.setIframeHeight(0, true, {maxHeight: 300})''')) "
      ],
      "id": "kGxhNDnUbZMD"
    },
    {
      "cell_type": "code",
      "execution_count": 58,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "c5ddd06d",
        "outputId": "842b1f26-760c-4776-ba21-dd64d5a54211"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/347 [00:00<?, ?it/s]\n",
            "\n",
            "\n",
            "Epoch [1/20]: 100%|██████████| 347/347 [00:21<00:00, 15.82it/s]\n",
            "  0%|          | 0/347 [00:00<?, ?it/s]\n",
            "\n",
            "\n",
            "\n",
            "  0%|          | 0/74 [00:23<?, ?it/s]\n",
            "Epoch [2/20]: 100%|██████████| 347/347 [00:21<00:00, 15.85it/s]\n",
            "  0%|          | 0/347 [00:00<?, ?it/s]\n",
            "\n",
            "\n",
            "  0%|          | 0/74 [00:23<?, ?it/s]\n",
            "Epoch [3/20]: 100%|██████████| 347/347 [00:22<00:00, 15.73it/s]\n",
            "  0%|          | 0/347 [00:00<?, ?it/s]\n",
            "\n",
            "\n",
            "\n",
            "  0%|          | 0/74 [00:23<?, ?it/s]\n",
            "Epoch [4/20]: 100%|██████████| 347/347 [00:22<00:00, 15.73it/s]\n",
            "  0%|          | 0/347 [00:00<?, ?it/s]\n",
            "\n",
            "\n",
            "  0%|          | 0/74 [00:23<?, ?it/s]\n",
            "Epoch [5/20]: 100%|██████████| 347/347 [00:21<00:00, 15.86it/s]\n",
            "  0%|          | 0/347 [00:00<?, ?it/s]\n",
            "\n",
            "\n",
            "\n",
            "  0%|          | 0/74 [00:23<?, ?it/s]\n",
            "Epoch [6/20]: 100%|██████████| 347/347 [00:21<00:00, 15.87it/s]\n",
            "  0%|          | 0/347 [00:00<?, ?it/s]\n",
            "\n",
            "\n",
            "  0%|          | 0/74 [00:23<?, ?it/s]\n",
            "Epoch [7/20]: 100%|██████████| 347/347 [00:21<00:00, 15.87it/s]\n",
            "  0%|          | 0/347 [00:00<?, ?it/s]\n",
            "\n",
            "\n",
            "\n",
            "  0%|          | 0/74 [00:23<?, ?it/s]\n",
            "Epoch [8/20]: 100%|██████████| 347/347 [00:21<00:00, 15.85it/s]\n",
            "  0%|          | 0/347 [00:00<?, ?it/s]\n",
            "\n",
            "\n",
            "  0%|          | 0/74 [00:23<?, ?it/s]\n",
            "Epoch [9/20]: 100%|██████████| 347/347 [00:21<00:00, 15.88it/s]\n",
            "  0%|          | 0/347 [00:00<?, ?it/s]\n",
            "\n",
            "\n",
            "\n",
            "  0%|          | 0/74 [00:23<?, ?it/s]\n",
            "Epoch [10/20]: 100%|██████████| 347/347 [00:21<00:00, 15.81it/s]\n",
            "  0%|          | 0/347 [00:00<?, ?it/s]\n",
            "\n",
            "\n",
            "  0%|          | 0/74 [00:23<?, ?it/s]\n",
            "Epoch [11/20]: 100%|██████████| 347/347 [00:22<00:00, 15.70it/s]\n",
            "  0%|          | 0/347 [00:00<?, ?it/s]\n",
            "\n",
            "\n",
            "\n",
            "  0%|          | 0/74 [00:23<?, ?it/s]\n",
            "Epoch [12/20]: 100%|██████████| 347/347 [00:22<00:00, 15.74it/s]\n",
            "  0%|          | 0/347 [00:00<?, ?it/s]\n",
            "\n",
            "\n",
            "  0%|          | 0/74 [00:23<?, ?it/s]\n",
            "Epoch [13/20]: 100%|██████████| 347/347 [00:21<00:00, 15.81it/s]\n",
            "  0%|          | 0/347 [00:00<?, ?it/s]\n",
            "\n",
            "\n",
            "\n",
            "  0%|          | 0/74 [00:23<?, ?it/s]\n",
            "Epoch [14/20]: 100%|██████████| 347/347 [00:21<00:00, 15.79it/s]\n",
            "  0%|          | 0/347 [00:00<?, ?it/s]\n",
            "\n",
            "\n",
            "  0%|          | 0/74 [00:23<?, ?it/s]\n",
            "Epoch [15/20]: 100%|██████████| 347/347 [00:22<00:00, 15.75it/s]\n",
            "  0%|          | 0/347 [00:00<?, ?it/s]\n",
            "\n",
            "\n",
            "\n",
            "  0%|          | 0/74 [00:23<?, ?it/s]\n",
            "Epoch [16/20]: 100%|██████████| 347/347 [00:21<00:00, 15.83it/s]\n",
            "  0%|          | 0/347 [00:00<?, ?it/s]\n",
            "\n",
            "\n",
            "  0%|          | 0/74 [00:23<?, ?it/s]\n",
            "Epoch [17/20]: 100%|██████████| 347/347 [00:21<00:00, 15.79it/s]\n",
            "  0%|          | 0/347 [00:00<?, ?it/s]\n",
            "\n",
            "\n",
            "\n",
            "  0%|          | 0/74 [00:23<?, ?it/s]\n",
            "Epoch [18/20]: 100%|██████████| 347/347 [00:22<00:00, 15.67it/s]\n",
            "  0%|          | 0/347 [00:00<?, ?it/s]\n",
            "\n",
            "\n",
            "  0%|          | 0/74 [00:23<?, ?it/s]\n",
            "Epoch [19/20]: 100%|██████████| 347/347 [00:22<00:00, 15.69it/s]\n",
            "  0%|          | 0/347 [00:00<?, ?it/s]\n",
            "\n",
            "\n",
            "\n",
            "  0%|          | 0/74 [00:23<?, ?it/s]\n",
            "Epoch [20/20]: 100%|██████████| 347/347 [00:22<00:00, 15.77it/s]\n",
            "  0%|          | 0/74 [00:23<?, ?it/s]\n"
          ]
        }
      ],
      "source": [
        "np.random.seed(1)\n",
        "torch.manual_seed(1)\n",
        "\n",
        "train_loss,train_epoch_loss,val_loss,val_epoch_loss,train_acc,val_acc=train(net=SalienceNet,loss_fn=criterion,dataloader_train=dataloader_train,\n",
        "                  dataloader_val=dataloader_val,epoch=20)\n",
        "\n",
        "\n"
      ],
      "id": "c5ddd06d"
    },
    {
      "cell_type": "code",
      "execution_count": 59,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 472
        },
        "id": "fk-6haR7G5-q",
        "outputId": "3281779d-6a9d-4ae6-edbc-090d03c0102c"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "plt.plot(train_epoch_loss, label = 'train loss')\n",
        "plt.plot(val_epoch_loss, label = 'validation loss')\n",
        "plt.xlabel('Epoch')\n",
        "plt.ylabel('Loss')\n",
        "plt.title('loss per epoch')\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "id": "fk-6haR7G5-q"
    },
    {
      "cell_type": "code",
      "source": [
        "plt.plot(train_acc, label = 'train acc')\n",
        "plt.plot(val_acc, label = 'validation acc')\n",
        "plt.xlabel('Epoch')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.title('Accuracy per epoch')\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 472
        },
        "id": "s9cEBXo1dJNj",
        "outputId": "2b4b2f51-ddd9-42c8-9cc5-a4d25023eb72"
      },
      "id": "s9cEBXo1dJNj",
      "execution_count": 60,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "test_loss = test(net=SalienceNet,loss_fn=criterion,dataloader_test=dataloader_test)"
      ],
      "metadata": {
        "id": "DaXL76FBu8aa",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f03c0ead-91b9-4650-db92-b68b5294fc75"
      },
      "id": "DaXL76FBu8aa",
      "execution_count": 48,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Batch [2/8]:   5%|▍         | 5/109 [00:00<00:02, 46.60it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Batch [2/19]:  14%|█▍        | 15/109 [00:00<00:02, 46.28it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Batch [2/29]:  24%|██▍       | 26/109 [00:00<00:01, 48.34it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Batch [2/39]:  33%|███▎      | 36/109 [00:00<00:01, 48.59it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Batch [2/49]:  42%|████▏     | 46/109 [00:01<00:01, 48.80it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Batch [2/58]:  51%|█████▏    | 56/109 [00:01<00:01, 47.05it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Batch [2/68]:  61%|██████    | 66/109 [00:01<00:00, 46.44it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Batch [2/79]:  70%|██████▉   | 76/109 [00:01<00:00, 46.97it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Batch [2/88]:  79%|███████▉  | 86/109 [00:01<00:00, 46.36it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Batch [2/98]:  88%|████████▊ | 96/109 [00:02<00:00, 46.83it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Batch [2/108]: 100%|██████████| 109/109 [00:02<00:00, 47.35it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n",
            "testing...\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 49,
      "metadata": {
        "id": "dtd4ymkVafCh",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 472
        },
        "outputId": "86694b86-8d94-4a57-ec53-08867582f5ee"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "plt.plot(test_loss)\n",
        "plt.xlabel('Iterations of gradient descent')\n",
        "plt.ylabel('Loss')\n",
        "plt.title('Loss for test data')\n",
        "plt.show()"
      ],
      "id": "dtd4ymkVafCh"
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": "YOLO",
      "language": "python",
      "name": "yolo"
    },
    "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.9"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}