700 lines (699 with data), 81.3 kB

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 177,
   "id": "75a9cab2",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import random\n",
    "import numpy as np\n",
    "import pickle\n",
    "\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "7d42d817",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[nltk_data] Error loading stopwords: <urlopen error [SSL:\n",
      "[nltk_data]     CERTIFICATE_VERIFY_FAILED] certificate verify failed:\n",
      "[nltk_data]     unable to get local issuer certificate (_ssl.c:1131)>\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "import spacy\n",
    "\n",
    "import nltk\n",
    "import string\n",
    "#nltk.download('punkt')\n",
    "nltk.download('stopwords')\n",
    "from nltk.corpus import stopwords\n",
    "STOP_WORDS = stopwords.words('english')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "b8516e50",
   "metadata": {},
   "outputs": [],
   "source": [
    "bio_files_dir = '../data/bio_data_files'\n",
    "bio_files = [os.path.join(bio_files_dir, f) for f in os.listdir('../data/bio_data_files') if f.endswith('.bio')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "cebfd940",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number of .bio files is 200\n"
     ]
    }
   ],
   "source": [
    "print(f\"The number of .bio files is {len(bio_files)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bfe2b598",
   "metadata": {},
   "source": [
    "## Check if any of the stopwords contain B-tag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "4d9f940a",
   "metadata": {},
   "outputs": [],
   "source": [
    "for bio_file in bio_files:\n",
    "    with open(bio_file, \"r\", encoding='utf-8') as f:\n",
    "        for line in f:\n",
    "            if line.strip() == '':\n",
    "                continue\n",
    "            word, tag = line.strip().split('\\t')\n",
    "            if word in STOP_WORDS and tag.startswith('B'):\n",
    "                print(line)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fbe4fa1",
   "metadata": {},
   "source": [
    "## Data Cleaning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "73f0e53d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def clean_word(word):\n",
    "    \n",
    "    # remove non-alphanumeric characters and extra whitespaces\n",
    "    word = re.sub(r'[^\\w\\s]','',word)\n",
    "    word = re.sub(r'\\s+',' ',word)\n",
    "    \n",
    "    # convert to lowercase\n",
    "    word = word.lower()\n",
    "    \n",
    "    if word not in STOP_WORDS:\n",
    "        return word\n",
    "    \n",
    "    return ''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "09853edd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load a pre-trained Spacy model and set the stop words\n",
    "nlp = spacy.load('en_core_web_sm')\n",
    "\n",
    "def clean_word(word):\n",
    "    # remove non-alphanumeric characters and extra whitespaces\n",
    "    word = re.sub(r'[^\\w\\s]','',word)\n",
    "    word = re.sub(r'\\s+',' ',word)\n",
    "    \n",
    "    # convert to lowercase\n",
    "    word = word.lower()\n",
    "\n",
    "    # lemmatize the word\n",
    "    lemma = nlp(word)[0].lemma_\n",
    "    \n",
    "    # check if the lemma is a stop word\n",
    "    if lemma not in STOP_WORDS:\n",
    "        return lemma\n",
    "    \n",
    "    return ''\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "141f77d8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def parse_data_from_file(bio_file):\n",
    "    \"\"\"\n",
    "    Reads a file in BIO format (one token per line, with tab-separated word and tag),\n",
    "    and extracts the sentences and labels as lists of lists. Each inner list represents\n",
    "    a sentence, and contains the words of the sentence in order. Each corresponding inner\n",
    "    list in the 'labels' list contains the BIO tags for the words in the corresponding\n",
    "    sentence, in the same order.\n",
    "    \n",
    "    Args:\n",
    "    - bio_file (str): the path to the BioNLP file to read\n",
    "    \n",
    "    Returns:\n",
    "    - A tuple containing:\n",
    "        - sentences (List[List[str]]): a list of lists, where each inner list represents\n",
    "          a sentence and contains the words of the sentence in order\n",
    "        - labels (List[List[str]]): a list of lists, where each inner list corresponds\n",
    "          to a sentence in the 'sentences' list and contains the BIO tags for the words\n",
    "          in the corresponding sentence, in the same order.\n",
    "    \"\"\"\n",
    "    sentences = []\n",
    "    labels = []\n",
    "    \n",
    "    with open(bio_file, \"r\", encoding='utf-8') as f:\n",
    "        \n",
    "        current_sentences = []\n",
    "        current_labels = []\n",
    "        \n",
    "        for line in f:\n",
    "            \n",
    "            if line.strip() == '':\n",
    "                # If we encounter a blank line, it means we've reached the end of a sentence\n",
    "                if len(current_sentences) > 0:\n",
    "                    \n",
    "                    # Add the current sentence and labels to the list\n",
    "                    sentences.append(current_sentences)\n",
    "                    labels.append(current_labels)\n",
    "                    \n",
    "                    # Reset the current sentence and labels lists\n",
    "                    current_sentences = []\n",
    "                    current_labels = []\n",
    "                    continue\n",
    "                    \n",
    "            word, tag = line.strip().split('\\t')\n",
    "            word = clean_word(word)\n",
    "            \n",
    "            if word.strip():\n",
    "                current_sentences.append(word)\n",
    "                \n",
    "                if len(current_labels) > 0:\n",
    "                    if tag[2:] == current_labels[-1][2:] and tag[:2] == \"B-\":\n",
    "                        tag = f\"I-{tag[2:]}\"\n",
    "                current_labels.append(tag)\n",
    "        \n",
    "    return sentences, labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "fd844f67",
   "metadata": {},
   "outputs": [],
   "source": [
    "def parse_bio_files(bio_files):\n",
    "    \n",
    "    sentences = []\n",
    "    labels = []\n",
    "    \n",
    "    for idx, bio_file in enumerate(bio_files):\n",
    "        \n",
    "        curr_sentences, curr_labels = parse_data_from_file(bio_file)\n",
    "        \n",
    "        if len(curr_sentences) > 0:\n",
    "            sentences.extend(curr_sentences)\n",
    "            labels.extend(curr_labels)\n",
    "            \n",
    "        if (idx+1) % 20 == 0:\n",
    "            print(f'{idx+1} completed')\n",
    "\n",
    "    return sentences, labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "45fd1f2c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20 completed\n",
      "40 completed\n",
      "60 completed\n",
      "80 completed\n",
      "100 completed\n",
      "120 completed\n",
      "140 completed\n",
      "160 completed\n",
      "180 completed\n",
      "200 completed\n"
     ]
    }
   ],
   "source": [
    "sentences, labels = parse_bio_files(bio_files)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "b53eabb9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset contains 4341 examples\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(f\"Dataset contains {len(sentences)} examples\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46342054",
   "metadata": {},
   "source": [
    "## Shuffle the sentences and labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "56e01b35",
   "metadata": {},
   "outputs": [],
   "source": [
    "combined = list(zip(sentences, labels))\n",
    "random.shuffle(combined)\n",
    "sentences[:], labels[:] = zip(*combined)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "722ff4a8",
   "metadata": {},
   "source": [
    "## Train Test Validation Split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "30bb6251",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Split the data into training, validation, and test sets\n",
    "\n",
    "TEST_SIZE = 0.2\n",
    "\n",
    "num_sentences = len(sentences)\n",
    "num_train = int(num_sentences * (1 - TEST_SIZE - 0.1))\n",
    "num_valid = int(num_sentences * 0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "id": "0c1d5432",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_sentences = sentences[:num_train]\n",
    "train_labels = labels[:num_train]\n",
    "\n",
    "valid_sentences = sentences[num_train:num_train+num_valid]\n",
    "valid_labels = labels[num_train:num_train+num_valid]\n",
    "\n",
    "test_sentences = sentences[num_train+num_valid:]\n",
    "test_labels = labels[num_train+num_valid:]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d413c70",
   "metadata": {},
   "source": [
    "## Tokenization - Sequences and padding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "de6ea2c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "unique_labels = set(element for sublist in labels for element in sublist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "id": "9e0dbaea",
   "metadata": {},
   "outputs": [],
   "source": [
    "label_to_index = {label: id+1 for id, label in enumerate(sorted(unique_labels))}\n",
    "index_to_label = {id: label for label, id in label_to_index.items()}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "id": "9ba093e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add the new label and ID to the dictionaries\n",
    "label_to_index['<PAD>'] = 0\n",
    "index_to_label[0] = '<PAD>'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "id": "c4f7383a",
   "metadata": {},
   "outputs": [],
   "source": [
    "NUM_CLASSES = len(index_to_label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "id": "91f9e4df",
   "metadata": {},
   "outputs": [],
   "source": [
    "MAX_LENGTH = 100\n",
    "\n",
    "train_labels = [[label_to_index[label] for label in labels] for labels in train_labels]\n",
    "train_labels = pad_sequences(train_labels, maxlen=MAX_LENGTH, padding='post', value=NUM_CLASSES-1)\n",
    "train_labels = to_categorical(train_labels, num_classes=NUM_CLASSES)\n",
    "\n",
    "valid_labels = [[label_to_index[label] for label in labels] for labels in valid_labels]\n",
    "valid_labels = pad_sequences(valid_labels, maxlen=MAX_LENGTH, padding='post', value=NUM_CLASSES-1)\n",
    "valid_labels = to_categorical(valid_labels, num_classes=NUM_CLASSES)\n",
    "\n",
    "test_labels = [[label_to_index[label] for label in labels] for labels in test_labels]\n",
    "test_labels = pad_sequences(test_labels, maxlen=MAX_LENGTH, padding='post', value=NUM_CLASSES-1)\n",
    "test_labels = to_categorical(test_labels, num_classes=NUM_CLASSES)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "id": "a5fc9b7d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert the input sentences to sequences of word indices\n",
    "tokenizer = Tokenizer()\n",
    "tokenizer.fit_on_texts(train_sentences)\n",
    "\n",
    "\n",
    "train_sequences = tokenizer.texts_to_sequences(train_sentences)\n",
    "val_sequences = tokenizer.texts_to_sequences(valid_sentences)\n",
    "test_sequences = tokenizer.texts_to_sequences(test_sentences)\n",
    "\n",
    "\n",
    "# Pad the sequences to a fixed length\n",
    "train_sequences_padded = pad_sequences(train_sequences, maxlen=MAX_LENGTH, padding='post', truncating='post')\n",
    "val_sequences_padded = pad_sequences(val_sequences, maxlen=MAX_LENGTH, padding='post', truncating='post')\n",
    "test_sequences_padded = pad_sequences(test_sequences, maxlen=MAX_LENGTH, padding='post', truncating='post')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cfcdb497",
   "metadata": {},
   "source": [
    "###  save to a .npz file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "id": "27d0e8b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savez(\n",
    "    '../data/data.npz',\n",
    "     train_sequences_padded=train_sequences_padded,\n",
    "     train_labels=train_labels,\n",
    "     val_sequences_padded=val_sequences_padded,\n",
    "     val_labels=valid_labels,\n",
    "     test_sequences_padded=test_sequences_padded,\n",
    "     test_labels=test_labels,\n",
    "     label_to_index=label_to_index,\n",
    "     index_to_label=index_to_label\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "55c25a8f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "314f9f5d",
   "metadata": {},
   "source": [
    "## Building Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "id": "886f4882",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3038, 100, 79)"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_labels.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "id": "1cd0ea36",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n",
      "95/95 [==============================] - 8s 63ms/step - loss: 0.8827 - accuracy: 0.8964 - val_loss: 0.3796 - val_accuracy: 0.9129\n",
      "Epoch 2/20\n",
      "95/95 [==============================] - 6s 64ms/step - loss: 0.3871 - accuracy: 0.9065 - val_loss: 0.3668 - val_accuracy: 0.9130\n",
      "Epoch 3/20\n",
      "95/95 [==============================] - 6s 62ms/step - loss: 0.3634 - accuracy: 0.9086 - val_loss: 0.3585 - val_accuracy: 0.9149\n",
      "Epoch 4/20\n",
      "95/95 [==============================] - 6s 63ms/step - loss: 0.3383 - accuracy: 0.9138 - val_loss: 0.3494 - val_accuracy: 0.9180\n",
      "Epoch 5/20\n",
      "95/95 [==============================] - 6s 65ms/step - loss: 0.3026 - accuracy: 0.9217 - val_loss: 0.3306 - val_accuracy: 0.9253\n",
      "Epoch 6/20\n",
      "95/95 [==============================] - 6s 65ms/step - loss: 0.2605 - accuracy: 0.9332 - val_loss: 0.3159 - val_accuracy: 0.9305\n",
      "Epoch 7/20\n",
      "95/95 [==============================] - 6s 63ms/step - loss: 0.2212 - accuracy: 0.9435 - val_loss: 0.3047 - val_accuracy: 0.9337\n",
      "Epoch 8/20\n",
      "95/95 [==============================] - 6s 64ms/step - loss: 0.1884 - accuracy: 0.9523 - val_loss: 0.3058 - val_accuracy: 0.9359\n",
      "Epoch 9/20\n",
      "95/95 [==============================] - 6s 63ms/step - loss: 0.1612 - accuracy: 0.9589 - val_loss: 0.3036 - val_accuracy: 0.9377\n",
      "Epoch 10/20\n",
      "95/95 [==============================] - 6s 66ms/step - loss: 0.1393 - accuracy: 0.9642 - val_loss: 0.3080 - val_accuracy: 0.9390\n",
      "Epoch 11/20\n",
      "95/95 [==============================] - 6s 65ms/step - loss: 0.1217 - accuracy: 0.9684 - val_loss: 0.3115 - val_accuracy: 0.9392\n",
      "Epoch 12/20\n",
      "95/95 [==============================] - 6s 62ms/step - loss: 0.1071 - accuracy: 0.9719 - val_loss: 0.3183 - val_accuracy: 0.9402\n",
      "Epoch 13/20\n",
      "95/95 [==============================] - 6s 62ms/step - loss: 0.0950 - accuracy: 0.9750 - val_loss: 0.3252 - val_accuracy: 0.9404\n",
      "Epoch 14/20\n",
      "95/95 [==============================] - 6s 63ms/step - loss: 0.0846 - accuracy: 0.9779 - val_loss: 0.3346 - val_accuracy: 0.9409\n",
      "Epoch 15/20\n",
      "95/95 [==============================] - 6s 65ms/step - loss: 0.0758 - accuracy: 0.9802 - val_loss: 0.3395 - val_accuracy: 0.9406\n",
      "Epoch 16/20\n",
      "95/95 [==============================] - 6s 67ms/step - loss: 0.0680 - accuracy: 0.9822 - val_loss: 0.3533 - val_accuracy: 0.9407\n",
      "Epoch 17/20\n",
      "95/95 [==============================] - 6s 65ms/step - loss: 0.0606 - accuracy: 0.9844 - val_loss: 0.3563 - val_accuracy: 0.9407\n",
      "Epoch 18/20\n",
      "95/95 [==============================] - 6s 64ms/step - loss: 0.0545 - accuracy: 0.9861 - val_loss: 0.3661 - val_accuracy: 0.9408\n",
      "Epoch 19/20\n",
      "95/95 [==============================] - 6s 66ms/step - loss: 0.0488 - accuracy: 0.9878 - val_loss: 0.3751 - val_accuracy: 0.9405\n",
      "Epoch 20/20\n",
      "95/95 [==============================] - 6s 62ms/step - loss: 0.0439 - accuracy: 0.9893 - val_loss: 0.3879 - val_accuracy: 0.9407\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "id": "c7dd3bba",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "id": "841fc432",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "id": "ded6974a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "28/28 [==============================] - 0s 17ms/step - loss: 0.4221 - accuracy: 0.9364\n",
      "Test accuracy: 0.9364326596260071\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "9f061245",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "id": "5c4b7d16",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 0s 9ms/step\n",
      "Predicted Named Entities:\n",
      "leptospira: Diagnostic_procedure\n",
      "igm: Diagnostic_procedure\n",
      "antibody: O\n",
      "perform: Date\n",
      "5th: Date\n",
      "day: O\n",
      "illness: Lab_value\n",
      "positive: Diagnostic_procedure\n",
      "igg: Lab_value\n",
      "negative: O\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "id": "2bf7f283",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Assuming tokenizer is your trained tokenizer\n",
    "with open('../data/tokenizer.pickle', 'wb') as handle:\n",
    "    pickle.dump(tokenizer, handle, protocol=pickle.HIGHEST_PROTOCOL)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e4de8cb8",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}