HW12_Ignatiev.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "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.8.3"
    },
    "colab": {
      "name": "HW12 Ignatiev.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4rk-idmfHOd8",
        "outputId": "8e7eb728-0fe8-43bf-b9ee-104d35283109"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mounted at /content/drive\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JTtvYjBIHOd-",
        "outputId": "5ff45efb-5ea8-4daf-edf4-17a24f570fb5"
      },
      "source": [
        "!unzip -d . drive/MyDrive/data.zip"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Archive:  drive/MyDrive/data.zip\n",
            "  inflating: ./lenta_sample.csv      \n",
            "  inflating: ./__MACOSX/._lenta_sample.csv  \n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uMoSwOMdHOd-"
      },
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import torch.optim as optim\n",
        "import torch.utils.data"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FmNaJR4LHOd_"
      },
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "from string import punctuation\n",
        "from sklearn.model_selection import train_test_split\n",
        "from collections import Counter\n",
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rsJh2MBoHOd_"
      },
      "source": [
        "data = pd.read_csv(\"lenta_sample.csv\")\n",
        "data.dropna(subset = ['topic', 'text'], inplace=True)"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4bYyJ35NHOd_"
      },
      "source": [
        "def preprocess(text):\n",
        "    tokens = text.lower().split()\n",
        "    tokens = [token.strip(punctuation) for token in tokens]\n",
        "    tokens = [token for token in tokens if token]\n",
        "    return tokens"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P6YYZOVZHOeA"
      },
      "source": [
        "vocab = Counter()\n",
        "for text in data[\"text\"]:\n",
        "    vocab.update(preprocess(text))"
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mA3v3r6-HOeA"
      },
      "source": [
        "filtered_vocab = set()\n",
        "for word in vocab:\n",
        "    if vocab[word] > 30:\n",
        "        filtered_vocab.add(word)"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kR0YpJXeHOeB"
      },
      "source": [
        "word2id = {\"PAD\":0}\n",
        "for word in filtered_vocab:\n",
        "    word2id[word] = len(word2id)\n",
        "id2word = {i:word for word, i in word2id.items()}"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "owu8fqxXHOeB"
      },
      "source": [
        "class Dataset(torch.utils.data.Dataset):\n",
        "    def __init__(self, word2id, MAX_LEN, texts, targets):\n",
        "        super().__init__()\n",
        "        self.texts = [torch.LongTensor([word2id[w] for w in self.preprocess(t) if w in word2id][:MAX_LEN]) for t in texts]\n",
        "        self.texts = torch.nn.utils.rnn.pad_sequence(self.texts, batch_first=True)\n",
        "        self.target = torch.LongTensor(targets)\n",
        "        \n",
        "        self.word2id = word2id\n",
        "        self.MAX_LEN = MAX_LEN\n",
        "\n",
        "#         self.target = self.target[self.texts.sum(1).bool()]\n",
        "#         self.texts = self.texts[self.texts.sum(1).bool()]\n",
        "        self.length = len(texts)\n",
        "        \n",
        "    def __getitem__(self, item):\n",
        "        ids = self.texts[item]\n",
        "        y = self.target[item]\n",
        "        return ids, y\n",
        "    \n",
        "    def __len__(self):\n",
        "        return self.length\n",
        "    \n",
        "    @staticmethod\n",
        "    def preprocess(text):\n",
        "        tokens = text.lower().split()\n",
        "        tokens = [token.strip(punctuation) for token in tokens]\n",
        "        tokens = [token for token in tokens if token]\n",
        "        return tokens        "
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GmWc5mPTHOeC"
      },
      "source": [
        "MAX_LEN = 200"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lIxozR_XHOeC"
      },
      "source": [
        "texts = data[\"text\"].values\n",
        "id2label = {i:l for i, l in enumerate(set(data.topic))}\n",
        "label2id = {l:i for i, l in id2label.items()}\n",
        "targets = [label2id[l] for l in data.topic]"
      ],
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PFBOWxQnHOeC"
      },
      "source": [
        "train_texts, valid_texts, train_targets, valid_targets = train_test_split(texts, targets, test_size=0.05)"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MiABnvK9HOeC"
      },
      "source": [
        "training_set:torch.utils.data.Dataset = Dataset(word2id, MAX_LEN, train_texts, train_targets)\n",
        "training_generator:torch.utils.data.DataLoader = torch.utils.data.DataLoader(training_set, batch_size=256, shuffle=True)"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p3z2mJFsHOeD"
      },
      "source": [
        "valid_set:torch.utils.data.Dataset = Dataset(word2id, MAX_LEN, valid_texts, valid_targets)\n",
        "valid_generator:torch.utils.data.DataLoader = torch.utils.data.DataLoader(valid_set, batch_size=256, shuffle=True) "
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q1Hb5PxzHOeD"
      },
      "source": [
        "from sklearn.metrics import f1_score"
      ],
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rNEuNJqIHOeD"
      },
      "source": [
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
      ],
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JfOoOlVAHOeE"
      },
      "source": [
        "import math"
      ],
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uFw56WThHOeE"
      },
      "source": [
        "class Clf(nn.Module):\n",
        "    def __init__(self, output_dim, word2id=word2id):\n",
        "        super().__init__()\n",
        "        self.VOCAB_SIZE = len(word2id)\n",
        "        self.EMB_DIM = 100\n",
        "        self.MAX_LEN = 200\n",
        "        self.IN_CHANNELS = self.MAX_LEN\n",
        "        \n",
        "        self.KERNEL_SIZE_1 = 3\n",
        "        self.OUT_CHANNELS_1 = 64\n",
        "        self.KERNEL_SIZE_2 = 5\n",
        "        self.OUT_CHANNELS_2 = 32\n",
        "        self.KERNEL_SIZE_POOL = 2\n",
        "        self.STRIDE = 2\n",
        "        self.STRIDE_POOL = 2\n",
        "        self.RNN_UNITS = 128\n",
        "        self.HIDDEN_FC = 64\n",
        "        \n",
        "        self.conv_size_1 = math.floor(((self.EMB_DIM - 1 * (self.KERNEL_SIZE_1 - 1) - 1) / self.STRIDE) + 1)\n",
        "        self.pool_size_1 = math.floor(((self.conv_size_1 - 1 * (self.KERNEL_SIZE_POOL - 1) - 1) / self.STRIDE_POOL + 1))\n",
        "        self.con_size_2 = math.floor(((self.pool_size_1 - 1 * (self.KERNEL_SIZE_2 - 1) - 1) / self.STRIDE) + 1)\n",
        "        self.pool_size_2 = math.floor(((self.con_size_2 - 1 * (self.KERNEL_SIZE_POOL - 1) / self.STRIDE_POOL) + 1))\n",
        "        \n",
        "        self.embedding = nn.Embedding(self.VOCAB_SIZE, self.EMB_DIM)\n",
        "        self.conv_1 = nn.Conv1d(self.IN_CHANNELS,\n",
        "                                self.OUT_CHANNELS_1,\n",
        "                                self.KERNEL_SIZE_1,\n",
        "                                self.STRIDE)\n",
        "        self.pool_1 = nn.MaxPool1d(self.KERNEL_SIZE_POOL,\n",
        "                                   self.STRIDE_POOL)\n",
        "        self.conv_2 = nn.Conv1d(self.OUT_CHANNELS_1,\n",
        "                                self.OUT_CHANNELS_2,\n",
        "                                self.KERNEL_SIZE_2,\n",
        "                                self.STRIDE)\n",
        "        self.pool_2 = nn.MaxPool1d(self.KERNEL_SIZE_POOL,\n",
        "                                   self.STRIDE_POOL)\n",
        "        self.relu = torch.nn.LeakyReLU()\n",
        "        self.dropout = torch.nn.Dropout(0.3)\n",
        "        \n",
        "#         self.lstm = nn.LSTM(self.pool_size_2, self.RNN_UNITS, batch_first=True)\n",
        "#         self.gru = nn.GRU(self.pool_size_2, self.RNN_UNITS, batch_first=True)\n",
        "        self.lstm = nn.LSTM(self.OUT_CHANNELS_2, self.RNN_UNITS, batch_first=True)\n",
        "        self.gru = nn.GRU(self.OUT_CHANNELS_2, self.RNN_UNITS, batch_first=True)\n",
        "        \n",
        "        \n",
        "        self.fc = nn.Linear(self.RNN_UNITS, self.HIDDEN_FC)\n",
        "        self.hidden = nn.Linear(self.HIDDEN_FC, output_dim)        \n",
        "        self.act = nn.LogSoftmax(1)\n",
        "\n",
        "    def forward(self, text):\n",
        "#         embedded = self.embedding(text).permute(0, 2, 1)\n",
        "        embedded = self.embedding(text)\n",
        "        conv1 = self.relu(self.conv_1(embedded))\n",
        "        pool1 = self.pool_1(conv1)\n",
        "        conv2 = self.relu(self.conv_2(pool1))\n",
        "        pool2 = self.pool_2(conv2).permute(0, 2, 1)\n",
        "        pool_backward = torch.flip(pool2, (1,))\n",
        "        \n",
        "        gru_out, (h, *_) = self.gru(pool2)\n",
        "        lstm_out, (h_b, *_) = self.lstm(pool_backward)\n",
        "        h, h_b = h.squeeze(0).unsqueeze(dim=2), h_b.squeeze(0).unsqueeze(dim=2)\n",
        "        cat = torch.cat((h, h_b), dim=2)\n",
        "        mean = torch.mean(cat, dim=2).float()\n",
        "        fc = self.dropout(self.fc(mean))        \n",
        "        hidden = self.hidden(fc)\n",
        "        out = self.act(hidden)\n",
        "        return out\n",
        "    \n",
        "model:torch.nn.Module = Clf(len(label2id))\n",
        "optimizer:torch.optim.Optimizer = optim.Adam(model.parameters(), lr=0.001)\n",
        "criterion = nn.NLLLoss().to(device)\n",
        "model = model.to(device)"
      ],
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h4xsOOIOHOeF"
      },
      "source": [
        "def train(model:nn.Module,\n",
        "          iterator:torch.utils.data.DataLoader,\n",
        "          optimizer:torch.optim.Optimizer,\n",
        "          loss_fn:nn.modules.loss._Loss,\n",
        "          print_every:int=1000):\n",
        "    epoch_loss:list = []\n",
        "    epoch_f1:list = []\n",
        "    model.train()\n",
        "    \n",
        "    for i, (texts, ys) in enumerate(iterator):\n",
        "        optimizer.zero_grad()\n",
        "        predictions = model(texts.to(device)).squeeze()\n",
        "        loss = loss_fn(predictions, ys.to(device))\n",
        "        \n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        preds = predictions.detach().to('cpu').numpy().argmax(1).tolist()\n",
        "        y_true = ys.tolist()\n",
        "        \n",
        "        epoch_loss.append(loss.item())\n",
        "        epoch_f1.append(f1_score(y_true, preds, average=\"micro\"))\n",
        "        \n",
        "        if not (i + 1) % print_every:\n",
        "            print(f\"loss: {np.mean(epoch_loss)}; F1: {np.mean(epoch_f1)}\")\n",
        "    return np.mean(epoch_f1)\n",
        "    \n",
        "def evaluate(model:nn.Module,\n",
        "             iterator:torch.utils.data.DataLoader,\n",
        "             loss_fn:torch.nn.modules.loss._Loss):\n",
        "    epoch_loss:list = []\n",
        "    epoch_f1:list = []\n",
        "        \n",
        "    model.eval()\n",
        "    with torch.no_grad():\n",
        "        for texts, ys in iterator:\n",
        "            predictions = model(texts.to(device)).squeeze()\n",
        "            loss = loss_fn(predictions, ys.to(device))\n",
        "            preds = predictions.detach().to(\"cpu\").numpy().argmax(1).tolist()\n",
        "            y_true = ys.tolist()\n",
        "            \n",
        "            epoch_loss.append(loss.item())\n",
        "            epoch_f1.append(f1_score(y_true, preds, average=\"micro\"))\n",
        "    return np.mean(epoch_f1)"
      ],
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qKxcjQdTHOeG",
        "outputId": "1f367082-31ac-43ed-e30c-9e9f9b80c910"
      },
      "source": [
        "f1s = []\n",
        "f1s_eval = []\n",
        "\n",
        "for i in range(10):\n",
        "    print(i)\n",
        "    f1s.append(train(model, training_generator, optimizer, criterion))\n",
        "    ev = evaluate(model, valid_generator, criterion)\n",
        "    print(\"Eval - \", ev)\n",
        "    f1s_eval.append(ev)"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0\n",
            "Eval -  0.5893163314176245\n",
            "1\n",
            "Eval -  0.7021276340996169\n",
            "2\n",
            "Eval -  0.7459650383141763\n",
            "3\n",
            "Eval -  0.7552448515325672\n",
            "4\n",
            "Eval -  0.7683387212643678\n",
            "5\n",
            "Eval -  0.7661368534482759\n",
            "6\n",
            "Eval -  0.7659602490421457\n",
            "7\n",
            "Eval -  0.7683105842911878\n",
            "8\n",
            "Eval -  0.7619103208812261\n",
            "9\n",
            "Eval -  0.7577717911877394\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "K2vKxwTMHOeG",
        "outputId": "a269dd3d-bbc7-451d-e1bc-5ed13c93f39a"
      },
      "source": [
        "plt.plot(f1s)\n",
        "plt.plot(f1s_eval)\n",
        "plt.title('model f1 micro')\n",
        "plt.ylabel('f1')\n",
        "plt.xlabel('epoch')\n",
        "plt.legend(['train', 'val'], loc='upper left')\n",
        "plt.show()"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}