Medical_Paper_Abstracts_Classification_using_NLP.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Medical Paper Abstracts Classification using NLP.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyP/v5CYeIouTuuqCYbshGO7",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/RohitGanji/NLP-Medical-Paper-Abstracts-Classification/blob/main/Medical_Paper_Abstracts_Classification_using_NLP.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GTylj_mkoD6R"
      },
      "source": [
        "# Medical Paper Abstracts Classification using NLP\n",
        "\n",
        "This project is an implementation of the paper \"Neural Networks for Joint Sentence Classification in Medical Abstracts\".\n",
        "\n",
        "Paper - https://arxiv.org/pdf/1612.05251.pdf"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ascdX3lAtjLc"
      },
      "source": [
        "## Preparing Data"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zRePV38toVh3"
      },
      "source": [
        "### Downloading Dataset"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AYMCy6V9puiW",
        "outputId": "a9d1b5bb-7e6c-4fc0-80c7-d3903fa9369d"
      },
      "source": [
        "!git clone https://github.com/Franck-Dernoncourt/pubmed-rct.git"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Cloning into 'pubmed-rct'...\n",
            "remote: Enumerating objects: 33, done.\u001b[K\n",
            "remote: Counting objects: 100% (3/3), done.\u001b[K\n",
            "remote: Compressing objects: 100% (3/3), done.\u001b[K\n",
            "remote: Total 33 (delta 0), reused 0 (delta 0), pack-reused 30\u001b[K\n",
            "Unpacking objects: 100% (33/33), done.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9gjU26uNthV1"
      },
      "source": [
        "### Unzipping train dataset\n",
        "\n",
        "The train data is in zip format. Let's unzip it."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L2-Srx8ep_Gt",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "747d36d9-f55d-423d-f377-9a38de0aad71"
      },
      "source": [
        "!unzip /content/pubmed-rct/PubMed_200k_RCT_numbers_replaced_with_at_sign/train.zip -d /content/pubmed-rct/PubMed_200k_RCT_numbers_replaced_with_at_sign/"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Archive:  /content/pubmed-rct/PubMed_200k_RCT_numbers_replaced_with_at_sign/train.zip\n",
            "  inflating: /content/pubmed-rct/PubMed_200k_RCT_numbers_replaced_with_at_sign/train.txt  \n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UjLYizsTqT6u"
      },
      "source": [
        "DIR = \"pubmed-rct/PubMed_200k_RCT_numbers_replaced_with_at_sign/\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f_EeRxPUuGDw"
      },
      "source": [
        "### Preprocessing data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Cdjy9eN7wELG"
      },
      "source": [
        "def get_lines(filename):\n",
        "  \"\"\"\n",
        "  Reads a filename and returns a list of lines of text\n",
        "\n",
        "  Args:\n",
        "      filename: path of the file\n",
        "\n",
        "  Returns:\n",
        "      A list of strings with one string per line from filename.\n",
        "  \"\"\"\n",
        "  with open(filename) as f:\n",
        "    return f.readlines()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NtROyMFjvVR0"
      },
      "source": [
        "def preprocess(filename):\n",
        "  \"\"\" \n",
        "  Returns a list of dictionaries of abstract line data.\n",
        "\n",
        "  Args: \n",
        "      filename: path of the filename (train, test, dev)\n",
        "  Returns:\n",
        "      List of dictionary each containing a line from abstract, the line's label, the line's position in the abstract, and the total number of lines in the dataset where the line is from.\n",
        "  \"\"\"\n",
        "\n",
        "  input_lines = get_lines(filename)\n",
        "  abstract_lines = \"\"\n",
        "  abstract_samples = []\n",
        "\n",
        "  for line in input_lines:\n",
        "    if line.startswith(\"###\"):\n",
        "      abstract_id = line\n",
        "      abstract_lines = \"\"\n",
        "    elif line.isspace():\n",
        "      abstract_line_split = abstract_lines.splitlines()\n",
        "\n",
        "      for abstract_line_number, abstract_line in enumerate(abstract_line_split):\n",
        "        line_data = {}\n",
        "        target_text_split = abstract_line.split(\"\\t\")\n",
        "        line_data[\"target\"] = target_text_split[0]\n",
        "        line_data[\"text\"] = target_text_split[1].lower()\n",
        "        line_data[\"line_number\"] = abstract_line_number\n",
        "        line_data[\"total_lines\"] = len(abstract_line_split) - 1\n",
        "        abstract_samples.append(line_data)\n",
        "\n",
        "    else:\n",
        "      abstract_lines += line\n",
        "  \n",
        "  return abstract_samples"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PquoZeAtv2Ve"
      },
      "source": [
        "train_samples = preprocess(DIR+\"train.txt\")\n",
        "val_samples = preprocess(DIR+\"dev.txt\")\n",
        "test_samples = preprocess(DIR+\"test.txt\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R7DgeoOBv563"
      },
      "source": [
        "### Viewing our data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EzEhSR6nyuSz"
      },
      "source": [
        "import pandas as pd\n",
        "\n",
        "train_df = pd.DataFrame(train_samples)\n",
        "val_df = pd.DataFrame(val_samples)\n",
        "test_df = pd.DataFrame(test_samples)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        },
        "id": "H8FtjHiqzU0N",
        "outputId": "8361d4c5-01f5-4828-f896-e7caf426ddd2"
      },
      "source": [
        "train_df.head()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>target</th>\n",
              "      <th>text</th>\n",
              "      <th>line_number</th>\n",
              "      <th>total_lines</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>BACKGROUND</td>\n",
              "      <td>the emergence of hiv as a chronic condition me...</td>\n",
              "      <td>0</td>\n",
              "      <td>10</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>BACKGROUND</td>\n",
              "      <td>this paper describes the design and evaluation...</td>\n",
              "      <td>1</td>\n",
              "      <td>10</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>METHODS</td>\n",
              "      <td>this study is designed as a randomised control...</td>\n",
              "      <td>2</td>\n",
              "      <td>10</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>METHODS</td>\n",
              "      <td>the intervention group will participate in the...</td>\n",
              "      <td>3</td>\n",
              "      <td>10</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>METHODS</td>\n",
              "      <td>the program is based on self-efficacy theory a...</td>\n",
              "      <td>4</td>\n",
              "      <td>10</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "       target  ... total_lines\n",
              "0  BACKGROUND  ...          10\n",
              "1  BACKGROUND  ...          10\n",
              "2     METHODS  ...          10\n",
              "3     METHODS  ...          10\n",
              "4     METHODS  ...          10\n",
              "\n",
              "[5 rows x 4 columns]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "udm5-hkky3HD",
        "outputId": "60fe796c-2286-495f-e4d8-e896685d65c3"
      },
      "source": [
        "train_df.target.value_counts()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "RESULTS        766271\n",
              "METHODS        722586\n",
              "CONCLUSIONS    339714\n",
              "BACKGROUND     196689\n",
              "OBJECTIVE      186601\n",
              "Name: target, dtype: int64"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 276
        },
        "id": "knEozKKczRAt",
        "outputId": "22a16934-02cd-4d3b-ee49-545835ae3c42"
      },
      "source": [
        "train_df.total_lines.plot.hist();"
      ],
      "execution_count": null,
      "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"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tQy7YuPGzedl"
      },
      "source": [
        "It seems like length of most of the abstracts are between 7 and 17."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0fC0fxfR58s9"
      },
      "source": [
        "## Creating Datasets"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bftAIHaXy5Fj"
      },
      "source": [
        "### Converting data to numeric labels"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BrLFsnL21Z0x"
      },
      "source": [
        "# Create one-hot-encoded tensors of \"target\" column\n",
        "\n",
        "from sklearn.preprocessing import OneHotEncoder\n",
        "ohe = OneHotEncoder(sparse=False)\n",
        "\n",
        "train_labels_one_hot = ohe.fit_transform(train_df[\"target\"].to_numpy().reshape(-1, 1))\n",
        "val_labels_one_hot = ohe.transform(val_df[\"target\"].to_numpy().reshape(-1, 1))\n",
        "test_labels_one_hot = ohe.transform(test_df[\"target\"].to_numpy().reshape(-1, 1))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 276
        },
        "id": "gGZ9kHzN2kBP",
        "outputId": "7cc213bd-1cd4-428a-b345-d12e4ffd7a5f"
      },
      "source": [
        "train_df.line_number.plot.hist();"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEDCAYAAAA4FgP0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAReUlEQVR4nO3de7BdZX3G8e9jInLxQpV4mQQFbRQZL4hHtFUrUrURNLG1UhiZqsNAZyqOjpcarYOWjjPaTr0Wp0ZlvLSKUatNSyxFpeo4AgmCYIJoRJREayKiiFoQ/fWPvaK7h3OSHThrb85+v5+ZM1nrXe9e+/cOm/OcddnvSlUhSWrXXSZdgCRpsgwCSWqcQSBJjTMIJKlxBoEkNc4gkKTGLcogSHJOkp1JvjZi/xOTbE2yJcmH+65PkhaTLMbvEST5A+Am4INV9Yi99F0JrAeOq6obkty3qnaOo05JWgwW5RFBVX0B+NFwW5KHJPnPJJcm+WKSI7pNpwFnV9UN3WsNAUkasiiDYB7rgJdU1WOBVwLv6tofCjw0yZeSXJRk1cQqlKQ7oaWTLmAhJLk78PvAx5Lsbr5b9+9SYCVwLLAC+EKSR1bVj8ddpyTdGU1FEDA4svlxVR01x7btwMVV9Uvg20m+wSAYNo2zQEm6s5qKU0NVdSODX/LPA8jAo7vNn2JwNECSQxicKrpmEnVK0p1Rb0Gwt1s8u1/W70iyLckVSY7eh31/BPgy8LAk25OcCjwfODXJV4EtwJqu+/nA9Um2AhcCr6qq6+/I2CRpmvR2++jebvFMcjzwEuB44PHA26vq8b0UI0maV29HBHPd4jnLGgYhUVV1EXBwkgf0VY8kaW6TvFi8HLhuaH171/b92R2TnA6cDnDQQQc99ogjjpjdRZK0B5deeukPq2rZXNsWxV1DVbWOwfcEmJmZqc2bN0+4IklaXJJ8Z75tk7xraAdw6ND6iq5NkjRGkwyCDcCfd3cPPQH4SVXd5rSQJKlfvZ0a6m7xPBY4JMl24PXAXQGq6p+AjQzuGNoG/Bx4UV+1SJLm11sQVNXJe9lewIv7en9J0mim4pvFkqTbzyCQpMYZBJLUOINAkhpnEEhS4xbFN4sXymFrz5vYe1/7phMm9t6StCceEUhS4wwCSWqcQSBJjTMIJKlxBoEkNc4gkKTGGQSS1DiDQJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNa+qZxZM0qecl+6xkSXvjEYEkNc4gkKTGGQSS1DiDQJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDWu1yBIsirJ1Um2JVk7x/YHJrkwyWVJrkhyfJ/1SJJuq7cgSLIEOBt4JnAkcHKSI2d1ex2wvqoeA5wEvKuveiRJc+vziOAYYFtVXVNVtwDnAmtm9Sngnt3yvYDv9ViPJGkOfQbBcuC6ofXtXduwNwCnJNkObAReMteOkpyeZHOSzbt27eqjVklq1qQvFp8MvL+qVgDHAx9KcpuaqmpdVc1U1cyyZcvGXqQkTbM+g2AHcOjQ+oqubdipwHqAqvoysD9wSI81SZJm6TMINgErkxyeZD8GF4M3zOrzXeAPAZI8nEEQeO5HksaotyCoqluBM4DzgasY3B20JclZSVZ33V4BnJbkq8BHgBdWVfVVkyTptnp9QllVbWRwEXi47cyh5a3AE/usQZK0Z5O+WCxJmjCDQJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhpnEEhS4wwCSWqcQSBJjTMIJKlxBoEkNc4gkKTGGQSS1DiDQJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxhkEktQ4g0CSGtdrECRZleTqJNuSrJ2nz4lJtibZkuTDfdYjSbqtpX3tOMkS4Gzg6cB2YFOSDVW1dajPSuA1wBOr6oYk9+2rHknS3EY6IkjyyNux72OAbVV1TVXdApwLrJnV5zTg7Kq6AaCqdt6O95Ek3QGjnhp6V5JLkvxlknuN+JrlwHVD69u7tmEPBR6a5EtJLkqyaq4dJTk9yeYkm3ft2jXi20uSRjFSEFTVk4HnA4cClyb5cJKnL8D7LwVWAscCJwPvSXLwHO+/rqpmqmpm2bJlC/C2kqTdRr5YXFXfBF4HvBp4CvCOJF9P8ifzvGQHg+DYbUXXNmw7sKGqfllV3wa+wSAYJEljMuo1gkcleStwFXAc8Oyqeni3/NZ5XrYJWJnk8CT7AScBG2b1+RSDowGSHMLgVNE1+zoISdLtN+pdQ+8E3gu8tqp+sbuxqr6X5HVzvaCqbk1yBnA+sAQ4p6q2JDkL2FxVG7ptz0iyFfgV8Kqquv4OjEeStI9GDYITgF9U1a8AktwF2L+qfl5VH5rvRVW1Edg4q+3MoeUCXt79SJImYNRrBJ8BDhhaP7BrkyQtcqMGwf5VddPulW75wH5KkiSN06hB8LMkR+9eSfJY4Bd76C9JWiRGvUbwMuBjSb4HBLg/8Ge9VSVJGpuRgqCqNiU5AnhY13R1Vf2yv7IkSeOyL5POPQ44rHvN0Umoqg/2UpUkaWxGCoIkHwIeAlzO4H5/gAIMAkla5EY9IpgBjuzu+5ckTZFR7xr6GoMLxJKkKTPqEcEhwNYklwA3726sqtW9VCVJGptRg+ANfRYhSZqcUW8f/XySBwErq+ozSQ5kMJGcJGmRG3Ua6tOAjwPv7pqWM5hCWpK0yI16sfjFwBOBG+E3D6nxQfOSNAVGDYKbuwfQA5BkKYPvEUiSFrlRg+DzSV4LHNA9q/hjwL/3V5YkaVxGDYK1wC7gSuAvGDxsZs4nk0mSFpdR7xr6NfCe7keSNEVGnWvo28xxTaCqHrzgFUmSxmpf5hrabX/gecC9F74cSdK4jXSNoKquH/rZUVVvY/BAe0nSIjfqqaGjh1bvwuAIYV+eZSBJupMa9Zf5Pwwt3wpcC5y44NVIksZu1LuGntp3IZKkyRj11NDL97S9qt6yMOVIksZtX+4aehywoVt/NnAJ8M0+ipIkjc+oQbACOLqqfgqQ5A3AeVV1Sl+FSZLGY9QpJu4H3DK0fkvXJkla5EY9IvggcEmST3brzwE+0E9JkqRxGvWuoTcm+TTw5K7pRVV1WX9lSZLGZdRTQwAHAjdW1duB7UkO76kmSdIYjfqoytcDrwZe0zXdFfjnvoqSJI3PqEcEfwysBn4GUFXfA+7RV1GSpPEZNQhuqaqim4o6yUH9lSRJGqdRg2B9kncDByc5DfgMPqRGkqbCXoMgSYCPAh8HPgE8DDizqt45wmtXJbk6ybYka/fQ77lJKsnMfH0kSf3Y6+2jVVVJNlbVI4ELRt1xkiXA2cDTge3ApiQbqmrrrH73AF4KXLxPlUuSFsSop4a+kuRx+7jvY4BtVXVNVd0CnAusmaPf3wJvBv53H/cvSVoAowbB44GLknwryRVJrkxyxV5esxy4bmh9e9f2G90Dbw6tqvP2tKMkpyfZnGTzrl27RixZkjSKPZ4aSvLAqvou8EcL/cZJ7gK8BXjh3vpW1TpgHcDMzEwtdC2S1LK9XSP4FINZR7+T5BNV9dx92PcO4NCh9RVd2273AB4B/PfgejT3BzYkWV1Vm/fhfSRJd8DeTg1laPnB+7jvTcDKJIcn2Q84id8+z4Cq+klVHVJVh1XVYcBFgCEgSWO2tyCoeZb3qqpuBc4AzgeuAtZX1ZYkZyVZvW9lSpL6srdTQ49OciODI4MDumW69aqqe+7pxVW1Edg4q+3MefoeO1LFkqQFtccgqKol4ypEkjQZ+zINtSRpChkEktQ4g0CSGmcQSFLjDAJJatxID6/X4nXY2j1O49Sra990wsTeW9LoPCKQpMYZBJLUOINAkhpnEEhS4wwCSWqcQSBJjTMIJKlxBoEkNc4gkKTGGQSS1DiDQJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhrXaxAkWZXk6iTbkqydY/vLk2xNckWSzyZ5UJ/1SJJuq7cgSLIEOBt4JnAkcHKSI2d1uwyYqapHAR8H/q6veiRJc+vziOAYYFtVXVNVtwDnAmuGO1TVhVX18271ImBFj/VIkubQZxAsB64bWt/etc3nVODTc21IcnqSzUk279q1awFLlCTdKS4WJzkFmAH+fq7tVbWuqmaqambZsmXjLU6SptzSHve9Azh0aH1F1/b/JHka8NfAU6rq5h7rkSTNoc8jgk3AyiSHJ9kPOAnYMNwhyWOAdwOrq2pnj7VIkubRWxBU1a3AGcD5wFXA+qrakuSsJKu7bn8P3B34WJLLk2yYZ3eSpJ70eWqIqtoIbJzVdubQ8tP6fH9J0t7dKS4WS5ImxyCQpMYZBJLUOINAkhpnEEhS4wwCSWqcQSBJjTMIJKlxBoEkNc4gkKTGGQSS1DiDQJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhq3dNIFaHodtva8ibzvtW86YSLvKy1WHhFIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxvUaBElWJbk6ybYka+fYfrckH+22X5zksD7rkSTdVm9BkGQJcDbwTOBI4OQkR87qdipwQ1X9LvBW4M191SNJmlufXyg7BthWVdcAJDkXWANsHeqzBnhDt/xx4B+TpKqqx7o05fwim7Rv+gyC5cB1Q+vbgcfP16eqbk3yE+A+wA+HOyU5HTi9W70pydW3s6ZDZu+7AY55TDLZ41n/O7fhjoz5QfNtWBRTTFTVOmDdHd1Pks1VNbMAJS0ajrkNjrkNfY25z4vFO4BDh9ZXdG1z9kmyFLgXcH2PNUmSZukzCDYBK5McnmQ/4CRgw6w+G4AXdMt/CnzO6wOSNF69nRrqzvmfAZwPLAHOqaotSc4CNlfVBuB9wIeSbAN+xCAs+nSHTy8tQo65DY65Db2MOf4BLklt85vFktQ4g0CSGtdMEOxtuotpkOScJDuTfG2o7d5JLkjyze7f35lkjQspyaFJLkyyNcmWJC/t2qd5zPsnuSTJV7sx/03Xfng3Tcu2btqW/SZd60JLsiTJZUn+o1uf6jEnuTbJlUkuT7K5a+vls91EEIw43cU0eD+walbbWuCzVbUS+Gy3Pi1uBV5RVUcCTwBe3P13neYx3wwcV1WPBo4CViV5AoPpWd7aTddyA4PpW6bNS4GrhtZbGPNTq+qooe8O9PLZbiIIGJruoqpuAXZPdzFVquoLDO6+GrYG+EC3/AHgOWMtqkdV9f2q+kq3/FMGvySWM91jrqq6qVu9a/dTwHEMpmmBKRszQJIVwAnAe7v1MOVjnkcvn+1WgmCu6S6WT6iWcbtfVX2/W/4f4H6TLKYv3cy1jwEuZsrH3J0iuRzYCVwAfAv4cVXd2nWZxs/324C/An7drd+H6R9zAf+V5NJumh3o6bO9KKaY0MKoqkoydfcLJ7k78AngZVV14+CPxYFpHHNV/Qo4KsnBwCeBIyZcUq+SPAvYWVWXJjl20vWM0ZOqakeS+wIXJPn68MaF/Gy3ckQwynQX0+oHSR4A0P27c8L1LKgkd2UQAv9SVf/aNU/1mHerqh8DFwK/BxzcTdMC0/f5fiKwOsm1DE7rHge8nekeM1W1o/t3J4PAP4aePtutBMEo011Mq+FpPF4A/NsEa1lQ3Xni9wFXVdVbhjZN85iXdUcCJDkAeDqDayMXMpimBaZszFX1mqpaUVWHMfh/93NV9XymeMxJDkpyj93LwDOAr9HTZ7uZbxYnOZ7Becbd0128ccIlLbgkHwGOZTBV7Q+A1wOfAtYDDwS+A5xYVbMvKC9KSZ4EfBG4kt+eO34tg+sE0zrmRzG4SLiEwR9y66vqrCQPZvDX8r2By4BTqurmyVXaj+7U0Cur6lnTPOZubJ/sVpcCH66qNya5Dz18tpsJAknS3Fo5NSRJmodBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhr3fxA33MPoF4ScAAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Vugq2ola0mQ9"
      },
      "source": [
        "# Create one-hot-encoded tensors of \"line_number\" column\n",
        "\n",
        "import tensorflow as tf\n",
        "\n",
        "train_line_numbers_one_hot = tf.one_hot(train_df[\"line_number\"].to_numpy(), depth=15)\n",
        "val_line_numbers_one_hot = tf.one_hot(val_df[\"line_number\"].to_numpy(), depth=15)\n",
        "test_line_numbers_one_hot = tf.one_hot(test_df[\"line_number\"].to_numpy(), depth=15)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 276
        },
        "id": "q5_abmLt6Ryf",
        "outputId": "514dc22d-701d-40d5-9b21-0f35050f529d"
      },
      "source": [
        "\n",
        "train_df.total_lines.plot.hist();"
      ],
      "execution_count": null,
      "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"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IwLPpI4e6Tvi",
        "outputId": "690f189e-e038-4c34-ebe4-344de5d10e86"
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "np.percentile(train_df.total_lines, 98)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "20.0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dusKr-bU6VfY"
      },
      "source": [
        "# Create one-hot-encoded tensors of \"total_lines\" column\n",
        "\n",
        "train_total_lines_one_hot = tf.one_hot(train_df[\"total_lines\"].to_numpy(), depth=20)\n",
        "val_total_lines_one_hot = tf.one_hot(val_df[\"total_lines\"].to_numpy(), depth=20)\n",
        "test_total_lines_one_hot = tf.one_hot(test_df[\"total_lines\"].to_numpy(), depth=20)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rtuqFLHc6wYU"
      },
      "source": [
        "### Converting abstract lines to lists"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Pm1FQ2eA625r",
        "outputId": "78a1577d-abee-46ee-9b8d-6e861763e041"
      },
      "source": [
        "# Convert abstract text lines into lists of sentences\n",
        "train_sentences = train_df[\"text\"].tolist()\n",
        "val_sentences = val_df[\"text\"].tolist()\n",
        "test_sentences = test_df[\"text\"].tolist()\n",
        "len(train_sentences), len(val_sentences), len(test_sentences)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(2211861, 28932, 29493)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4R-NUaMFDNl_"
      },
      "source": [
        "char_lens = [len(sentence) for sentence in train_sentences]\n",
        "char_len = int(np.percentile(char_lens, 95))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qYqf3VA465Kb"
      },
      "source": [
        "# Convert abstract text sentences into lists of characters\n",
        "\n",
        "def split_chars(text):\n",
        "  return \" \".join(list(text))\n",
        "  \n",
        "train_chars = [split_chars(sentence) for sentence in train_sentences]\n",
        "val_chars = [split_chars(sentence) for sentence in val_sentences]\n",
        "test_chars = [split_chars(sentence) for sentence in test_sentences]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TCtfTE_h7f5Q"
      },
      "source": [
        "### Creating Tensor Datasets"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Vj-tg8YO8EdE"
      },
      "source": [
        "# Train Dataset\n",
        "train_input = tf.data.Dataset.from_tensor_slices((train_line_numbers_one_hot,\n",
        "                                                  train_total_lines_one_hot,\n",
        "                                                  train_sentences,\n",
        "                                                  train_chars))\n",
        "train_labels = tf.data.Dataset.from_tensor_slices(train_labels_one_hot)\n",
        "train_dataset = tf.data.Dataset.zip((train_input, train_labels)).batch(32).prefetch(tf.data.AUTOTUNE)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QYQqcVPS8hoF"
      },
      "source": [
        "# Val Dataset\n",
        "val_input = tf.data.Dataset.from_tensor_slices((val_line_numbers_one_hot,\n",
        "                                                val_total_lines_one_hot,\n",
        "                                                val_sentences,\n",
        "                                                val_chars))\n",
        "val_labels = tf.data.Dataset.from_tensor_slices(val_labels_one_hot)\n",
        "val_dataset = tf.data.Dataset.zip((val_input, val_labels)).batch(32).prefetch(tf.data.AUTOTUNE)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Zw308bE68z59"
      },
      "source": [
        "# Test Dataset\n",
        "test_input = tf.data.Dataset.from_tensor_slices((test_line_numbers_one_hot,\n",
        "                                                 test_total_lines_one_hot,\n",
        "                                                 test_sentences,\n",
        "                                                 test_chars))\n",
        "test_dataset = test_input.batch(32).prefetch(tf.data.AUTOTUNE)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pfu-08kE0IyL"
      },
      "source": [
        "## Model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R-7-QQXPDzT9"
      },
      "source": [
        "### Creating layers"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0WzjMKeDB54c"
      },
      "source": [
        "import string\n",
        "alphabet = string.ascii_lowercase + string.digits + string.punctuation\n",
        "\n",
        "char_lens = [len(sentence) for sentence in train_sentences]\n",
        "char_len = int(np.percentile(char_lens, 95))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_fLPqEaS9RYY"
      },
      "source": [
        "import tensorflow_hub as hub\n",
        "from tensorflow.keras.layers.experimental.preprocessing import TextVectorization\n",
        "\n",
        "# Embedding Layer\n",
        "embedding_layer = hub.KerasLayer(\"https://tfhub.dev/google/universal-sentence-encoder/4\",\n",
        "                                 trainable=False,\n",
        "                                 name=\"USE\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DATtwyMiGjX4"
      },
      "source": [
        "# Character Vectorizer\n",
        "char_vectorizer = TextVectorization(max_tokens = len(alphabet)+2,\n",
        "                                    output_sequence_length = char_len,\n",
        "                                    standardize = \"lower_and_strip_punctuation\",\n",
        "                                    name = \"char_vectorizer\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UcvMB7BjO4pE"
      },
      "source": [
        "char_vectorizer.adapt(train_chars[:500000])\n",
        "char_vectorizer.adapt(train_chars[500000:1000000])\n",
        "char_vectorizer.adapt(train_chars[1000000:1500000])\n",
        "char_vectorizer.adapt(train_chars[1500000:2000000])\n",
        "char_vectorizer.adapt(train_chars[2000000:])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1Dh7v5IvSzFb"
      },
      "source": [
        "# Character Embedding\n",
        "char_embed = tf.keras.layers.Embedding(input_dim=len(alphabet) + 2,\n",
        "                              output_dim=25,\n",
        "                              mask_zero=True,\n",
        "                              name=\"char_embed\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qaaY9EpKDmot"
      },
      "source": [
        "### Model Architecture"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VBUpkE8CD4lt"
      },
      "source": [
        "from tensorflow.keras import layers\n",
        "\n",
        "# Sentence Inputs\n",
        "sentence_inputs = layers.Input(shape=[], dtype=\"string\", name=\"sentence_inputs\")\n",
        "sentence_embeddings = embedding_layer(sentence_inputs)\n",
        "sentence_outputs = layers.Dense(128, activation=\"relu\")(sentence_embeddings)\n",
        "sentence_model = tf.keras.Model(inputs=sentence_inputs,\n",
        "                                outputs=sentence_embeddings)\n",
        "\n",
        "# Character Inputs\n",
        "character_inputs = layers.Input(shape=(1,), dtype=\"string\", name=\"character_inputs\")\n",
        "character_vectors = char_vectorizer(character_inputs)\n",
        "character_embeddings = char_embed(character_vectors)\n",
        "character_outputs = layers.Bidirectional(layers.LSTM(32))(character_embeddings)\n",
        "character_model = tf.keras.Model(inputs=character_inputs,\n",
        "                                 outputs=character_outputs)\n",
        "\n",
        "# Line Number Inputs\n",
        "line_number_inputs = layers.Input(shape=(15,), dtype=tf.int32, name=\"line_number_input\")\n",
        "line_number_outputs = layers.Dense(32, activation=\"relu\")(line_number_inputs)\n",
        "line_number_model = tf.keras.Model(inputs=line_number_inputs,\n",
        "                                   outputs=line_number_outputs)\n",
        "\n",
        "# Total Lines Inputs\n",
        "total_lines_inputs = layers.Input(shape=(20,), dtype=tf.int32, name=\"total_lines_input\")\n",
        "total_lines_outputs = layers.Dense(32, activation=\"relu\")(total_lines_inputs)\n",
        "total_lines_model = tf.keras.Model(inputs=total_lines_inputs,\n",
        "                                   outputs=total_lines_outputs)\n",
        "\n",
        "# Sentence and Character Hybrid Embedding\n",
        "sentence_character_hybrid = layers.Concatenate(name=\"sentence_character_hybrid\")([sentence_model.output, character_model.output])\n",
        "hidden_layer = layers.Dense(256, activation=\"relu\")(sentence_character_hybrid)\n",
        "hidden_layer = layers.Dropout(0.5)(hidden_layer)\n",
        "\n",
        "# Combine Line Number, Total Lines and Last Hidden Layer\n",
        "\n",
        "mega_layer = layers.Concatenate(name=\"mega_layer\")([line_number_model.output,\n",
        "                                                    total_lines_model.output,\n",
        "                                                    hidden_layer])\n",
        "\n",
        "# Output Layer\n",
        "output_layer = layers.Dense(5, activation=\"softmax\", name=\"output_layer\")(mega_layer)\n",
        "\n",
        "# Model\n",
        "model = tf.keras.Model(inputs=[line_number_model.input,\n",
        "                               total_lines_model.input,\n",
        "                               sentence_model.input,\n",
        "                               character_model.input],\n",
        "                       outputs=output_layer)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 856
        },
        "id": "-iyv0nU0FCw3",
        "outputId": "2c0d50c9-466b-46c0-c2e1-87dbe2d36993"
      },
      "source": [
        "tf.keras.utils.plot_model(model)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 76
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "raY4iomgYa5n"
      },
      "source": [
        "### Compiling the Model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dcavyBIuTi6M"
      },
      "source": [
        "# Compile the model\n",
        "model.compile(loss=tf.keras.losses.CategoricalCrossentropy(label_smoothing=0.2),\n",
        "              optimizer=tf.keras.optimizers.Adam(),\n",
        "              metrics=[\"accuracy\"])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NrpMJ3f9Uwzt"
      },
      "source": [
        "### Fitting the Model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e9eGb5lUUzJe",
        "outputId": "34b9c291-03fa-4035-ad30-6a606dbc1c1c"
      },
      "source": [
        "history = model.fit(train_dataset,\n",
        "                    steps_per_epoch=int(0.1*len(train_dataset)),\n",
        "                    epochs=3,\n",
        "                    validation_data=val_dataset,\n",
        "                    validation_steps=int(0.1*len(val_dataset)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/3\n",
            "6912/6912 [==============================] - 324s 45ms/step - loss: 0.9509 - accuracy: 0.8262 - val_loss: 0.9168 - val_accuracy: 0.8549\n",
            "Epoch 2/3\n",
            "6912/6912 [==============================] - 295s 43ms/step - loss: 0.9215 - accuracy: 0.8478 - val_loss: 0.9058 - val_accuracy: 0.8608\n",
            "Epoch 3/3\n",
            "6912/6912 [==============================] - 296s 43ms/step - loss: 0.9168 - accuracy: 0.8514 - val_loss: 0.9001 - val_accuracy: 0.8642\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8KU5QdDWEf4p"
      },
      "source": [
        "Due to the lack of GPU, i've only trained for 3 epochs. You can expect better results by training for more epochs and adding callbacks."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UOp6Zs6JcvQZ"
      },
      "source": [
        "## Plotting Graphs"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yxozMFPUcX5r"
      },
      "source": [
        "import matplotlib.pyplot as plt"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 573
        },
        "id": "bs62WpQZcqwL",
        "outputId": "ebc5a602-4fb6-4efb-e1fe-c6c2e82c2f93"
      },
      "source": [
        "# summarize history for accuracy\n",
        "plt.plot(history.history['accuracy'])\n",
        "plt.plot(history.history['val_accuracy'])\n",
        "plt.title('model accuracy')\n",
        "plt.ylabel('accuracy')\n",
        "plt.xlabel('epoch')\n",
        "plt.legend(['train', 'test'], loc='upper left')\n",
        "plt.show()\n",
        "# summarize history for loss\n",
        "plt.plot(history.history['loss'])\n",
        "plt.plot(history.history['val_loss'])\n",
        "plt.title('model loss')\n",
        "plt.ylabel('loss')\n",
        "plt.xlabel('epoch')\n",
        "plt.legend(['train', 'test'], loc='upper left')\n",
        "plt.show()"
      ],
      "execution_count": null,
      "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"
          }
        },
        {
          "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"
          }
        }
      ]
    }
  ]
}