MVNN_twitter.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Copy of Copy of MVNN_Prototype.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/AyushGupta51379/COMP_5331_Project_Fake_News_Detection/blob/master/MVNN_twitter.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ghzNr1TklPAR"
      },
      "source": [
        "# MVNN\n",
        "\n",
        "This piece of work is an implementation of Multi-domain Visual Neural Network (MVNN), which is first proposed in the paper [Exploiting Multi-domain Visual Information for Fake News Detection](https://arxiv.org/abs/1908.04472)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vYmmpTvxlII9"
      },
      "source": [
        "# some basic things to include\n",
        "import os\n",
        "import numpy as np\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "from torchvision import datasets, transforms\n",
        "\n",
        "from PIL import Image\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.image as mpimg\n",
        "\n",
        "# some preprocessing techniques\n",
        "from scipy.fftpack import dct\n",
        "\n",
        "# custom dataset\n",
        "from torch.utils.data.dataset import Dataset\n",
        "\n",
        "# this is only required for Google Colab\n",
        "from google.colab import drive\n",
        "\n",
        "import time\n",
        "from datetime import datetime\n",
        "import matplotlib.pyplot as plt"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HsuzqnBVpuAR"
      },
      "source": [
        "these modules and dataset require to be downloaded (unless they are executed under a repository)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iCbaTVoCPyWo",
        "outputId": "acaf6035-2883-46b3-91c2-a016492d089d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Mount your google drive (for later model saving & loading)\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mounted at /content/drive\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OsFX9EkSmXxF",
        "outputId": "f4161174-deb9-4fe9-db56-3f7ef1a36af8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# DCT modules\n",
        "#print(\"DCT Module:\")\n",
        "#!gdown --id 1MtVZXrFkLTLQgOhFhbYIUrXT-FMKH2hH\n",
        "#from dct import DCT, DFT\n",
        "\n",
        "# download the Weibo dataset\n",
        "# !gdown --id 1gjbSZV5NjjIVOqSP-yTCqXcGPX9PnYn5\n",
        "# !unzip -q '/content/MM17-WeiboRumorSet.zip'\n",
        "# print(\"Dataset: Weibo is loaded\")\n",
        "# mainfolder = 'MM17-WeiboRumorSet/'\n",
        "# subfolders = {'nonrumor_images': 0, 'rumor_images': 1}\n",
        "\n",
        "# download the Twitter dataset\n",
        "!gdown --id 1ydEupxLKCmFYe3nfbpbRyCmHi05Oxt5i\n",
        "!unzip -q '/content/Medieval2015_fake_or_real_Images.zip'\n",
        "print(\"Dataset: Twitter is loaded\")\n",
        "mainfolder = 'Medieval2015_fake_or_real_Images/'\n",
        "subfolders = {'non-rumor': 0, 'rumor': 1}"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Downloading...\n",
            "From: https://drive.google.com/uc?id=1ydEupxLKCmFYe3nfbpbRyCmHi05Oxt5i\n",
            "To: /content/Medieval2015_fake_or_real_Images.zip\n",
            "35.3MB [00:00, 68.6MB/s]\n",
            "Dataset: Twitter is loaded\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jLz9GPSIgczE"
      },
      "source": [
        "\n",
        "'''\n",
        "Usage:\n",
        "as image preprocessor by calling DCT() as a transform\n",
        "\n",
        "input: 128*128*3 PIL image\n",
        "output: 64*256 torch array (histogram)\n",
        "\n",
        "[128*128] => (crop) => [256 * [8*8]] => (DCT_2d) => [256 * [8 * 8]] => reshape => [256 * 64]  \n",
        "'''\n",
        "\n",
        "class DCT(object):\n",
        "    def __init__(self):\n",
        "        self.BLOCK_HEIGHT = 8\n",
        "        self.BLOCK_WIDTH = 8\n",
        "        self.BLOCK_SIZE = (self.BLOCK_HEIGHT, self.BLOCK_WIDTH)\n",
        "\n",
        "    def div_block(self, img, block_size):\n",
        "        img_height = img.height\n",
        "        img_width = img.width\n",
        "        block_height = block_size[0]\n",
        "        block_width = block_size[1]\n",
        "        assert(img_height % block_height == 0)\n",
        "        assert(img_width % block_width == 0)\n",
        "\n",
        "        blocks = []\n",
        "        for i in range(0,img_height,block_height):\n",
        "            for j in range(0,img_width,block_width):\n",
        "                box = (j, i, j+block_width, i+block_height)\n",
        "                block = np.array(img.crop(box))\n",
        "                blocks.append(block)\n",
        "        return np.array(blocks)\n",
        "\n",
        "    def dct2(self, array_2d):\n",
        "        return dct(dct(array_2d.T, norm = 'ortho').T, norm = 'ortho')\n",
        "\n",
        "    def _dct2(self, array_2d):\n",
        "        return dct(dct(array_2d, norm = 'ortho').T, norm = 'ortho').T\n",
        "\n",
        "    def __call__(self, img):\n",
        "        image = img\n",
        "        blocks = self.div_block(image, self.BLOCK_SIZE)\n",
        "        b_blocks, g_blocks, r_blocks = blocks[:, :, :, 0], blocks[:, :, :, 1], blocks[:, :, :, 2]\n",
        "        test_blocks = (b_blocks + g_blocks + r_blocks) / 3 # naive greyscale\n",
        "        result = np.array([self._dct2(test_block) for test_block in test_blocks])\n",
        "        # return a torch.tensor\n",
        "        return torch.from_numpy(result.reshape(256, 64).T).float()\n",
        "\n",
        "    def __repr__(self):\n",
        "        return \"Simply DCT. What do you expect?\"\n",
        "\n",
        "'''\n",
        "Usage: Same as DCT()\n",
        "\n",
        "input: 64*256 torch array (histogram)\n",
        "output: 64*256 torch array (frequency histogram)\n",
        "'''\n",
        "class DFT(object):\n",
        "    def __init__(self):\n",
        "        pass\n",
        "\n",
        "    def __call__(self, freq):\n",
        "        # convert into complex form containing real and imaginary part\n",
        "        cmplx = torch.from_numpy(np.zeros((freq.shape[0], freq.shape[1], 2)))\n",
        "        cmplx[:, :, 0] += freq\n",
        "        out = torch.fft(cmplx, 1, normalized=True)[:, :, 0]\n",
        "        return out\n",
        "\n",
        "    def __repr__(self):\n",
        "        return \"Simply DFT. What do you expect?\"\n",
        "\n",
        "\n",
        "'''\n",
        "input: PIL loaded image\n",
        "output: PIL image, in YCbCr color space\n",
        "'''\n",
        "class Ycbcr_convert():\n",
        "    def __init__(self):\n",
        "        pass\n",
        "\n",
        "    def __call__(self, img):\n",
        "        return img.convert('YCbCr')\n",
        "\n",
        "    def __repr__(self):\n",
        "        return \"Convert a PIL Image from RGB to YCbCr\" "
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ayTY1AY3miLq"
      },
      "source": [
        "## Image transformers for pixel and freq domain"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AeTQn2uZmX2r"
      },
      "source": [
        "## Define the image transformers for pixel and freq domain\n",
        "\n",
        "image_height_pixel, image_width_pixel = 224, 224\n",
        "image_height_freq, image_width_freq = 128, 128\n",
        "tform_pixel = transforms.Compose([\n",
        "    transforms.Resize((image_height_pixel,image_width_pixel), interpolation=Image.BICUBIC),\n",
        "    transforms.ToTensor()\n",
        "])\n",
        "tform_freq = transforms.Compose([\n",
        "    transforms.Resize((image_height_freq,image_width_freq), interpolation=Image.BICUBIC),\n",
        "    Ycbcr_convert(),\n",
        "    DCT(),\n",
        "    DFT()\n",
        "])\n",
        "\n",
        "def imshow(np_image):\n",
        "    plt.figure(figsize = (5,5))\n",
        "    plt.imshow(np_image) # it should be a numpy array\n",
        "    plt.show()"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4nas4CoTsRqC"
      },
      "source": [
        "### Some remarks from AG  \n",
        "When you use GPU runtime in Colab, apart from the original VM running the notebook, Google will instantiate a new VM with GPU so that parallel computations are forwarded to VM with GPU. \\\\\n",
        "Here we load all the data (~1.35GB, while Nvidia Tesla K80 has 12GB RAM) into memory in the beginning. Hence the data transfer between 2 VMs will only be called once, rather than every mini-batch. This is the point which takes most time, while in the training section later it will exhibit huge speedup."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4sNJgGvkmX5z"
      },
      "source": [
        "class WeiboRumorDataset(Dataset):\n",
        "    def __init__(self, tform_pixel, tform_freq, folder, subfolders):        \n",
        "        self.tform_pixel = tform_pixel\n",
        "        self.tform_freq = tform_freq\n",
        "        self.mainfolder = folder\n",
        "        self.subfolders = subfolders        \n",
        "        self.data = []\n",
        "        # load the entire dataset into memory\n",
        "        for subfolder, label in subfolders.items():\n",
        "            current = os.path.join(self.mainfolder, subfolder)\n",
        "            filenames = os.listdir(current)\n",
        "            for filename in filenames:\n",
        "                self.data.append([os.path.join(subfolder, filename), label])\n",
        "            print(\"[%s]: %d image loaded.\" % (current, len(filenames)))\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.data)\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        if torch.is_tensor(idx):\n",
        "            idx = idx.tolist()\n",
        "\n",
        "        filepath, label = self.data[idx]\n",
        "        img = Image.open(os.path.join(self.mainfolder, filepath)).convert('RGB')     \n",
        "        pixel_input = self.tform_pixel(img)\n",
        "        freq_input = self.tform_freq(img)\n",
        "        out = [pixel_input, freq_input, label]\n",
        "        return out"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AxFdeFBD0icA",
        "outputId": "d3dd32e0-99de-4309-a403-7c5f46693fd9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 410
        }
      },
      "source": [
        "# visualize information of the dataset\n",
        "\n",
        "dataset = WeiboRumorDataset(tform_pixel, tform_freq, mainfolder, subfolders)\n",
        "count = dataset.__len__()\n",
        "print('Total no. of images: ', count)\n",
        "\n",
        "pixel_input, freq_input, label = dataset.__getitem__(0)\n",
        "imshow(pixel_input.transpose(0, 1).transpose(1, 2))\n",
        "print(\"Frequency domain shape:\", freq_input.shape)\n",
        "print(\"Label:\", label)"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[Medieval2015_fake_or_real_Images/non-rumor]: 176 image loaded.\n",
            "[Medieval2015_fake_or_real_Images/rumor]: 184 image loaded.\n",
            "Total no. of images:  360\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 360x360 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Frequency domain shape: torch.Size([64, 256])\n",
            "Label: 0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xsxqK2wRlNvD"
      },
      "source": [
        "## Subnetworks"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iSzJzDbwsKAt"
      },
      "source": [
        "class CNN(nn.Module):\n",
        "    def __init__(self, image_height, image_width):\n",
        "        super(CNN, self).__init__()\n",
        "\n",
        "        # NOTE:\n",
        "        # 1. Before each ReLu, a BatchNorm2d layer is added to accelerate convergence (also did by the authors of the paper)\n",
        "\n",
        "        # Conv Model 1\n",
        "        self.conv_M1 = nn.Sequential(nn.Conv2d( 3, 32, 3, padding = 1), nn.ReLU(), nn.BatchNorm2d(32),  # (N,  3, 128, 128) --> (N, 32, 128, 128); add padding = 1 for kernel size = 3 to avoid changing output size\n",
        "                                     nn.Conv2d(32, 32, 1), nn.ReLU(),   nn.BatchNorm2d(32),             # (N, 32, 128, 128) --> (N, 32, 128, 128);\n",
        "                                     nn.MaxPool2d(2))                                                   # (N,  3, 128, 128) --> (N, 32,  64,  64);\n",
        "                                     \n",
        "        # Conv Model 2\n",
        "        self.conv_M2 = nn.Sequential(nn.Conv2d(32, 64, 3, padding = 1), nn.ReLU(), nn.BatchNorm2d(64),  # (N, 32, 64, 64) --> (N, 64, 64, 64)\n",
        "                                     nn.Conv2d(64, 64, 1), nn.ReLU(), nn.BatchNorm2d(64),               # (N, 64, 64, 64) --> (N, 64, 64, 64)\n",
        "                                     nn.MaxPool2d(2))                                                   # (N, 64, 64, 64) --> (N, 64, 32, 32)\n",
        "\n",
        "        # Conv Model 3\n",
        "        self.conv_M3 = nn.Sequential(nn.Conv2d(64, 64, 3, padding = 1), nn.ReLU(), nn.BatchNorm2d(64),  # (N, 64, 32, 32) --> (N, 64, 32, 32)\n",
        "                                     nn.Conv2d(64, 64, 1), nn.ReLU(), nn.BatchNorm2d(64),               # (N, 64, 32, 32) --> (N, 64, 32, 32)\n",
        "                                     nn.MaxPool2d(2))                                                   # (N, 64, 32, 32) --> (N, 64, 16, 16)\n",
        "\n",
        "        # Conv Model 4\n",
        "        self.conv_M4 = nn.Sequential(nn.Conv2d( 64, 128, 3, padding = 1), nn.ReLU(), nn.BatchNorm2d(128), # (N,  64, 16, 16) --> (N, 128, 16, 16)\n",
        "                                     nn.Conv2d(128, 128, 1), nn.ReLU(), nn.BatchNorm2d(128),              # (N, 128, 16, 16) --> (N, 128, 16, 16)\n",
        "                                     nn.MaxPool2d(2))                                                     # (N, 128, 16, 16) --> (N, 128,  8,  8)\n",
        "        \n",
        "        #===== For each branch =====%\n",
        "        # Note:\n",
        "        # 1. Flatten convolution layer before FC layer, the input column size = 64 neurons * pooled output size\n",
        "        # 2. Since image_height and image_width are fed from outside, we need to ensure the type to int after division, otherwise gives bugs.\n",
        "        # 3. Need to add a dropout layer with a prob of 0.5 after FC layer (see the reference paper)\n",
        "        # 4. Before each FC layer, a BatchNorm2d layer is added to accelerate convergence\n",
        "\n",
        "        self.conv_br1 = nn.Sequential(nn.Conv2d(32, 64, 1),\n",
        "                                      nn.Flatten(1, -1),    # flatten from the 2nd dim (1) to the last dim (-1)\n",
        "                                      nn.BatchNorm1d(int(64*image_height*image_width/2/2)),\n",
        "                                      nn.Linear(int(64*image_height*image_width/2/2), 64),\n",
        "                                      nn.Dropout(0.5))\n",
        "\n",
        "        self.conv_br2 = nn.Sequential(nn.Conv2d(64, 64, 1),\n",
        "                                      nn.Flatten(1, -1),     \n",
        "                                      nn.BatchNorm1d(int(64*image_height*image_width/4/4)),         \n",
        "                                      nn.Linear(int(64*image_height*image_width/4/4), 64),\n",
        "                                      nn.Dropout(0.5))\n",
        "\n",
        "        self.conv_br3 = nn.Sequential(nn.Conv2d(64, 64, 1),\n",
        "                                      nn.Flatten(1, -1),    \n",
        "                                      nn.BatchNorm1d(int(64*image_height*image_width/8/8)),\n",
        "                                      nn.Linear(int(64*image_height*image_width/8/8), 64),\n",
        "                                      nn.Dropout(0.5))\n",
        "\n",
        "        self.conv_br4 = nn.Sequential(nn.Conv2d(128, 64, 1),\n",
        "                                      nn.Flatten(1, -1),              \n",
        "                                      nn.BatchNorm1d(int(64*image_height*image_width/16/16)),\n",
        "                                      nn.Linear(int(64*image_height*image_width/16/16), 64),\n",
        "                                      nn.Dropout(0.5))\n",
        "\n",
        "        # FC layer to 2 classes (fake or real) with Softmax to compute prob along the dimension of concatenated features (64*4 = 256)\n",
        "        self.fc = nn.Sequential(nn.BatchNorm1d(256),\n",
        "                                nn.Linear(256, 2),\n",
        "                                nn.Dropout(0.5))    \n",
        "                                        #nn.Softmax(dim=1)) # AG: no need for softmax if we use cross entropy loss function, which will also offer prob.\n",
        "                                                            # Now the loss in the training part converges!!\n",
        "    \n",
        "    def forward(self, x):\n",
        "        out1 = self.conv_M1(x)      # Branch 1\n",
        "        out2 = self.conv_M2(out1)   # Branch 2\n",
        "        out3 = self.conv_M3(out2)   # Branch 3\n",
        "        out4 = self.conv_M4(out3)   # Branch 4\n",
        "        v1 = self.conv_br1(out1)\n",
        "        v2 = self.conv_br2(out2)\n",
        "        v3 = self.conv_br3(out3)\n",
        "        v4 = self.conv_br4(out4)\n",
        "        v_cat = torch.cat((v1, v2, v3, v4), dim=1)\n",
        "        # p = self.fc(v_cat)\n",
        "\n",
        "        # print(\"\\n v1 size:\", v1.shape)\n",
        "        # print(\"\\n v2 size:\", v2.shape)\n",
        "        # print(\"\\n v3 size:\", v3.shape)\n",
        "        # print(\"\\n v4 size:\", v4.shape)\n",
        "        # print(\"\\n v_cat size:\", v_cat.shape)\n",
        "        return v1, v2, v3, v4, v_cat\n",
        "\n",
        "class CNN_GRU(CNN):\n",
        "    def __init__(self, image_height, image_width):\n",
        "        super(CNN_GRU, self).__init__(image_height, image_width)\n",
        "\n",
        "        # The 4 GRUs in layer 1\n",
        "        self.gru1_1 = nn.GRU(input_size=64, hidden_size=32, num_layers=1, bidirectional=False)\n",
        "        self.gru2_1 = nn.GRU(input_size=64, hidden_size=32, num_layers=1, bidirectional=False)\n",
        "        self.gru3_1 = nn.GRU(input_size=64, hidden_size=32, num_layers=1, bidirectional=False)\n",
        "        self.gru4_1 = nn.GRU(input_size=64, hidden_size=32, num_layers=1, bidirectional=False)\n",
        "\n",
        "        # The 4 GRUs in layer 2\n",
        "        self.gru1_2 = nn.GRU(input_size=32, hidden_size=32, num_layers=1, bidirectional=False)\n",
        "        self.gru2_2 = nn.GRU(input_size=32, hidden_size=32, num_layers=1, bidirectional=False)\n",
        "        self.gru3_2 = nn.GRU(input_size=32, hidden_size=32, num_layers=1, bidirectional=False)\n",
        "        self.gru4_2 = nn.GRU(input_size=32, hidden_size=32, num_layers=1, bidirectional=False)\n",
        "\n",
        "        self.relu = nn.ReLU()\n",
        "\n",
        "        self.bn = nn.BatchNorm1d(4*2*32)\n",
        "        self.fc = nn.Sequential(nn.Linear(4*2*32, 2))\n",
        "                                            # nn.LogSoftmax(dim=1)) # AG: no need for softmax if we use cross entropy loss function, which will also offer prob.\n",
        "                                                            # Now the loss in the training part converges!!\n",
        "    def forward(self, x):\n",
        "        v1, v2, v3, v4, v_cat = super().forward(x)\n",
        "        \n",
        "        v1 = v1.unsqueeze(0) # add an extra dimension to feed into the gru model (4, 64) --> (1, 4, 64)\n",
        "        v2 = v2.unsqueeze(0)\n",
        "        v3 = v3.unsqueeze(0)\n",
        "        v4 = v4.unsqueeze(0)\n",
        "\n",
        "        # backward GRU (1st layer) which reads from v4 to v1 \n",
        "        out4_layer1, h4_backward = self.gru4_1(v4)                  # --> (1, N, 32)\n",
        "        out3_layer1, h3_backward = self.gru3_1(v3, h4_backward)\n",
        "        out2_layer1, h2_backward = self.gru2_1(v2, h3_backward)\n",
        "        out1_layer1, h1_backward = self.gru1_1(v1, h2_backward)\n",
        "\n",
        "\n",
        "        # forward GRU (2nd layer) which reads from v1 to v4 \n",
        "        out1_layer2, h1_forward = self.gru1_2(h1_backward)          # --> (1, N, 32)\n",
        "        out2_layer2, h2_forward = self.gru2_2(h2_backward, h1_backward)\n",
        "        out3_layer2, h3_forward = self.gru3_2(h3_backward, h2_backward)\n",
        "        out4_layer2, h4_forward = self.gru4_2(h4_backward, h3_backward)\n",
        "\n",
        "        # concatenating the forward hidden state and the backward hidden state along the feature dimension --> (1, N, 64)\n",
        "        L1 = torch.squeeze(torch.cat((h1_forward, h1_backward), dim=2)) # --> (N, 64)\n",
        "        L2 = torch.squeeze(torch.cat((h2_forward, h2_backward), dim=2))\n",
        "        L3 = torch.squeeze(torch.cat((h3_forward, h3_backward), dim=2))\n",
        "        L4 = torch.squeeze(torch.cat((h4_forward, h4_backward), dim=2))\n",
        "\n",
        "        # print(\"\\n L1 size:\", L1.shape)\n",
        "        # print(\"\\n L2 size:\", L2.shape)\n",
        "        # print(\"\\n L3 size:\", L3.shape)\n",
        "        # print(\"\\n L4 size:\", L4.shape)\n",
        "\n",
        "        L_cat = torch.cat((L1, L2, L3, L4), dim=1)    # --> (4, N, 32)\n",
        "        # print(\"\\n L_cat size:\", L_cat.shape)\n",
        "        \n",
        "        # p = self.fc(self.bn(L_cat))\n",
        "\n",
        "        return L1, L2, L3, L4, L_cat\n",
        "\n",
        "class Frequent_Domain_Subnetwork(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(Frequent_Domain_Subnetwork, self).__init__()\n",
        "        self.backbone = nn.Sequential(nn.Conv1d(64, 32, 3, padding=1),  #nn.BatchNorm2d(32),\n",
        "                                      nn.MaxPool1d(2),                  #nn.BatchNorm2d(32),\n",
        "                                      nn.Conv1d(32, 64, 3, padding=1),  #nn.BatchNorm2d(64),\n",
        "                                      nn.MaxPool1d(2),                  #nn.BatchNorm2d(64),\n",
        "                                      nn.Conv1d(64, 128, 3, padding=1), #nn.BatchNorm2d(128),\n",
        "                                      nn.MaxPool1d(2),        #nn.BatchNorm2d(128),\n",
        "                                      nn.Flatten(), \n",
        "                                      nn.Linear(4096, 64),\n",
        "                                      nn.ReLU(),              #nn.BatchNorm1d(64),\n",
        "                                      nn.Linear(64, 64))\n",
        "\n",
        "    def forward(self, x):\n",
        "        out = self.backbone.forward(x)\n",
        "        return out    "
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nkgAG_e7terO"
      },
      "source": [
        "# Model 1, full MVNN\n",
        "class MVNN(nn.Module):\n",
        "    def __init__(self, image_height_pixel, image_width_pixel):\n",
        "        super().__init__()\n",
        "        # subnetworks\n",
        "        self.pixel_subnet = CNN_GRU(image_height_pixel, image_width_pixel)\n",
        "        self.freq_subnet = Frequent_Domain_Subnetwork()\n",
        "\n",
        "        # attention\n",
        "        self.output_len = 5\n",
        "        self.dimensions = 64\n",
        "        self.v = nn.Parameter(torch.rand(self.dimensions, 1))\n",
        "        self.W = nn.Linear(self.dimensions, self.dimensions)\n",
        "        self.softmax = nn.Softmax(dim=1)\n",
        "        self.tanh = nn.Tanh()\n",
        "        # final FC\n",
        "        self.Wc = nn.Linear(self.dimensions, 2)\n",
        "\n",
        "    def forward(self, x_pixel, x_freq):\n",
        "        dimensions = self.dimensions\n",
        "        output_len = self.output_len\n",
        "\n",
        "        L1, L2, L3, L4, L_cat = self.pixel_subnet(x_pixel)      \n",
        "        L0 = self.freq_subnet(x_freq)\n",
        "\n",
        "        L_all = torch.stack((L0, L1, L2, L3, L4), dim=1) # Bx5x64\n",
        "        batch_size, output_len, dimensions = L_all.shape\n",
        "        L_all = self.W(L_all.reshape(batch_size * output_len, dimensions))\n",
        "        L_all = L_all.reshape((batch_size, output_len, dimensions))\n",
        "        f = self.tanh(L_all.reshape(batch_size, output_len, dimensions))\n",
        "\n",
        "        # Bx5x64 bmm 1x64x1 => Bx5x1 => Bx5\n",
        "        a = self.softmax(torch.matmul(f, self.v).view(batch_size, -1)) \n",
        "        # Bx1x5 bmm Bx5x64 => Bx1x64 => Bx64\n",
        "        u = torch.bmm(a.unsqueeze(1), L_all).view(batch_size, -1)\n",
        "        out = self.Wc(u) # final output: Bx2\n",
        "        return out        \n",
        "\n",
        "# Model 2, w/o freq\n",
        "class MVNN_wout_freq(nn.Module):\n",
        "    def __init__(self, image_height_pixel, image_width_pixel):\n",
        "        super().__init__()\n",
        "\n",
        "        # subnetworks\n",
        "        self.pixel_subnet = CNN_GRU(image_height_pixel, image_width_pixel)\n",
        "        # self.freq_subnet = Frequent_Domain_Subnetwork()     \n",
        "\n",
        "        # attention\n",
        "        self.output_len = 5\n",
        "        self.dimensions = 64\n",
        "        self.v = nn.Parameter(torch.rand(self.dimensions, 1))\n",
        "        self.W = nn.Linear(self.dimensions, self.dimensions)\n",
        "        self.softmax = nn.Softmax(dim=1)\n",
        "        self.tanh = nn.Tanh()\n",
        "        # final FC\n",
        "        self.Wc = nn.Linear(self.dimensions, 2)\n",
        "\n",
        "    def forward(self, x_pixel, x_freq):\n",
        "        dimensions = self.dimensions\n",
        "        output_len = self.output_len\n",
        "\n",
        "        L1, L2, L3, L4, L_cat = self.pixel_subnet(x_pixel)      \n",
        "        # L0 = self.freq_subnet(x_freq)\n",
        "\n",
        "        L_all = torch.stack((L1, L2, L3, L4), dim=1) # Bx4x64\n",
        "        # L_all = torch.stack((L0, L1, L2, L3, L4), dim=1) # Bx5x64\n",
        "\n",
        "        batch_size, output_len, dimensions = L_all.shape\n",
        "        L_all = self.W(L_all.reshape(batch_size * output_len, dimensions))\n",
        "        L_all = L_all.reshape((batch_size, output_len, dimensions))\n",
        "        f = self.tanh(L_all.reshape(batch_size, output_len, dimensions))\n",
        "\n",
        "        # Bx4x64 bmm 1x64x1 => Bx5x1 => Bx5\n",
        "        a = self.softmax(torch.matmul(f, self.v).view(batch_size, -1)) \n",
        "        # Bx1x5 bmm Bx5x64 => Bx1x64 => Bx64\n",
        "        u = torch.bmm(a.unsqueeze(1), L_all).view(batch_size, -1)\n",
        "        out = self.Wc(u) # final output: Bx2\n",
        "        return out      "
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3EdG2-b6Yju4"
      },
      "source": [
        "from sklearn.metrics import accuracy_score # normal accuracy\n",
        "from sklearn.metrics import balanced_accuracy_score # used in case of imbalanced data sets, average of recall, from 0 to 1\n",
        "from sklearn.metrics import confusion_matrix # division of performance on the multilabels\n",
        "from sklearn.metrics import cohen_kappa_score # compares model against random prediction, from -1 to 1\n",
        "from sklearn.metrics import classification_report # for multilabel classification, gives precision, recall, f score, support, more\n",
        "\n",
        "def print_metrics(y_true, y_pred, target_names):\n",
        "    print(\"Accuracy:\", accuracy_score(y_true, y_pred))\n",
        "    print(\"Balanced Accuracy:\" , balanced_accuracy_score(y_true, y_pred))\n",
        "    print(\"Confusion Matrix:\\n\", confusion_matrix(y_true, y_pred))\n",
        "    print(\"Cohen Kappa Score:\", cohen_kappa_score(y_true, y_pred))\n",
        "    print(\"Classification Report:\\n\", classification_report(y_true, y_pred, target_names=target_names))\n",
        "\n",
        "#  function to view one image\n",
        "def image_show(np_image):\n",
        "  plt.figure(figsize = (5,5))\n",
        "  plt.imshow(np_image) # it should be a numpy array\n",
        "  plt.show()\n"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NvJVbvepOrJA"
      },
      "source": [
        "## Let's Start Training"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gOea_kRVOwPK",
        "outputId": "d62fc921-f071-421a-9e86-757bd12b2613",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Hyper-parameters\n",
        "MAX_EPOCH = 20\n",
        "learning_rate = 0.0001 # adopt a small lr to ensure convergence\n",
        "batch_size = 32\n",
        "resumetraining = False\n",
        "\n",
        "print_every = 20\n",
        "test_n_savemodel_every_epoch = 3\n",
        "device = 'cuda'\n",
        "seed_no = 0\n",
        "\n",
        "#================================\n",
        "modelname = 'MVNN_wout_freq'    # Which model to use?\n",
        "#================================\n",
        "\n",
        "if modelname == 'MVNN': # hard-coded\n",
        "  model = MVNN(image_height_pixel, image_width_pixel).to(device)\n",
        "elif modelname == 'MVNN_wout_freq':\n",
        "  model = MVNN_wout_freq(image_height_pixel, image_width_pixel).to(device)\n",
        "else:\n",
        "  model = []\n",
        "  print(\"Error: the selected model is not available!\")\n",
        "\n",
        "\n",
        "torch.manual_seed(seed_no) # set seed for reproducibility\n",
        "\n",
        "# 80% train, 20% test\n",
        "trainset, testset = torch.utils.data.random_split(dataset, [int(count*0.8), count-int(count*0.8)])\n",
        "print('Total no. of train set images: ', len(trainset))\n",
        "print('Total no. of test set images: ', len(testset))\n",
        "\n",
        "labels = dataset.subfolders # the dataset saves the subfolder's name as the labels\n",
        "classes = list(labels.keys()) # convert dict keys into list\n",
        "print('classes:', classes)\n",
        "\n",
        "# Load training and test sets\n",
        "trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True, drop_last=True) \n",
        "testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size, shuffle=True, drop_last=True) \n",
        "\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)\n",
        "\n",
        "# Resume the last trained model?\n",
        "#================================\n",
        "resume_epoch = 0\n",
        "if resumetraining == True:\n",
        "  # load the model checkpoint\n",
        "  PATH = ('drive/My Drive/Colab Notebooks/trained_models/' + modelname + \"_MAXepoch\" + str(MAX_EPOCH)\n",
        "          + \"_batch\" + str(batch_size) + \"_lr\" + str(learning_rate) + \".pth\")\n",
        "  print('Loading from ', PATH)\n",
        "\n",
        "  checkpoint = torch.load(PATH)\n",
        "  # load model weights state_dict\n",
        "  model.load_state_dict(checkpoint['model_state_dict'])\n",
        "  print('Previously trained model weights state_dict loaded...')\n",
        "\n",
        "  # load trained optimizer state_dict\n",
        "  optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n",
        "  print('Previously trained optimizer state_dict loaded...')\n",
        "\n",
        "  resume_epoch = checkpoint['epoch']\n",
        "  # load the criterion\n",
        "  criterion = checkpoint['loss']\n",
        "  print('Trained model loss function loaded...')\n",
        "\n",
        "  # load the avg acc & loss in the previous epochs\n",
        "  epoch_avg_acc = checkpoint['epoch_avg_acc']\n",
        "  epoch_avg_loss = checkpoint['epoch_avg_loss']\n",
        "\n",
        "  print('\\n===== Resuming the Last Training from Epoch %d ... =====' %(resume_epoch))\n",
        "else:\n",
        "  epoch_avg_acc = []\n",
        "  epoch_avg_loss = []\n",
        "  print('\\n===== Start a New Training ... =====')\n",
        "  \n",
        "\n",
        "for epoch in range(MAX_EPOCH - resume_epoch):\n",
        "    total_loss, total_acc = 0, 0\n",
        "    cnt = 0\n",
        "    t0 = time.time()\n",
        "\n",
        "    epoch = epoch + resume_epoch\n",
        "    for i, data in enumerate(trainloader):\n",
        "        Xp, Xf = data[0].float().to(device), data[1].float().to(device)\n",
        "        y = data[2].to(device)        \n",
        "\n",
        "        optimizer.zero_grad() \n",
        "        \n",
        "        # forward\n",
        "        out = model(Xp, Xf)        \n",
        "        #print(out, y_pred)\n",
        "        loss = criterion(out, y)\n",
        "\n",
        "        # backward\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "        # stats\n",
        "        y_pred = torch.argmax(out, dim=1)\n",
        "        total_acc += (y_pred == y).sum().item() / len(y_pred)\n",
        "        total_loss += loss.item()\n",
        "\n",
        "        cnt += 1\n",
        "        if i % print_every == 0:\n",
        "            avg_loss = total_loss / cnt\n",
        "            avg_acc = total_acc / cnt\n",
        "            total_acc, total_loss = 0, 0\n",
        "            cnt = 0\n",
        "            # print(out.T, '\\n', y_pred.T, '\\n', y.T)\n",
        "            print('%s: [Epoch %d] [Iter %d/%d] Loss: %5f  Acc: %5f' %(modelname, epoch+1, i+1, int(len(trainset)/trainloader.batch_size), avg_loss, avg_acc))\n",
        "\n",
        "    # Store the average acc & loss for each epoch for later plotting\n",
        "    print('Training:  Avg Loss = %5f, Avg Acc = %5f' %(avg_loss, avg_acc))\n",
        "    epoch_avg_acc.append(avg_acc)\n",
        "    epoch_avg_loss.append(avg_loss)\n",
        "\n",
        "    # Time the training\n",
        "    t1 = time.time()\n",
        "    print(\"Training Time: %10.3f mins\" %((t1-t0)/60))\n",
        "\n",
        "    # Validating\n",
        "    if (epoch+1) % test_n_savemodel_every_epoch == 0:\n",
        "      report_every = 10\n",
        "      acc, test_loss = 0, 0\n",
        "      cnt = 0\n",
        "      model.eval()\n",
        "      y_true = []\n",
        "      y_pred = []\n",
        "      with torch.no_grad():\n",
        "          print('\\n===== Start Validating ... =====')\n",
        "          for data in testloader:\n",
        "              Xp, Xf = data[0].float().to(device), data[1].float().to(device)\n",
        "              y = data[2].to(device)\n",
        "\n",
        "              # prediction\n",
        "              out = model(Xp, Xf)        \n",
        "              pred = torch.argmax(out, dim=1)\n",
        "\n",
        "              test_loss = criterion(out, y)\n",
        "              test_loss += test_loss.item()\n",
        "\n",
        "              y_true.append(y)\n",
        "              y_pred.append(pred)\n",
        "\n",
        "              cnt += 1\n",
        "\n",
        "              if cnt % report_every == 0:\n",
        "                  print(\"[Test] [Epoch %d]  %d / %d batches tested\" % (epoch+1, cnt, testloader.__len__()))        \n",
        "\n",
        "          test_loss = test_loss/testloader.__len__()\n",
        "          print(\"[Test] [Epoch %d] %d / %d batches tested. Test Loss: %5f\" % (epoch+1, cnt, testloader.__len__(), test_loss))\n",
        "      model.train() # Toggle on the training mode to enable back the dropout/batchnorm layers for training\n",
        "      \n",
        "      # Print classification report\n",
        "      y_true = torch.cat(y_true, dim=0)\n",
        "      y_pred = torch.cat(y_pred, dim=0)\n",
        "      target_names = ['non-rumor', 'rumor']\n",
        "      print_metrics(y_true.cpu(), y_pred.cpu(), target_names)\n",
        "      print('')\n",
        "      '''\n",
        "      # Save model checkpoint\n",
        "      PATH = ('drive/My Drive/Colab Notebooks/trained_models/' + modelname + \"_MAXepoch\" + str(MAX_EPOCH)\n",
        "              + \"_batch\" + str(batch_size) + \"_lr\" + str(learning_rate) + \".pth\")\n",
        "      print(PATH)\n",
        "      torch.save({\n",
        "            'epoch': epoch+1,\n",
        "            'model_state_dict': model.state_dict(),\n",
        "            'optimizer_state_dict': optimizer.state_dict(),\n",
        "            'loss': criterion,\n",
        "            'epoch_avg_acc': epoch_avg_acc,\n",
        "            'epoch_avg_loss': epoch_avg_loss,\n",
        "            }, PATH)\n",
        "      print('!!! The trained model is saved !!!') # Make sure you have enough space on google drive\n",
        "      '''\n",
        "    # Early stopper\n",
        "    if avg_loss < 0.1:\n",
        "      print('Training is stopped at [Epoch %d] as loss is already very low (%5f)!' %(epoch+1, avg_loss))\n",
        "      break\n",
        "\n",
        "print('\\n===== Finished Training & Validating =====')\n"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Total no. of train set images:  288\n",
            "Total no. of test set images:  72\n",
            "classes: ['non-rumor', 'rumor']\n",
            "\n",
            "===== Start a New Training ... =====\n",
            "MVNN_wout_freq: [Epoch 1] [Iter 1/9] Loss: 0.708420  Acc: 0.500000\n",
            "Training:  Avg Loss = 0.708420, Avg Acc = 0.500000\n",
            "Training Time:      0.134 mins\n",
            "MVNN_wout_freq: [Epoch 2] [Iter 1/9] Loss: 0.587989  Acc: 0.781250\n",
            "Training:  Avg Loss = 0.587989, Avg Acc = 0.781250\n",
            "Training Time:      0.128 mins\n",
            "MVNN_wout_freq: [Epoch 3] [Iter 1/9] Loss: 0.556926  Acc: 0.812500\n",
            "Training:  Avg Loss = 0.556926, Avg Acc = 0.812500\n",
            "Training Time:      0.129 mins\n",
            "\n",
            "===== Start Validating ... =====\n",
            "[Test] [Epoch 3] 2 / 2 batches tested. Test Loss: 0.711792\n",
            "Accuracy: 0.515625\n",
            "Balanced Accuracy: 0.47438423645320194\n",
            "Confusion Matrix:\n",
            " [[32  3]\n",
            " [28  1]]\n",
            "Cohen Kappa Score: -0.05531914893617018\n",
            "Classification Report:\n",
            "               precision    recall  f1-score   support\n",
            "\n",
            "   non-rumor       0.53      0.91      0.67        35\n",
            "       rumor       0.25      0.03      0.06        29\n",
            "\n",
            "    accuracy                           0.52        64\n",
            "   macro avg       0.39      0.47      0.37        64\n",
            "weighted avg       0.40      0.52      0.40        64\n",
            "\n",
            "\n",
            "MVNN_wout_freq: [Epoch 4] [Iter 1/9] Loss: 0.472944  Acc: 0.937500\n",
            "Training:  Avg Loss = 0.472944, Avg Acc = 0.937500\n",
            "Training Time:      0.130 mins\n",
            "MVNN_wout_freq: [Epoch 5] [Iter 1/9] Loss: 0.396942  Acc: 0.968750\n",
            "Training:  Avg Loss = 0.396942, Avg Acc = 0.968750\n",
            "Training Time:      0.129 mins\n",
            "MVNN_wout_freq: [Epoch 6] [Iter 1/9] Loss: 0.421325  Acc: 0.968750\n",
            "Training:  Avg Loss = 0.421325, Avg Acc = 0.968750\n",
            "Training Time:      0.128 mins\n",
            "\n",
            "===== Start Validating ... =====\n",
            "[Test] [Epoch 6] 2 / 2 batches tested. Test Loss: 0.741684\n",
            "Accuracy: 0.65625\n",
            "Balanced Accuracy: 0.6111111111111112\n",
            "Confusion Matrix:\n",
            " [[35  1]\n",
            " [21  7]]\n",
            "Cohen Kappa Score: 0.24137931034482762\n",
            "Classification Report:\n",
            "               precision    recall  f1-score   support\n",
            "\n",
            "   non-rumor       0.62      0.97      0.76        36\n",
            "       rumor       0.88      0.25      0.39        28\n",
            "\n",
            "    accuracy                           0.66        64\n",
            "   macro avg       0.75      0.61      0.57        64\n",
            "weighted avg       0.73      0.66      0.60        64\n",
            "\n",
            "\n",
            "MVNN_wout_freq: [Epoch 7] [Iter 1/9] Loss: 0.368898  Acc: 0.906250\n",
            "Training:  Avg Loss = 0.368898, Avg Acc = 0.906250\n",
            "Training Time:      0.128 mins\n",
            "MVNN_wout_freq: [Epoch 8] [Iter 1/9] Loss: 0.334102  Acc: 0.906250\n",
            "Training:  Avg Loss = 0.334102, Avg Acc = 0.906250\n",
            "Training Time:      0.129 mins\n",
            "MVNN_wout_freq: [Epoch 9] [Iter 1/9] Loss: 0.290979  Acc: 1.000000\n",
            "Training:  Avg Loss = 0.290979, Avg Acc = 1.000000\n",
            "Training Time:      0.129 mins\n",
            "\n",
            "===== Start Validating ... =====\n",
            "[Test] [Epoch 9] 2 / 2 batches tested. Test Loss: 0.537705\n",
            "Accuracy: 0.6875\n",
            "Balanced Accuracy: 0.6699507389162561\n",
            "Confusion Matrix:\n",
            " [[30  5]\n",
            " [15 14]]\n",
            "Cohen Kappa Score: 0.35025380710659904\n",
            "Classification Report:\n",
            "               precision    recall  f1-score   support\n",
            "\n",
            "   non-rumor       0.67      0.86      0.75        35\n",
            "       rumor       0.74      0.48      0.58        29\n",
            "\n",
            "    accuracy                           0.69        64\n",
            "   macro avg       0.70      0.67      0.67        64\n",
            "weighted avg       0.70      0.69      0.67        64\n",
            "\n",
            "\n",
            "MVNN_wout_freq: [Epoch 10] [Iter 1/9] Loss: 0.310054  Acc: 0.906250\n",
            "Training:  Avg Loss = 0.310054, Avg Acc = 0.906250\n",
            "Training Time:      0.130 mins\n",
            "MVNN_wout_freq: [Epoch 11] [Iter 1/9] Loss: 0.195791  Acc: 1.000000\n",
            "Training:  Avg Loss = 0.195791, Avg Acc = 1.000000\n",
            "Training Time:      0.129 mins\n",
            "MVNN_wout_freq: [Epoch 12] [Iter 1/9] Loss: 0.191837  Acc: 1.000000\n",
            "Training:  Avg Loss = 0.191837, Avg Acc = 1.000000\n",
            "Training Time:      0.129 mins\n",
            "\n",
            "===== Start Validating ... =====\n",
            "[Test] [Epoch 12] 2 / 2 batches tested. Test Loss: 0.574870\n",
            "Accuracy: 0.671875\n",
            "Balanced Accuracy: 0.6527777777777778\n",
            "Confusion Matrix:\n",
            " [[29  7]\n",
            " [14 14]]\n",
            "Cohen Kappa Score: 0.3142857142857143\n",
            "Classification Report:\n",
            "               precision    recall  f1-score   support\n",
            "\n",
            "   non-rumor       0.67      0.81      0.73        36\n",
            "       rumor       0.67      0.50      0.57        28\n",
            "\n",
            "    accuracy                           0.67        64\n",
            "   macro avg       0.67      0.65      0.65        64\n",
            "weighted avg       0.67      0.67      0.66        64\n",
            "\n",
            "\n",
            "MVNN_wout_freq: [Epoch 13] [Iter 1/9] Loss: 0.187237  Acc: 0.968750\n",
            "Training:  Avg Loss = 0.187237, Avg Acc = 0.968750\n",
            "Training Time:      0.130 mins\n",
            "MVNN_wout_freq: [Epoch 14] [Iter 1/9] Loss: 0.143019  Acc: 0.968750\n",
            "Training:  Avg Loss = 0.143019, Avg Acc = 0.968750\n",
            "Training Time:      0.129 mins\n",
            "MVNN_wout_freq: [Epoch 15] [Iter 1/9] Loss: 0.130447  Acc: 1.000000\n",
            "Training:  Avg Loss = 0.130447, Avg Acc = 1.000000\n",
            "Training Time:      0.129 mins\n",
            "\n",
            "===== Start Validating ... =====\n",
            "[Test] [Epoch 15] 2 / 2 batches tested. Test Loss: 0.957414\n",
            "Accuracy: 0.671875\n",
            "Balanced Accuracy: 0.6691104594330402\n",
            "Confusion Matrix:\n",
            " [[25  8]\n",
            " [13 18]]\n",
            "Cohen Kappa Score: 0.3398821218074656\n",
            "Classification Report:\n",
            "               precision    recall  f1-score   support\n",
            "\n",
            "   non-rumor       0.66      0.76      0.70        33\n",
            "       rumor       0.69      0.58      0.63        31\n",
            "\n",
            "    accuracy                           0.67        64\n",
            "   macro avg       0.68      0.67      0.67        64\n",
            "weighted avg       0.67      0.67      0.67        64\n",
            "\n",
            "\n",
            "MVNN_wout_freq: [Epoch 16] [Iter 1/9] Loss: 0.113392  Acc: 1.000000\n",
            "Training:  Avg Loss = 0.113392, Avg Acc = 1.000000\n",
            "Training Time:      0.128 mins\n",
            "MVNN_wout_freq: [Epoch 17] [Iter 1/9] Loss: 0.092333  Acc: 1.000000\n",
            "Training:  Avg Loss = 0.092333, Avg Acc = 1.000000\n",
            "Training Time:      0.128 mins\n",
            "Training is stopped at [Epoch 17] as loss is already very low (0.092333)!\n",
            "\n",
            "===== Finished Training & Validating =====\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O6jQUG4hOccu"
      },
      "source": [
        "# Training graph"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jfdMzsbAOcB-",
        "outputId": "7e2aba04-b75e-4853-e43e-cfa0184129d8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 654
        }
      },
      "source": [
        "x = list(range(1, epoch+2))\n",
        "# print(x)\n",
        "# print(epoch_avg_acc)\n",
        "\n",
        "fig, (ax1, ax2) = plt.subplots(2, 1)\n",
        "fig.suptitle('Training metrics (%s)' %(modelname))    \n",
        "ax1.plot(x, epoch_avg_acc, 'o-')\n",
        "ax1.set_ylabel('Avg Accuracy')\n",
        "ax1.set_xticks(list(range(1, epoch+2, 2)))\n",
        "\n",
        "ax2.plot(x, epoch_avg_loss, '.-')\n",
        "ax2.set_xlabel('Epoch')\n",
        "ax2.set_ylabel('Avg Loss')\n",
        "ax2.set_xticks(list(range(1, epoch+2, 2)))\n",
        "\n",
        "figname = (\"drive/My Drive/Colab Notebooks/trained_models/\"+ modelname + \"_epoch\" + str(epoch+1)\n",
        "         + \"_batch\" + str(batch_size) + \"_lr\" + str(learning_rate) + '_' + 'seed' + str(seed_no) + '_'\n",
        "         + datetime.today().strftime('%Y-%m-%d') + \".pdf\")\n",
        "\n",
        "plt.savefig(figname, bbox_inches='tight')\n"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "error",
          "ename": "FileNotFoundError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-14-956e0a7bbfcc>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     18\u001b[0m          + datetime.today().strftime('%Y-%m-%d') + \".pdf\")\n\u001b[1;32m     19\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 20\u001b[0;31m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msavefig\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfigname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbbox_inches\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'tight'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/matplotlib/pyplot.py\u001b[0m in \u001b[0;36msavefig\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    721\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0msavefig\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    722\u001b[0m     \u001b[0mfig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgcf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 723\u001b[0;31m     \u001b[0mres\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msavefig\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    724\u001b[0m     \u001b[0mfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanvas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw_idle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m   \u001b[0;31m# need this if 'transparent=True' to reset colors\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    725\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mres\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/matplotlib/figure.py\u001b[0m in \u001b[0;36msavefig\u001b[0;34m(self, fname, transparent, **kwargs)\u001b[0m\n\u001b[1;32m   2201\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpatch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_visible\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mframeon\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2202\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2203\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanvas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprint_figure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2204\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2205\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mframeon\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/matplotlib/backend_bases.py\u001b[0m in \u001b[0;36mprint_figure\u001b[0;34m(self, filename, dpi, facecolor, edgecolor, orientation, format, bbox_inches, **kwargs)\u001b[0m\n\u001b[1;32m   2124\u001b[0m                     \u001b[0morientation\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0morientation\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2125\u001b[0m                     \u001b[0mbbox_inches_restore\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0m_bbox_inches_restore\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2126\u001b[0;31m                     **kwargs)\n\u001b[0m\u001b[1;32m   2127\u001b[0m             \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2128\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mbbox_inches\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mrestore_bbox\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/matplotlib/backends/backend_pdf.py\u001b[0m in \u001b[0;36mprint_pdf\u001b[0;34m(self, filename, dpi, bbox_inches_restore, metadata, **kwargs)\u001b[0m\n\u001b[1;32m   2539\u001b[0m             \u001b[0mfile\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfilename\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_file\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2540\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2541\u001b[0;31m             \u001b[0mfile\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mPdfFile\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfilename\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetadata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmetadata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2542\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2543\u001b[0m             \u001b[0mfile\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnewPage\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwidth\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mheight\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/matplotlib/backends/backend_pdf.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, filename, metadata)\u001b[0m\n\u001b[1;32m    457\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moriginal_file_like\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    458\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtell_base\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 459\u001b[0;31m         \u001b[0mfh\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mopened\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcbook\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto_filehandle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfilename\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"wb\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreturn_opened\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    460\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mopened\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    461\u001b[0m             \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/matplotlib/cbook/__init__.py\u001b[0m in \u001b[0;36mto_filehandle\u001b[0;34m(fname, flag, return_opened, encoding)\u001b[0m\n\u001b[1;32m    401\u001b[0m             \u001b[0mfh\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbz2\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mBZ2File\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mflag\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    402\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 403\u001b[0;31m             \u001b[0mfh\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mflag\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mencoding\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mencoding\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    404\u001b[0m         \u001b[0mopened\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    405\u001b[0m     \u001b[0;32melif\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'seek'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'drive/My Drive/Colab Notebooks/trained_models/MVNN_wout_freq_epoch17_batch32_lr0.0001_seed0_2020-11-01.pdf'"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gC1SLtQjDXck"
      },
      "source": [
        "# Save the trained model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6ZjCLDm-DWt6",
        "outputId": "743a3025-7b6b-4645-b314-339de0fd6ad0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Specify a path to your local drive\n",
        "PATH = ('drive/My Drive/Colab Notebooks/' + modelname + \"_epoch\" + str(epoch+1)\n",
        "         + \"_batch\" + str(batch_size) + \"_lr\" + str(learning_rate) + '_' + 'seed' + str(seed_no) + '_'\n",
        "         + datetime.today().strftime('%Y-%m-%d') + \".pt\")\n",
        "print(PATH)\n",
        "\n",
        "# Save the trained model\n",
        "torch.save(model, PATH)"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "drive/My Drive/Colab Notebooks/MVNN_wout_freq_epoch17_batch32_lr0.0001_seed0_2020-11-01.pt\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zYR3Z7xgYU18"
      },
      "source": [
        "## Load the trained model from google drive share link id"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cpZXxMnBeXbU",
        "outputId": "cbdfcd84-22e8-4f43-ad01-5f5fd76c60be",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Download the trained full MVNN model\n",
        "!gdown --id 1-1Io_bGiir9Wq4cgwzkdNrVzseRYX4pa\n",
        "PATH = '/content/MVNN_epoch16_batch32_lr0.0001_seed0_2020-10-31.pt'\n",
        "\n",
        "# Download the trained MVNN without frequency\n",
        "# !gdown --id 1lAYnZ4OZbivnlkkkzWpc9F6GTLRqpRjO\n",
        "# PATH = '/content/MVNN_wout_freq_epoch19_batch32_lr0.0001_seed0_2020-10-31.pt'\n",
        "# model = torch.load(PATH)"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Downloading...\n",
            "From: https://drive.google.com/uc?id=1-1Io_bGiir9Wq4cgwzkdNrVzseRYX4pa\n",
            "To: /content/MVNN_epoch16_batch32_lr0.0001_seed0_2020-10-31.pt\n",
            "292MB [00:01, 236MB/s]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lNsR5NuQYnL3",
        "outputId": "4f958676-28c4-4c8d-f852-16ff83731be2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "report_every = 10\n",
        "acc, loss = 0, 0\n",
        "cnt = 0\n",
        "model.eval()\n",
        "y_true = []\n",
        "y_pred = []\n",
        "with torch.no_grad():\n",
        "    print('\\n===== Start Validating ... =====')\n",
        "    for data in testloader:\n",
        "        Xp, Xf = data[0].float().to(device), data[1].float().to(device)\n",
        "        y = data[2].to(device)\n",
        "\n",
        "        # prediction\n",
        "        out = model(Xp, Xf)        \n",
        "        pred = torch.argmax(out, dim=1)\n",
        "\n",
        "        y_true.append(y)\n",
        "        y_pred.append(pred)\n",
        "\n",
        "        cnt += 1\n",
        "\n",
        "        if cnt % report_every == 0:\n",
        "            print(\"[Test] %d / %d batches tested\" % (cnt, testloader.__len__()))        \n",
        "\n",
        "    print(\"[Test] %d / %d batches tested\" % (cnt, testloader.__len__()))\n",
        "    y_true = torch.cat(y_true, dim=0)\n",
        "    y_pred = torch.cat(y_pred, dim=0)\n",
        "    target_names = ['non-rumor', 'rumor']\n",
        "    print_metrics(y_true.cpu(), y_pred.cpu(), target_names)"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "===== Start Validating ... =====\n",
            "[Test] 2 / 2 batches tested\n",
            "Accuracy: 0.453125\n",
            "Balanced Accuracy: 0.47044334975369456\n",
            "Confusion Matrix:\n",
            " [[10 25]\n",
            " [10 19]]\n",
            "Cohen Kappa Score: -0.05660377358490565\n",
            "Classification Report:\n",
            "               precision    recall  f1-score   support\n",
            "\n",
            "   non-rumor       0.50      0.29      0.36        35\n",
            "       rumor       0.43      0.66      0.52        29\n",
            "\n",
            "    accuracy                           0.45        64\n",
            "   macro avg       0.47      0.47      0.44        64\n",
            "weighted avg       0.47      0.45      0.43        64\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}