wv_mlp_genres_resnet.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8e62d2ed",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import pickle as pkl\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.metrics import precision_score\n",
    "from sklearn.metrics import f1_score\n",
    "from sklearn.metrics import recall_score"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa3de7c2",
   "metadata": {},
   "source": [
    "Loading and concatenating the word2vec tensor and ResNet representation generated for our dataset which will serve as input features to the MLP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "0b288a33",
   "metadata": {},
   "outputs": [],
   "source": [
    "wv  = torch.load(\"./dataset/word2vec_emb_tensor.pkl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "cf669607",
   "metadata": {},
   "outputs": [],
   "source": [
    "cnn = torch.load(\"./dataset/cnn_resnet_emb_tensor.pkl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "606022e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "X = torch.cat((wv,cnn),dim=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "51a0152f",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"./dataset/books_with_genres.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c776257",
   "metadata": {},
   "source": [
    "Setting the output labels for the classification of genre into fiction/non-fiction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "248de6c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"fiction_binary\"] = np.where(df['binary_category']=='fiction', 1, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "da203ccb",
   "metadata": {},
   "outputs": [],
   "source": [
    "y = df[\"fiction_binary\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "6e1915f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "y = y.to_numpy()\n",
    "y = torch.from_numpy(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "4b265697",
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train = X[[i for i in range(4000)]]\n",
    "X_test = X[[i for i in range(4000,5000)]]\n",
    "y_train = y[[i for i in range(4000)]]\n",
    "y_test = y[[i for i in range(4000, 5000)]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "6da42d67",
   "metadata": {},
   "outputs": [],
   "source": [
    "y_train=y_train.long()\n",
    "y_test=y_test.long()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b6f9603",
   "metadata": {},
   "source": [
    "Defining the MLP module and running it on GPU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "77e5d1fb",
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device(\"cuda\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "9c2bac9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MLP(nn.Module):\n",
    "    def __init__(self, input_size, output_size, hidden_size):\n",
    "        super(MLP, self).__init__()\n",
    "        self.fc1 = nn.Linear(input_size, hidden_size)\n",
    "        self.fc2 = nn.Linear(hidden_size, output_size)\n",
    "        self.relu1 = nn.ReLU()\n",
    "\n",
    "    def forward(self, x):\n",
    "        out = self.fc1(x)\n",
    "        out = self.relu1(out)\n",
    "        out = self.fc2(out)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "54f2c423",
   "metadata": {},
   "outputs": [],
   "source": [
    "input_size = wv.shape[1]+cnn.shape[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "d9b9c2ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "net = MLP(input_size,2,512)\n",
    "net = net.to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4d9d3ad",
   "metadata": {},
   "source": [
    "Using CrossEntropyLoss for calculation of loss and Adam for optimisation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "4e1fe1db",
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer=torch.optim.Adam( net.parameters() , lr=5e-4 )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89f91399",
   "metadata": {},
   "source": [
    "Training the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "e9b29d6d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.optim as optim\n",
    "from random import randint\n",
    "\n",
    "bs = 1\n",
    "\n",
    "for epoch in range(50):\n",
    "\n",
    "    for iter in range(1,500):\n",
    "        # create a minibatch\n",
    "        indices=torch.LongTensor(bs).random_(0,4000)\n",
    "        minibatch_data =  X_train[indices].to(device)\n",
    "        minibatch_label = y_train[indices].to(device)\n",
    "\n",
    "        #reshape them to fit the network\n",
    "        inputs=minibatch_data.view(bs,1100)\n",
    "\n",
    "        inputs.requires_grad_()\n",
    "        prob=net(inputs)\n",
    "\n",
    "        loss = criterion(prob, minibatch_label)    \n",
    "        optimizer.zero_grad()       \n",
    "        loss.backward()\n",
    "        optimizer.step()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "076bd326",
   "metadata": {},
   "source": [
    "Testing the model and calculating f1, accuracy, precision and recall"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "bc2ddb48",
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = []\n",
    "y_true = []\n",
    "\n",
    "bs = 1\n",
    "\n",
    "for i in range(0,1000,bs):\n",
    "\n",
    "    # extract the minibatch\n",
    "    minibatch_data =  X_test[i:i+bs].to(device)\n",
    "    minibatch_label= y_test[i:i+bs].to(device)\n",
    "\n",
    "    # reshape the minibatch\n",
    "    inputs = minibatch_data.view(bs,input_size)\n",
    "\n",
    "    with torch.set_grad_enabled(False):\n",
    "    # feed it to the network\n",
    "        scores=net( inputs ) \n",
    "        scores = scores.argmax(dim=1)\n",
    "        scores = scores.long()\n",
    "        y_pred.append(scores.to('cpu'))\n",
    "        y_true.append(minibatch_label.to('cpu'))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "6f41de96",
   "metadata": {},
   "outputs": [],
   "source": [
    "true = []\n",
    "for i in y_true:\n",
    "    true.append(i.item())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "b8c99f6b",
   "metadata": {},
   "outputs": [],
   "source": [
    "pred = []\n",
    "for i in y_pred:\n",
    "    pred.append(i.item())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "99fd55e1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "f1 score on test set  = 0.7503852080123267\n",
      "accuracy score on test set  = 0.676\n",
      "precision score on test set  = 0.7645211930926217\n",
      "recall score on test set  = 0.7367624810892587\n"
     ]
    }
   ],
   "source": [
    "total_f1 = f1_score(pred,true)\n",
    "total_accuracy = accuracy_score(pred,true)\n",
    "total_precision = precision_score(pred,true)\n",
    "total_recall = recall_score(pred,true)\n",
    "\n",
    "print( 'f1 score on test set  =', total_f1)\n",
    "print( 'accuracy score on test set  =', total_accuracy)\n",
    "print( 'precision score on test set  =', total_precision)\n",
    "print( 'recall score on test set  =', total_recall)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "718b2533",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}