lstm_cnn_amazon.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "lstm-cnn-amazon.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "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)"
      ],
      "metadata": {
        "id": "3UJYgAhq1zrj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "%cd '/content/gdrive/My Drive/IDLSProject-main'"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Fafsl0NK1xrv",
        "outputId": "47482737-3559-4ba8-edf4-6269ca13f20b"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/content/gdrive/My Drive/IDLSProject-main\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "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",
        "\n",
        "with open(os.path.join(data_dir, 'word_dict_amazon.pkl'), \"rb\") as f:\n",
        "    word_dict = pickle.load(f)\n",
        "    \n",
        "train = pd.read_csv(os.path.join(data_dir, 'train_amazon.csv'), header=None, names=None)\n",
        "test_sample = pd.read_csv(os.path.join(data_dir, 'test_amazon.csv'), header=None, names=None)\n",
        "print(train.shape, test_sample.shape)\n",
        "\n",
        "\n",
        "test, val = train_test_split(test_sample, test_size=0.5)\n",
        "train.shape, test.shape, val.shape\n",
        "\n",
        "#drop rows\n",
        "test.drop(test.tail(227).index,inplace = True)\n",
        "val.drop(val.tail(228).index,inplace = True)\n",
        "test.shape, val.shape\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, val_y.shape)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QJUW-ZwSV9sY",
        "outputId": "e876ce73-df32-4e79-8718-d5223d09a226"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(83000, 502) (21975, 502)\n",
            "torch.Size([10760, 1]) torch.Size([10760, 1])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# write to file.\n",
        "filename = \"lstm-cnn-amazon.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)"
      ],
      "metadata": {
        "id": "_Yp0LBkIWHEw"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "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)"
      ],
      "metadata": {
        "id": "REymrbOqWO-G"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "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 = 10000\n",
        "embed_dims = 32\n",
        "hidden_size = 100\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)"
      ],
      "metadata": {
        "id": "xBOE2V9Co-1p"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "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))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wZ2NQqkBWV_z",
        "outputId": "d209c5d8-89b8-449d-d3b7-22f0f205127f"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 0/10 \tIteration: 0 \t\tTrain Loss: 0.697 \tTrain Accuracy: 40.00\n",
            "Epoch: 0/10 \tIteration: 100 \t\tTrain Loss: 0.555 \tTrain Accuracy: 80.00\n",
            "Epoch: 0/10 \tIteration: 200 \t\tTrain Loss: 0.337 \tTrain Accuracy: 84.00\n",
            "Epoch: 0/10 \tIteration: 300 \t\tTrain Loss: 0.414 \tTrain Accuracy: 82.00\n",
            "Epoch: 0/10 \tIteration: 400 \t\tTrain Loss: 0.208 \tTrain Accuracy: 90.00\n",
            "Epoch: 0/10 \tIteration: 500 \t\tTrain Loss: 0.308 \tTrain Accuracy: 84.00\n",
            "Epoch: 0/10 \tIteration: 600 \t\tTrain Loss: 0.254 \tTrain Accuracy: 92.00\n",
            "Epoch: 0/10 \tIteration: 700 \t\tTrain Loss: 0.383 \tTrain Accuracy: 86.00\n",
            "Epoch: 0/10 \tIteration: 800 \t\tTrain Loss: 0.330 \tTrain Accuracy: 82.00\n",
            "Epoch: 0/10 \tIteration: 900 \t\tTrain Loss: 0.158 \tTrain Accuracy: 94.00\n",
            "Epoch: 0/10 \tIteration: 1000 \t\tTrain Loss: 0.344 \tTrain Accuracy: 84.00\n",
            "Epoch: 0/10 \tIteration: 1100 \t\tTrain Loss: 0.348 \tTrain Accuracy: 86.00\n",
            "Epoch: 0/10 \tIteration: 1200 \t\tTrain Loss: 0.207 \tTrain Accuracy: 94.00\n",
            "Epoch: 0/10 \tIteration: 1300 \t\tTrain Loss: 0.184 \tTrain Accuracy: 88.00\n",
            "Epoch: 0/10 \tIteration: 1400 \t\tTrain Loss: 0.315 \tTrain Accuracy: 88.00\n",
            "Epoch: 0/10 \tIteration: 1500 \t\tTrain Loss: 0.312 \tTrain Accuracy: 90.00\n",
            "Epoch: 0/10 \tIteration: 1600 \t\tTrain Loss: 0.198 \tTrain Accuracy: 92.00\n",
            "\tTrain Loss: 0.337 \tTrain Acc: 85.165\n",
            "\t\tVal Loss: 0.300 \t\tVal Acc: 86.750\n",
            "Time to train epoch: 52.233704566955566 s\n",
            "Epoch: 1/10 \tIteration: 1700 \t\tTrain Loss: 0.177 \tTrain Accuracy: 96.00\n",
            "Epoch: 1/10 \tIteration: 1800 \t\tTrain Loss: 0.303 \tTrain Accuracy: 86.00\n",
            "Epoch: 1/10 \tIteration: 1900 \t\tTrain Loss: 0.365 \tTrain Accuracy: 80.00\n",
            "Epoch: 1/10 \tIteration: 2000 \t\tTrain Loss: 0.239 \tTrain Accuracy: 88.00\n",
            "Epoch: 1/10 \tIteration: 2100 \t\tTrain Loss: 0.236 \tTrain Accuracy: 90.00\n",
            "Epoch: 1/10 \tIteration: 2200 \t\tTrain Loss: 0.370 \tTrain Accuracy: 80.00\n",
            "Epoch: 1/10 \tIteration: 2300 \t\tTrain Loss: 0.187 \tTrain Accuracy: 94.00\n",
            "Epoch: 1/10 \tIteration: 2400 \t\tTrain Loss: 0.196 \tTrain Accuracy: 92.00\n",
            "Epoch: 1/10 \tIteration: 2500 \t\tTrain Loss: 0.360 \tTrain Accuracy: 84.00\n",
            "Epoch: 1/10 \tIteration: 2600 \t\tTrain Loss: 0.211 \tTrain Accuracy: 88.00\n",
            "Epoch: 1/10 \tIteration: 2700 \t\tTrain Loss: 0.364 \tTrain Accuracy: 86.00\n",
            "Epoch: 1/10 \tIteration: 2800 \t\tTrain Loss: 0.316 \tTrain Accuracy: 88.00\n",
            "Epoch: 1/10 \tIteration: 2900 \t\tTrain Loss: 0.306 \tTrain Accuracy: 88.00\n",
            "Epoch: 1/10 \tIteration: 3000 \t\tTrain Loss: 0.175 \tTrain Accuracy: 92.00\n",
            "Epoch: 1/10 \tIteration: 3100 \t\tTrain Loss: 0.150 \tTrain Accuracy: 96.00\n",
            "Epoch: 1/10 \tIteration: 3200 \t\tTrain Loss: 0.338 \tTrain Accuracy: 84.00\n",
            "Epoch: 1/10 \tIteration: 3300 \t\tTrain Loss: 0.220 \tTrain Accuracy: 90.00\n",
            "\tTrain Loss: 0.265 \tTrain Acc: 88.728\n",
            "\t\tVal Loss: 0.281 \t\tVal Acc: 87.731\n",
            "Time to train epoch: 52.98013353347778 s\n",
            "Epoch: 2/10 \tIteration: 3400 \t\tTrain Loss: 0.203 \tTrain Accuracy: 94.00\n",
            "Epoch: 2/10 \tIteration: 3500 \t\tTrain Loss: 0.276 \tTrain Accuracy: 84.00\n",
            "Epoch: 2/10 \tIteration: 3600 \t\tTrain Loss: 0.150 \tTrain Accuracy: 94.00\n",
            "Epoch: 2/10 \tIteration: 3700 \t\tTrain Loss: 0.129 \tTrain Accuracy: 98.00\n",
            "Epoch: 2/10 \tIteration: 3800 \t\tTrain Loss: 0.182 \tTrain Accuracy: 92.00\n",
            "Epoch: 2/10 \tIteration: 3900 \t\tTrain Loss: 0.214 \tTrain Accuracy: 92.00\n",
            "Epoch: 2/10 \tIteration: 4000 \t\tTrain Loss: 0.191 \tTrain Accuracy: 92.00\n",
            "Epoch: 2/10 \tIteration: 4100 \t\tTrain Loss: 0.200 \tTrain Accuracy: 92.00\n",
            "Epoch: 2/10 \tIteration: 4200 \t\tTrain Loss: 0.302 \tTrain Accuracy: 90.00\n",
            "Epoch: 2/10 \tIteration: 4300 \t\tTrain Loss: 0.139 \tTrain Accuracy: 96.00\n",
            "Epoch: 2/10 \tIteration: 4400 \t\tTrain Loss: 0.182 \tTrain Accuracy: 94.00\n",
            "Epoch: 2/10 \tIteration: 4500 \t\tTrain Loss: 0.344 \tTrain Accuracy: 86.00\n",
            "Epoch: 2/10 \tIteration: 4600 \t\tTrain Loss: 0.155 \tTrain Accuracy: 96.00\n",
            "Epoch: 2/10 \tIteration: 4700 \t\tTrain Loss: 0.328 \tTrain Accuracy: 86.00\n",
            "Epoch: 2/10 \tIteration: 4800 \t\tTrain Loss: 0.391 \tTrain Accuracy: 82.00\n",
            "Epoch: 2/10 \tIteration: 4900 \t\tTrain Loss: 0.347 \tTrain Accuracy: 82.00\n",
            "\tTrain Loss: 0.235 \tTrain Acc: 90.104\n",
            "\t\tVal Loss: 0.279 \t\tVal Acc: 88.194\n",
            "Time to train epoch: 53.092127323150635 s\n",
            "Epoch: 3/10 \tIteration: 5000 \t\tTrain Loss: 0.212 \tTrain Accuracy: 92.00\n",
            "Epoch: 3/10 \tIteration: 5100 \t\tTrain Loss: 0.288 \tTrain Accuracy: 92.00\n",
            "Epoch: 3/10 \tIteration: 5200 \t\tTrain Loss: 0.085 \tTrain Accuracy: 98.00\n",
            "Epoch: 3/10 \tIteration: 5300 \t\tTrain Loss: 0.191 \tTrain Accuracy: 94.00\n",
            "Epoch: 3/10 \tIteration: 5400 \t\tTrain Loss: 0.303 \tTrain Accuracy: 86.00\n",
            "Epoch: 3/10 \tIteration: 5500 \t\tTrain Loss: 0.163 \tTrain Accuracy: 88.00\n",
            "Epoch: 3/10 \tIteration: 5600 \t\tTrain Loss: 0.248 \tTrain Accuracy: 88.00\n",
            "Epoch: 3/10 \tIteration: 5700 \t\tTrain Loss: 0.252 \tTrain Accuracy: 90.00\n",
            "Epoch: 3/10 \tIteration: 5800 \t\tTrain Loss: 0.193 \tTrain Accuracy: 94.00\n",
            "Epoch: 3/10 \tIteration: 5900 \t\tTrain Loss: 0.122 \tTrain Accuracy: 94.00\n",
            "Epoch: 3/10 \tIteration: 6000 \t\tTrain Loss: 0.378 \tTrain Accuracy: 86.00\n",
            "Epoch: 3/10 \tIteration: 6100 \t\tTrain Loss: 0.225 \tTrain Accuracy: 88.00\n",
            "Epoch: 3/10 \tIteration: 6200 \t\tTrain Loss: 0.212 \tTrain Accuracy: 88.00\n",
            "Epoch: 3/10 \tIteration: 6300 \t\tTrain Loss: 0.178 \tTrain Accuracy: 90.00\n",
            "Epoch: 3/10 \tIteration: 6400 \t\tTrain Loss: 0.219 \tTrain Accuracy: 98.00\n",
            "Epoch: 3/10 \tIteration: 6500 \t\tTrain Loss: 0.158 \tTrain Accuracy: 92.00\n",
            "Epoch: 3/10 \tIteration: 6600 \t\tTrain Loss: 0.157 \tTrain Accuracy: 98.00\n",
            "\tTrain Loss: 0.210 \tTrain Acc: 91.380\n",
            "\t\tVal Loss: 0.293 \t\tVal Acc: 88.231\n",
            "Time to train epoch: 53.74765372276306 s\n",
            "Epoch: 4/10 \tIteration: 6700 \t\tTrain Loss: 0.067 \tTrain Accuracy: 98.00\n",
            "Epoch: 4/10 \tIteration: 6800 \t\tTrain Loss: 0.224 \tTrain Accuracy: 88.00\n",
            "Epoch: 4/10 \tIteration: 6900 \t\tTrain Loss: 0.088 \tTrain Accuracy: 98.00\n",
            "Epoch: 4/10 \tIteration: 7000 \t\tTrain Loss: 0.193 \tTrain Accuracy: 92.00\n",
            "Epoch: 4/10 \tIteration: 7100 \t\tTrain Loss: 0.138 \tTrain Accuracy: 94.00\n",
            "Epoch: 4/10 \tIteration: 7200 \t\tTrain Loss: 0.082 \tTrain Accuracy: 100.00\n",
            "Epoch: 4/10 \tIteration: 7300 \t\tTrain Loss: 0.323 \tTrain Accuracy: 88.00\n",
            "Epoch: 4/10 \tIteration: 7400 \t\tTrain Loss: 0.084 \tTrain Accuracy: 96.00\n",
            "Epoch: 4/10 \tIteration: 7500 \t\tTrain Loss: 0.281 \tTrain Accuracy: 88.00\n",
            "Epoch: 4/10 \tIteration: 7600 \t\tTrain Loss: 0.084 \tTrain Accuracy: 96.00\n",
            "Epoch: 4/10 \tIteration: 7700 \t\tTrain Loss: 0.182 \tTrain Accuracy: 92.00\n",
            "Epoch: 4/10 \tIteration: 7800 \t\tTrain Loss: 0.264 \tTrain Accuracy: 88.00\n",
            "Epoch: 4/10 \tIteration: 7900 \t\tTrain Loss: 0.152 \tTrain Accuracy: 94.00\n",
            "Epoch: 4/10 \tIteration: 8000 \t\tTrain Loss: 0.147 \tTrain Accuracy: 94.00\n",
            "Epoch: 4/10 \tIteration: 8100 \t\tTrain Loss: 0.100 \tTrain Accuracy: 94.00\n",
            "Epoch: 4/10 \tIteration: 8200 \t\tTrain Loss: 0.204 \tTrain Accuracy: 90.00\n",
            "\tTrain Loss: 0.185 \tTrain Acc: 92.624\n",
            "\t\tVal Loss: 0.323 \t\tVal Acc: 88.046\n",
            "Time to train epoch: 53.78374886512756 s\n",
            "Epoch: 5/10 \tIteration: 8300 \t\tTrain Loss: 0.213 \tTrain Accuracy: 92.00\n",
            "Epoch: 5/10 \tIteration: 8400 \t\tTrain Loss: 0.327 \tTrain Accuracy: 90.00\n",
            "Epoch: 5/10 \tIteration: 8500 \t\tTrain Loss: 0.145 \tTrain Accuracy: 96.00\n",
            "Epoch: 5/10 \tIteration: 8600 \t\tTrain Loss: 0.200 \tTrain Accuracy: 92.00\n",
            "Epoch: 5/10 \tIteration: 8700 \t\tTrain Loss: 0.120 \tTrain Accuracy: 96.00\n",
            "Epoch: 5/10 \tIteration: 8800 \t\tTrain Loss: 0.074 \tTrain Accuracy: 98.00\n",
            "Epoch: 5/10 \tIteration: 8900 \t\tTrain Loss: 0.117 \tTrain Accuracy: 92.00\n",
            "Epoch: 5/10 \tIteration: 9000 \t\tTrain Loss: 0.127 \tTrain Accuracy: 96.00\n",
            "Epoch: 5/10 \tIteration: 9100 \t\tTrain Loss: 0.085 \tTrain Accuracy: 100.00\n",
            "Epoch: 5/10 \tIteration: 9200 \t\tTrain Loss: 0.048 \tTrain Accuracy: 98.00\n",
            "Epoch: 5/10 \tIteration: 9300 \t\tTrain Loss: 0.242 \tTrain Accuracy: 92.00\n",
            "Epoch: 5/10 \tIteration: 9400 \t\tTrain Loss: 0.185 \tTrain Accuracy: 92.00\n",
            "Epoch: 5/10 \tIteration: 9500 \t\tTrain Loss: 0.142 \tTrain Accuracy: 96.00\n",
            "Epoch: 5/10 \tIteration: 9600 \t\tTrain Loss: 0.107 \tTrain Accuracy: 94.00\n",
            "Epoch: 5/10 \tIteration: 9700 \t\tTrain Loss: 0.223 \tTrain Accuracy: 88.00\n",
            "Epoch: 5/10 \tIteration: 9800 \t\tTrain Loss: 0.237 \tTrain Accuracy: 96.00\n",
            "Epoch: 5/10 \tIteration: 9900 \t\tTrain Loss: 0.076 \tTrain Accuracy: 98.00\n",
            "\tTrain Loss: 0.158 \tTrain Acc: 93.793\n",
            "\t\tVal Loss: 0.383 \t\tVal Acc: 87.880\n",
            "Time to train epoch: 53.87710618972778 s\n",
            "Epoch: 6/10 \tIteration: 10000 \t\tTrain Loss: 0.084 \tTrain Accuracy: 98.00\n",
            "Epoch: 6/10 \tIteration: 10100 \t\tTrain Loss: 0.133 \tTrain Accuracy: 96.00\n",
            "Epoch: 6/10 \tIteration: 10200 \t\tTrain Loss: 0.202 \tTrain Accuracy: 94.00\n",
            "Epoch: 6/10 \tIteration: 10300 \t\tTrain Loss: 0.142 \tTrain Accuracy: 94.00\n",
            "Epoch: 6/10 \tIteration: 10400 \t\tTrain Loss: 0.124 \tTrain Accuracy: 94.00\n",
            "Epoch: 6/10 \tIteration: 10500 \t\tTrain Loss: 0.133 \tTrain Accuracy: 94.00\n",
            "Epoch: 6/10 \tIteration: 10600 \t\tTrain Loss: 0.111 \tTrain Accuracy: 96.00\n",
            "Epoch: 6/10 \tIteration: 10700 \t\tTrain Loss: 0.074 \tTrain Accuracy: 96.00\n",
            "Epoch: 6/10 \tIteration: 10800 \t\tTrain Loss: 0.201 \tTrain Accuracy: 90.00\n",
            "Epoch: 6/10 \tIteration: 10900 \t\tTrain Loss: 0.234 \tTrain Accuracy: 90.00\n",
            "Epoch: 6/10 \tIteration: 11000 \t\tTrain Loss: 0.250 \tTrain Accuracy: 88.00\n",
            "Epoch: 6/10 \tIteration: 11100 \t\tTrain Loss: 0.211 \tTrain Accuracy: 96.00\n",
            "Epoch: 6/10 \tIteration: 11200 \t\tTrain Loss: 0.117 \tTrain Accuracy: 98.00\n",
            "Epoch: 6/10 \tIteration: 11300 \t\tTrain Loss: 0.192 \tTrain Accuracy: 90.00\n",
            "Epoch: 6/10 \tIteration: 11400 \t\tTrain Loss: 0.132 \tTrain Accuracy: 96.00\n",
            "Epoch: 6/10 \tIteration: 11500 \t\tTrain Loss: 0.133 \tTrain Accuracy: 94.00\n",
            "Epoch: 6/10 \tIteration: 11600 \t\tTrain Loss: 0.089 \tTrain Accuracy: 94.00\n",
            "\tTrain Loss: 0.131 \tTrain Acc: 95.041\n",
            "\t\tVal Loss: 0.484 \t\tVal Acc: 87.565\n",
            "Time to train epoch: 53.92569088935852 s\n",
            "Epoch: 7/10 \tIteration: 11700 \t\tTrain Loss: 0.081 \tTrain Accuracy: 96.00\n",
            "Epoch: 7/10 \tIteration: 11800 \t\tTrain Loss: 0.105 \tTrain Accuracy: 96.00\n",
            "Epoch: 7/10 \tIteration: 11900 \t\tTrain Loss: 0.033 \tTrain Accuracy: 100.00\n",
            "Epoch: 7/10 \tIteration: 12000 \t\tTrain Loss: 0.062 \tTrain Accuracy: 96.00\n",
            "Epoch: 7/10 \tIteration: 12100 \t\tTrain Loss: 0.146 \tTrain Accuracy: 96.00\n",
            "Epoch: 7/10 \tIteration: 12200 \t\tTrain Loss: 0.124 \tTrain Accuracy: 98.00\n",
            "Epoch: 7/10 \tIteration: 12300 \t\tTrain Loss: 0.120 \tTrain Accuracy: 96.00\n",
            "Epoch: 7/10 \tIteration: 12400 \t\tTrain Loss: 0.096 \tTrain Accuracy: 96.00\n",
            "Epoch: 7/10 \tIteration: 12500 \t\tTrain Loss: 0.185 \tTrain Accuracy: 96.00\n",
            "Epoch: 7/10 \tIteration: 12600 \t\tTrain Loss: 0.068 \tTrain Accuracy: 96.00\n",
            "Epoch: 7/10 \tIteration: 12700 \t\tTrain Loss: 0.074 \tTrain Accuracy: 98.00\n",
            "Epoch: 7/10 \tIteration: 12800 \t\tTrain Loss: 0.162 \tTrain Accuracy: 94.00\n",
            "Epoch: 7/10 \tIteration: 12900 \t\tTrain Loss: 0.075 \tTrain Accuracy: 96.00\n",
            "Epoch: 7/10 \tIteration: 13000 \t\tTrain Loss: 0.142 \tTrain Accuracy: 96.00\n",
            "Epoch: 7/10 \tIteration: 13100 \t\tTrain Loss: 0.115 \tTrain Accuracy: 94.00\n",
            "Epoch: 7/10 \tIteration: 13200 \t\tTrain Loss: 0.202 \tTrain Accuracy: 92.00\n",
            "\tTrain Loss: 0.107 \tTrain Acc: 96.061\n",
            "\t\tVal Loss: 0.703 \t\tVal Acc: 87.454\n",
            "Time to train epoch: 53.835296869277954 s\n",
            "Epoch: 8/10 \tIteration: 13300 \t\tTrain Loss: 0.127 \tTrain Accuracy: 94.00\n",
            "Epoch: 8/10 \tIteration: 13400 \t\tTrain Loss: 0.226 \tTrain Accuracy: 94.00\n",
            "Epoch: 8/10 \tIteration: 13500 \t\tTrain Loss: 0.017 \tTrain Accuracy: 100.00\n",
            "Epoch: 8/10 \tIteration: 13600 \t\tTrain Loss: 0.095 \tTrain Accuracy: 96.00\n",
            "Epoch: 8/10 \tIteration: 13700 \t\tTrain Loss: 0.245 \tTrain Accuracy: 88.00\n",
            "Epoch: 8/10 \tIteration: 13800 \t\tTrain Loss: 0.134 \tTrain Accuracy: 92.00\n",
            "Epoch: 8/10 \tIteration: 13900 \t\tTrain Loss: 0.145 \tTrain Accuracy: 92.00\n",
            "Epoch: 8/10 \tIteration: 14000 \t\tTrain Loss: 0.096 \tTrain Accuracy: 96.00\n",
            "Epoch: 8/10 \tIteration: 14100 \t\tTrain Loss: 0.097 \tTrain Accuracy: 98.00\n",
            "Epoch: 8/10 \tIteration: 14200 \t\tTrain Loss: 0.095 \tTrain Accuracy: 94.00\n",
            "Epoch: 8/10 \tIteration: 14300 \t\tTrain Loss: 0.102 \tTrain Accuracy: 96.00\n",
            "Epoch: 8/10 \tIteration: 14400 \t\tTrain Loss: 0.115 \tTrain Accuracy: 96.00\n",
            "Epoch: 8/10 \tIteration: 14500 \t\tTrain Loss: 0.047 \tTrain Accuracy: 100.00\n",
            "Epoch: 8/10 \tIteration: 14600 \t\tTrain Loss: 0.073 \tTrain Accuracy: 96.00\n",
            "Epoch: 8/10 \tIteration: 14700 \t\tTrain Loss: 0.111 \tTrain Accuracy: 98.00\n",
            "Epoch: 8/10 \tIteration: 14800 \t\tTrain Loss: 0.050 \tTrain Accuracy: 100.00\n",
            "Epoch: 8/10 \tIteration: 14900 \t\tTrain Loss: 0.070 \tTrain Accuracy: 96.00\n",
            "\tTrain Loss: 0.090 \tTrain Acc: 96.737\n",
            "\t\tVal Loss: 0.952 \t\tVal Acc: 87.380\n",
            "Time to train epoch: 53.91186213493347 s\n",
            "Epoch: 9/10 \tIteration: 15000 \t\tTrain Loss: 0.039 \tTrain Accuracy: 100.00\n",
            "Epoch: 9/10 \tIteration: 15100 \t\tTrain Loss: 0.020 \tTrain Accuracy: 100.00\n",
            "Epoch: 9/10 \tIteration: 15200 \t\tTrain Loss: 0.026 \tTrain Accuracy: 100.00\n",
            "Epoch: 9/10 \tIteration: 15300 \t\tTrain Loss: 0.162 \tTrain Accuracy: 94.00\n",
            "Epoch: 9/10 \tIteration: 15400 \t\tTrain Loss: 0.048 \tTrain Accuracy: 96.00\n",
            "Epoch: 9/10 \tIteration: 15500 \t\tTrain Loss: 0.019 \tTrain Accuracy: 100.00\n",
            "Epoch: 9/10 \tIteration: 15600 \t\tTrain Loss: 0.092 \tTrain Accuracy: 98.00\n",
            "Epoch: 9/10 \tIteration: 15700 \t\tTrain Loss: 0.023 \tTrain Accuracy: 100.00\n",
            "Epoch: 9/10 \tIteration: 15800 \t\tTrain Loss: 0.041 \tTrain Accuracy: 98.00\n",
            "Epoch: 9/10 \tIteration: 15900 \t\tTrain Loss: 0.037 \tTrain Accuracy: 98.00\n",
            "Epoch: 9/10 \tIteration: 16000 \t\tTrain Loss: 0.094 \tTrain Accuracy: 94.00\n",
            "Epoch: 9/10 \tIteration: 16100 \t\tTrain Loss: 0.219 \tTrain Accuracy: 90.00\n",
            "Epoch: 9/10 \tIteration: 16200 \t\tTrain Loss: 0.027 \tTrain Accuracy: 100.00\n",
            "Epoch: 9/10 \tIteration: 16300 \t\tTrain Loss: 0.015 \tTrain Accuracy: 100.00\n",
            "Epoch: 9/10 \tIteration: 16400 \t\tTrain Loss: 0.028 \tTrain Accuracy: 100.00\n",
            "Epoch: 9/10 \tIteration: 16500 \t\tTrain Loss: 0.072 \tTrain Accuracy: 96.00\n",
            "\tTrain Loss: 0.075 \tTrain Acc: 97.251\n",
            "\t\tVal Loss: 1.289 \t\tVal Acc: 87.102\n",
            "Time to train epoch: 53.92786478996277 s\n",
            "Test Loss: 1.115 \tTest Acc: 87.602\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "torch.save(model.state_dict(),\"./lstm-cnn-amazon.pth\")"
      ],
      "metadata": {
        "id": "z4Tjh75SWd8c"
      },
      "execution_count": 9,
      "outputs": []
    }
  ]
}