lstm_cnn_imdb.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Wke9GGY-Vhi9",
    "outputId": "38a8f7e3-331f-4f81-ea49-7c5c4c4e59a2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mounted at /content/gdrive/\n"
     ]
    }
   ],
   "source": [
    "from google.colab import drive\n",
    "drive.mount('/content/gdrive/')\n",
    "import sys\n",
    "import os\n",
    "prefix = '/content/gdrive/My Drive/'\n",
    "# modify \"customized_path_to_your_homework\" here to where you uploaded your homework\n",
    "customized_path_to_your_homework = 'IDLSProject-main-2'\n",
    "sys_path = os.path.join(prefix, customized_path_to_your_homework)\n",
    "sys.path.append(sys_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "zbpmqPd2Vzqt",
    "outputId": "c4aaf00f-0754-4b5c-d214-f7333926f993"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/content/gdrive/My Drive/IDLSProject-main-2\n"
     ]
    }
   ],
   "source": [
    "%cd '/content/gdrive/My Drive/IDLSProject-main-2'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "QJUW-ZwSV9sY",
    "outputId": "f08d8f4e-fca6-4a9c-d4da-1ceb1960e3f5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([10000, 1])\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import os\n",
    "import pickle\n",
    "import torch\n",
    "import torch.utils.data\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "data_dir = './data/pytorch'\n",
    "with open(os.path.join(data_dir, 'word_dict_qrnn.pkl'), \"rb\") as f:\n",
    "    word_dict = pickle.load(f)\n",
    "\n",
    "train = pd.read_csv(os.path.join(data_dir, 'train_qrnn.csv'), header=None, names=None)\n",
    "test_sample = pd.read_csv(os.path.join(data_dir, 'test_qrnn.csv'), header=None, names=None)\n",
    "\n",
    "test, val = train_test_split(test_sample, test_size=0.5)\n",
    "train.shape, test.shape, val.shape\n",
    "\n",
    "\n",
    "# Turn the input pandas dataframe into tensors\n",
    "train_y = torch.from_numpy(train[[0]].values).float()\n",
    "train_X = torch.from_numpy(train.drop([0, 1], axis=1).values).long()\n",
    "\n",
    "# Build the dataset\n",
    "train_ds = torch.utils.data.TensorDataset(train_X, train_y)\n",
    "# Build the dataloader\n",
    "train_dl = torch.utils.data.DataLoader(train_ds, batch_size=50)\n",
    "\n",
    "######val data\n",
    "# Turn the input pandas dataframe into tensors\n",
    "val_y = torch.from_numpy(val[[0]].values).float()\n",
    "val_X = torch.from_numpy(val.drop([0, 1], axis=1).values).long()\n",
    "\n",
    "# Build the dataset\n",
    "val_ds = torch.utils.data.TensorDataset(val_X, val_y)\n",
    "# Build the dataloader\n",
    "val_dl = torch.utils.data.DataLoader(val_ds, batch_size=50)\n",
    "\n",
    "\n",
    "#### Test data\n",
    "# Turn the input pandas dataframe into tensors\n",
    "test_y = torch.from_numpy(test[[0]].values).float()\n",
    "test_X = torch.from_numpy(test.drop([0, 1], axis=1).values).long()\n",
    "\n",
    "# Build the dataset\n",
    "test_ds = torch.utils.data.TensorDataset(test_X, test_y)\n",
    "# Build the dataloader\n",
    "test_dl = torch.utils.data.DataLoader(test_ds, batch_size=50)\n",
    "print(test_y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "AfhXAHD_WEh8"
   },
   "outputs": [],
   "source": [
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "epochs = 10\n",
    "batch_size = 50\n",
    "learning_rate = 0.001\n",
    "seq_len = 500\n",
    "dropout = 0.5\n",
    "filter_size = 100\n",
    "vocab_size = 5000\n",
    "embed_dims = 32\n",
    "hidden_size = 100\n",
    "kernel_size = [3,4,5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "_Yp0LBkIWHEw"
   },
   "outputs": [],
   "source": [
    "# write to file.\n",
    "filename = \"lstm-cnn-imdb.csv\"\n",
    "def write_to_csv(epochs, train_loss, train_acc, val_loss, val_acc, time_train):\n",
    "    epoch = [i for i in range(epochs)]\n",
    "    df_metrics = pd.DataFrame(list(zip(epoch, train_loss, train_acc, val_loss, val_acc, time_train)), columns =['Epoch', 'train_loss', 'train_acc', 'val_loss', 'val_acc', 'train_time'])\n",
    "    df_metrics.to_csv(filename, index=False)\n",
    "    \n",
    "def append_to_csv(epochs, accuracy):\n",
    "    acc = [accuracy for i in range(epochs)]\n",
    "    df_csv = pd.read_csv(filename)\n",
    "    df_csv['Test_Accuracy']  = acc\n",
    "    df_csv.to_csv(filename, index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "REymrbOqWO-G"
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import numpy as np\n",
    "class Combine(nn.Module):\n",
    "    def __init__(self,vocab_size, embed_size, filter_size, kernel_size, dropout, seq_len,hidden_size):\n",
    "        super(Combine, self).__init__()\n",
    "        self.embedding = nn.Embedding(vocab_size, embed_size, padding_idx=0)\n",
    "        self.lstm = nn.LSTM(input_size = embed_size, hidden_size = hidden_size,num_layers=1,batch_first=True)\n",
    "        self.conv1 = torch.nn.Conv2d(1,filter_size,kernel_size=[kernel_size[0],hidden_size])\n",
    "        self.conv2 = torch.nn.Conv2d(1,filter_size,kernel_size=[kernel_size[1],hidden_size])\n",
    "        self.conv3 = torch.nn.Conv2d(1,filter_size,kernel_size=[kernel_size[2],hidden_size])\n",
    "        self.mp1 = torch.nn.MaxPool1d(seq_len+1-kernel_size[0])\n",
    "        self.mp2 = torch.nn.MaxPool1d(seq_len+1-kernel_size[1])\n",
    "        self.mp3 = torch.nn.MaxPool1d(seq_len+1-kernel_size[2])\n",
    "        self.dropout = torch.nn.Dropout(dropout)\n",
    "        self.dense = nn.Linear(3*hidden_size,1)\n",
    "        self.sig = nn.Sigmoid()\n",
    "        self.word_dict = None\n",
    "\n",
    "\n",
    "    def forward(self, x,target):\n",
    "    \n",
    "        embeds = self.embedding(x)\n",
    "        # print('embedds')\n",
    "        # print(embeds.shape)\n",
    "        lstm_out, _ = self.lstm(embeds)\n",
    "        # print('lstm output')\n",
    "        # print(lstm_out.shape)\n",
    "        lstm_out = lstm_out.clone()\n",
    "        lstm_out.unsqueeze_(1)\n",
    "        # print('lstm output after')\n",
    "        # print(lstm_out.shape)\n",
    "        x1 = torch.tanh(self.dropout(self.conv1(lstm_out))).squeeze(3)\n",
    "        x2 = torch.tanh(self.dropout(self.conv2(lstm_out))).squeeze(3)\n",
    "        x3 = torch.tanh(self.dropout(self.conv3(lstm_out))).squeeze(3)\n",
    "        # print('x1.shape')\n",
    "        # print(x1.shape)\n",
    "        f1 = self.mp1(x1).squeeze(2)\n",
    "        # print('f1')\n",
    "        # print(f1.shape)\n",
    "        f2 = self.mp2(x2).squeeze(2)\n",
    "        # print('f2')\n",
    "        # print(f2.shape)\n",
    "        f3 = self.mp3(x3).squeeze(2)\n",
    "        # print('f3')\n",
    "        # print(f3.shape)\n",
    "        hidden = torch.cat([f1,f2,f3],dim=1)\n",
    "        logits = self.dense(hidden)\n",
    "        prediction = torch.sigmoid(logits)\n",
    "        target = target.view([-1,1])\n",
    "        correct_pred = torch.eq(torch.round(prediction).type(target.type()),target)\n",
    "        accuracy = torch.sum(correct_pred)\n",
    "        return prediction, accuracy\n",
    "        # return self.sig(out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "xBOE2V9Co-1p"
   },
   "outputs": [],
   "source": [
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "epochs = 10\n",
    "batch_size = 50\n",
    "learning_rate = 0.001\n",
    "embed_size = 300\n",
    "seq_len = 500\n",
    "dropout = 0.5\n",
    "filter_size = 100\n",
    "vocab_size = 5000\n",
    "embed_dims = 32\n",
    "kernel_size = [3,4,5]\n",
    "model = Combine(vocab_size, embed_dims, filter_size, kernel_size, dropout, seq_len,hidden_size).to(device).to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "wZ2NQqkBWV_z",
    "outputId": "8806d17d-b01b-4bf5-ba96-469b0e0554ba"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0/10 \tIteration: 0 \t\tTrain Loss: 0.694 \tTrain Accuracy: 50.00\n",
      "Epoch: 0/10 \tIteration: 100 \t\tTrain Loss: 0.619 \tTrain Accuracy: 64.00\n",
      "Epoch: 0/10 \tIteration: 200 \t\tTrain Loss: 0.527 \tTrain Accuracy: 78.00\n",
      "Epoch: 0/10 \tIteration: 300 \t\tTrain Loss: 0.440 \tTrain Accuracy: 80.00\n",
      "Epoch: 0/10 \tIteration: 400 \t\tTrain Loss: 0.451 \tTrain Accuracy: 78.00\n",
      "Epoch: 0/10 \tIteration: 500 \t\tTrain Loss: 0.353 \tTrain Accuracy: 88.00\n",
      "\tTrain Loss: 0.502 \tTrain Acc: 74.397\n",
      "\t\tVal Loss: 0.408 \t\tVal Acc: 83.150\n",
      "Time to train epoch: 16.967209577560425 s\n",
      "Epoch: 1/10 \tIteration: 600 \t\tTrain Loss: 0.297 \tTrain Accuracy: 90.00\n",
      "Epoch: 1/10 \tIteration: 700 \t\tTrain Loss: 0.292 \tTrain Accuracy: 90.00\n",
      "Epoch: 1/10 \tIteration: 800 \t\tTrain Loss: 0.297 \tTrain Accuracy: 92.00\n",
      "Epoch: 1/10 \tIteration: 900 \t\tTrain Loss: 0.272 \tTrain Accuracy: 88.00\n",
      "Epoch: 1/10 \tIteration: 1000 \t\tTrain Loss: 0.326 \tTrain Accuracy: 88.00\n",
      "Epoch: 1/10 \tIteration: 1100 \t\tTrain Loss: 0.234 \tTrain Accuracy: 90.00\n",
      "\tTrain Loss: 0.336 \tTrain Acc: 85.400\n",
      "\t\tVal Loss: 0.337 \t\tVal Acc: 85.820\n",
      "Time to train epoch: 15.800920486450195 s\n",
      "Epoch: 2/10 \tIteration: 1200 \t\tTrain Loss: 0.199 \tTrain Accuracy: 94.00\n",
      "Epoch: 2/10 \tIteration: 1300 \t\tTrain Loss: 0.193 \tTrain Accuracy: 94.00\n",
      "Epoch: 2/10 \tIteration: 1400 \t\tTrain Loss: 0.227 \tTrain Accuracy: 92.00\n",
      "Epoch: 2/10 \tIteration: 1500 \t\tTrain Loss: 0.245 \tTrain Accuracy: 88.00\n",
      "Epoch: 2/10 \tIteration: 1600 \t\tTrain Loss: 0.268 \tTrain Accuracy: 88.00\n",
      "Epoch: 2/10 \tIteration: 1700 \t\tTrain Loss: 0.165 \tTrain Accuracy: 96.00\n",
      "\tTrain Loss: 0.272 \tTrain Acc: 88.657\n",
      "\t\tVal Loss: 0.309 \t\tVal Acc: 86.870\n",
      "Time to train epoch: 15.799878358840942 s\n",
      "Epoch: 3/10 \tIteration: 1800 \t\tTrain Loss: 0.158 \tTrain Accuracy: 96.00\n",
      "Epoch: 3/10 \tIteration: 1900 \t\tTrain Loss: 0.118 \tTrain Accuracy: 98.00\n",
      "Epoch: 3/10 \tIteration: 2000 \t\tTrain Loss: 0.189 \tTrain Accuracy: 94.00\n",
      "Epoch: 3/10 \tIteration: 2100 \t\tTrain Loss: 0.191 \tTrain Accuracy: 92.00\n",
      "Epoch: 3/10 \tIteration: 2200 \t\tTrain Loss: 0.189 \tTrain Accuracy: 94.00\n",
      "Epoch: 3/10 \tIteration: 2300 \t\tTrain Loss: 0.098 \tTrain Accuracy: 96.00\n",
      "\tTrain Loss: 0.228 \tTrain Acc: 90.920\n",
      "\t\tVal Loss: 0.300 \t\tVal Acc: 87.040\n",
      "Time to train epoch: 15.79297661781311 s\n",
      "Epoch: 4/10 \tIteration: 2400 \t\tTrain Loss: 0.145 \tTrain Accuracy: 98.00\n",
      "Epoch: 4/10 \tIteration: 2500 \t\tTrain Loss: 0.079 \tTrain Accuracy: 100.00\n",
      "Epoch: 4/10 \tIteration: 2600 \t\tTrain Loss: 0.142 \tTrain Accuracy: 96.00\n",
      "Epoch: 4/10 \tIteration: 2700 \t\tTrain Loss: 0.146 \tTrain Accuracy: 94.00\n",
      "Epoch: 4/10 \tIteration: 2800 \t\tTrain Loss: 0.127 \tTrain Accuracy: 96.00\n",
      "Epoch: 4/10 \tIteration: 2900 \t\tTrain Loss: 0.072 \tTrain Accuracy: 98.00\n",
      "\tTrain Loss: 0.189 \tTrain Acc: 92.800\n",
      "\t\tVal Loss: 0.320 \t\tVal Acc: 86.580\n",
      "Time to train epoch: 15.796275854110718 s\n",
      "Epoch: 5/10 \tIteration: 3000 \t\tTrain Loss: 0.126 \tTrain Accuracy: 96.00\n",
      "Epoch: 5/10 \tIteration: 3100 \t\tTrain Loss: 0.068 \tTrain Accuracy: 100.00\n",
      "Epoch: 5/10 \tIteration: 3200 \t\tTrain Loss: 0.120 \tTrain Accuracy: 96.00\n",
      "Epoch: 5/10 \tIteration: 3300 \t\tTrain Loss: 0.112 \tTrain Accuracy: 96.00\n",
      "Epoch: 5/10 \tIteration: 3400 \t\tTrain Loss: 0.069 \tTrain Accuracy: 100.00\n",
      "Epoch: 5/10 \tIteration: 3500 \t\tTrain Loss: 0.042 \tTrain Accuracy: 100.00\n",
      "\tTrain Loss: 0.151 \tTrain Acc: 94.480\n",
      "\t\tVal Loss: 0.338 \t\tVal Acc: 86.650\n",
      "Time to train epoch: 15.800511598587036 s\n",
      "Epoch: 6/10 \tIteration: 3600 \t\tTrain Loss: 0.102 \tTrain Accuracy: 96.00\n",
      "Epoch: 6/10 \tIteration: 3700 \t\tTrain Loss: 0.119 \tTrain Accuracy: 92.00\n",
      "Epoch: 6/10 \tIteration: 3800 \t\tTrain Loss: 0.107 \tTrain Accuracy: 96.00\n",
      "Epoch: 6/10 \tIteration: 3900 \t\tTrain Loss: 0.081 \tTrain Accuracy: 98.00\n",
      "Epoch: 6/10 \tIteration: 4000 \t\tTrain Loss: 0.077 \tTrain Accuracy: 96.00\n",
      "Epoch: 6/10 \tIteration: 4100 \t\tTrain Loss: 0.041 \tTrain Accuracy: 100.00\n",
      "\tTrain Loss: 0.129 \tTrain Acc: 95.147\n",
      "\t\tVal Loss: 0.339 \t\tVal Acc: 87.550\n",
      "Time to train epoch: 15.809478521347046 s\n",
      "Epoch: 7/10 \tIteration: 4200 \t\tTrain Loss: 0.043 \tTrain Accuracy: 98.00\n",
      "Epoch: 7/10 \tIteration: 4300 \t\tTrain Loss: 0.091 \tTrain Accuracy: 98.00\n",
      "Epoch: 7/10 \tIteration: 4400 \t\tTrain Loss: 0.112 \tTrain Accuracy: 94.00\n",
      "Epoch: 7/10 \tIteration: 4500 \t\tTrain Loss: 0.091 \tTrain Accuracy: 96.00\n",
      "Epoch: 7/10 \tIteration: 4600 \t\tTrain Loss: 0.018 \tTrain Accuracy: 100.00\n",
      "Epoch: 7/10 \tIteration: 4700 \t\tTrain Loss: 0.009 \tTrain Accuracy: 100.00\n",
      "\tTrain Loss: 0.112 \tTrain Acc: 95.667\n",
      "\t\tVal Loss: 0.454 \t\tVal Acc: 85.140\n",
      "Time to train epoch: 15.805935859680176 s\n",
      "Epoch: 8/10 \tIteration: 4800 \t\tTrain Loss: 0.076 \tTrain Accuracy: 96.00\n",
      "Epoch: 8/10 \tIteration: 4900 \t\tTrain Loss: 0.041 \tTrain Accuracy: 100.00\n",
      "Epoch: 8/10 \tIteration: 5000 \t\tTrain Loss: 0.058 \tTrain Accuracy: 98.00\n",
      "Epoch: 8/10 \tIteration: 5100 \t\tTrain Loss: 0.107 \tTrain Accuracy: 92.00\n",
      "Epoch: 8/10 \tIteration: 5200 \t\tTrain Loss: 0.011 \tTrain Accuracy: 100.00\n",
      "Epoch: 8/10 \tIteration: 5300 \t\tTrain Loss: 0.012 \tTrain Accuracy: 100.00\n",
      "\tTrain Loss: 0.077 \tTrain Acc: 97.357\n",
      "\t\tVal Loss: 0.506 \t\tVal Acc: 85.400\n",
      "Time to train epoch: 15.810338735580444 s\n",
      "Epoch: 9/10 \tIteration: 5400 \t\tTrain Loss: 0.027 \tTrain Accuracy: 100.00\n",
      "Epoch: 9/10 \tIteration: 5500 \t\tTrain Loss: 0.045 \tTrain Accuracy: 100.00\n",
      "Epoch: 9/10 \tIteration: 5600 \t\tTrain Loss: 0.082 \tTrain Accuracy: 98.00\n",
      "Epoch: 9/10 \tIteration: 5700 \t\tTrain Loss: 0.069 \tTrain Accuracy: 96.00\n",
      "Epoch: 9/10 \tIteration: 5800 \t\tTrain Loss: 0.008 \tTrain Accuracy: 100.00\n",
      "Epoch: 9/10 \tIteration: 5900 \t\tTrain Loss: 0.024 \tTrain Accuracy: 98.00\n",
      "\tTrain Loss: 0.054 \tTrain Acc: 98.257\n",
      "\t\tVal Loss: 0.574 \t\tVal Acc: 85.350\n",
      "Time to train epoch: 15.802704095840454 s\n",
      "Test Loss: 0.598 \tTest Acc: 84.740\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "import numpy as np\n",
    "\n",
    "criterion = torch.nn.BCELoss().to(device)\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)\n",
    "counter = 0\n",
    "CNN_acc = []\n",
    "CNN_valacc = []\n",
    "train_loss_epoch = []\n",
    "train_acc_epoch = []\n",
    "val_loss_epoch = []\n",
    "val_acc_epoch = []\n",
    "time_epoch = []\n",
    "model.train()\n",
    "for e in range(epochs):\n",
    "    start_time = time.time()\n",
    "    train_loss = []\n",
    "    train_acc = []\n",
    "    for inputs, labels in train_dl:\n",
    "        inputs, labels = inputs.cuda(), labels.cuda()\n",
    "        model.zero_grad()\n",
    "        logits, accuracy = model(inputs,labels)\n",
    "        loss = criterion(logits,labels.float())\n",
    "        loss.backward()\n",
    "        nn.utils.clip_grad_norm_(model.parameters(), 5)\n",
    "        optimizer.step()\n",
    "        train_loss.append(loss.item())\n",
    "        train_acc.append(accuracy.item()*100/batch_size)\n",
    "        if counter%100==0:\n",
    "            print(\"Epoch: {}/{}\".format(e,epochs),\n",
    "                         \"\\tIteration: {}\".format(counter),\n",
    "                         \"\\t\\tTrain Loss: {:.3f}\".format(loss.item()),\n",
    "                         \"\\tTrain Accuracy: {:.2f}\".format(accuracy.item()*100/batch_size))\n",
    "            CNN_acc.append(accuracy.item()*100/batch_size)\n",
    "        counter += 1\n",
    "    train_loss_epoch.append(np.round(np.mean(train_loss), 3))\n",
    "    train_acc_epoch.append(np.round(np.mean(train_acc), 3))\n",
    "    print(\"\\tTrain Loss: {:.3f}\".format(np.mean(train_loss)), \"\\tTrain Acc: {:.3f}\".format(np.mean(train_acc)))\n",
    "\n",
    "    with torch.no_grad():\n",
    "        model.eval()\n",
    "        val_acc = []\n",
    "        val_loss = []\n",
    "        for inputs, labels in val_dl:\n",
    "            inputs_val, labels_val = inputs.cuda(), labels.cuda()\n",
    "            logits_val,accuracy_val = model(inputs_val,labels_val)\n",
    "            loss_val = criterion(logits_val,labels_val.float())\n",
    "            val_acc.append(accuracy_val.item()*100/batch_size)\n",
    "            val_loss.append(loss_val.item())\n",
    "        val_loss_epoch.append(np.round(np.mean(val_loss), 3))\n",
    "        val_acc_epoch.append(np.round(np.mean(val_acc), 3))\n",
    "        print(\"\\t\\tVal Loss: {:.3f}\".format(np.mean(val_loss)), \"\\t\\tVal Acc: {:.3f}\".format(np.mean(val_acc)))\n",
    "        CNN_valacc.append(np.mean(val_acc))\n",
    "        model.train()\n",
    "        \n",
    "    end_time = time.time()-start_time\n",
    "    print(\"Time to train epoch: {0} s\".format(end_time))\n",
    "    time_epoch.append(np.round(end_time, 3))\n",
    "    \n",
    "write_to_csv(epochs, train_loss_epoch, train_acc_epoch, val_loss_epoch, val_acc_epoch, time_epoch)\n",
    "    \n",
    "with torch.no_grad():\n",
    "    model.eval()\n",
    "    test_acc = []\n",
    "    test_loss = []\n",
    "    for inputs, labels in test_dl:\n",
    "        input_test, labels_test = inputs.cuda(), labels.cuda()\n",
    "        logits_test,accuracy_test = model(input_test,labels_test)\n",
    "        loss_test = criterion(logits_test,labels_test.float())\n",
    "        test_acc.append(accuracy_test.item()*100/batch_size)\n",
    "        test_loss.append(loss_test.item())\n",
    "    print(\"Test Loss: {:.3f}\".format(np.mean(test_loss)), \"\\tTest Acc: {:.3f}\".format(np.mean(test_acc)))\n",
    "    append_to_csv(epochs, np.round(np.mean(test_acc),3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "z4Tjh75SWd8c"
   },
   "outputs": [],
   "source": [
    "torch.save(model.state_dict(),\"./lstm-cnn-imdb.pth\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "name": "lstm-cnn-imdb.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "my_env2_gpu",
   "language": "python",
   "name": "my_env2_gpu"
  },
  "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}