{ "cells": [ { "cell_type": "raw", "metadata": {}, "source": [ "---\n", "title: 21 Named Entiry Recognition using Transformer\n", "description: An implementation of Transformer to perform token classification and identify species in PubMed abstracts\n", "---" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\"Colab\"" ] }, { "cell_type": "markdown", "metadata": { "id": "m8qFH7JQE4ht" }, "source": [ "\"Kaggle\"" ] }, { "cell_type": "markdown", "metadata": { "id": "djp2XOqO88qw" }, "source": [ "# Named Entity Recognition (NER)\n", "\n", "NER is an information extraction technique to identify and classify named entities in text. These entities can be pre-defined and generic like location names, organizations, time and etc, or they can be very specific like the example with the resume.\n", "\n", "The goal of a named entity recognition (NER) system is to identify all textual mentions of the named entities. This can be broken down into two sub-tasks: identifying the boundaries of the NE, and identifying its type.\n", "\n", "Named entity recognition is a task that is well-suited to the type of classifier-based approach. In particular, a tagger can be built that labels each word in a sentence using the IOB format, where chunks are labelled by their appropriate type.\n", "\n", "The IOB Tagging system contains tags of the form:\n", "\n", "* B - {CHUNK_TYPE} – for the word in the Beginning chunk\n", "* I - {CHUNK_TYPE} – for words Inside the chunk\n", "* O – Outside any chunk\n", "\n", "## Approaches to NER\n", "* **Classical Approaches:** mostly rule-based.\n", "* **Machine Learning Approaches:** there are two main methods in this category: \n", " * Treat the problem as a multi-class classification where named entities are our labels so we can apply different classification algorithms. The problem here is that identifying and labeling named entities require thorough understanding of the context of a sentence and sequence of the word labels in it, which this method ignores that.\n", " * Conditional Random Field (CRF) model. It is a probabilistic graphical model that can be used to model sequential data such as labels of words in a sentence. The CRF model is able to capture the features of the current and previous labels in a sequence but it cannot understand the context of the forward labels; this shortcoming plus the extra feature engineering involved with training a CRF model, makes it less appealing to be adapted by the industry.\n", "* **Deep Learning Approaches:** Bidirectional RNNs, Transformers" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "2KLIs8HHyrHd" }, "outputs": [], "source": [ "%%capture\n", "!pip install datasets" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "zy7PRVmH7ssP" }, "outputs": [], "source": [ "import numpy as np\n", "import pandas as pd\n", "import matplotlib.pyplot as plt\n", "import seaborn as sns\n", "from datasets import load_dataset\n", "\n", "plt.style.use('fivethirtyeight')" ] }, { "cell_type": "markdown", "metadata": { "id": "c-nHc7hB7wUF" }, "source": [ "# Getting the Dataset and EDA\n", "\n", "We will be working on S800 Corpus, which is a novel abstract-based manually annotated corpus. S800 comprises 800 PubMed abstracts in which organism mentions were identified and mapped to the corresponding NCBI Taxonomy identifiers.\n", "\n", "It is available on Hugging Face Datasets Hub" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "oiFtTMyry0rK" }, "outputs": [], "source": [ "%%capture\n", "dataset = load_dataset('species_800')\n", "\n", "train_df = pd.DataFrame(dataset['train']).explode(['tokens', 'ner_tags']).dropna()\n", "valid_df = pd.DataFrame(dataset['validation']).explode(['tokens', 'ner_tags']).dropna()\n", "test_df = pd.DataFrame(dataset['test']).explode(['tokens', 'ner_tags']).dropna()" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 206 }, "id": "YwmEqJAxzTTj", "outputId": "0a2965db-a864-470c-e31d-c7a21aa344a0" }, "outputs": [ { "data": { "text/html": [ "\n", "
\n", "
\n", "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
idtokensner_tags
00Methanoregula1
00formicica2
00sp0
00.0
00nov0
\n", "
\n", " \n", " \n", " \n", "\n", " \n", "
\n", "
\n", " " ], "text/plain": [ " id tokens ner_tags\n", "0 0 Methanoregula 1\n", "0 0 formicica 2\n", "0 0 sp 0\n", "0 0 . 0\n", "0 0 nov 0" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "train_df.head()" ] }, { "cell_type": "markdown", "metadata": { "id": "QtzeA-Te9xAM" }, "source": [ "Here ner_tag 1 indicates B\n", "and ner_tag 2 indicates I\n", "while ner_tag 0 indicates O\n", "\n", "for simplicity we will combine B and I" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "5Y6SPkV5-CuX" }, "outputs": [], "source": [ "train_df['ner_tags'] = train_df['ner_tags'].apply(lambda x: 1 if x > 0 else 0)\n", "valid_df['ner_tags'] = valid_df['ner_tags'].apply(lambda x: 1 if x > 0 else 0)\n", "test_df['ner_tags'] = test_df['ner_tags'].apply(lambda x: 1 if x > 0 else 0)" ] }, { "cell_type": "markdown", "metadata": { "id": "yhDHajh-9ewG" }, "source": [ "**Create list of list of tuples to differentiate each sentence from each other**" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "z9VjHDGU0JAL" }, "outputs": [], "source": [ "class SentenceGetter(object):\n", " \n", " def __init__(self, dataset, word_col, tag_col, sent_id_col):\n", " self.n_sent = 1\n", " self.dataset = dataset\n", " self.empty = False\n", " agg_func = lambda s: [\n", " (w, t) for w,t in zip(s[word_col].values.tolist(), s[tag_col].values.tolist())\n", " ]\n", " self.grouped = self.dataset.groupby(sent_id_col).apply(agg_func)\n", " self.sentences = [s for s in self.grouped]\n", " \n", " def get_next(self):\n", " try:\n", " s = self.grouped[\"Sentence: {}\".format(self.n_sent)]\n", " self.n_sent += 1\n", " return s\n", " except:\n", " return None" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "htPTQeiw1M9m", "outputId": "ea3b5019-3f58-4735-ed62-19764946be69" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Sample Sentence\n", "[('Methanoregula', 1), ('formicica', 1), ('sp', 0), ('.', 0), ('nov', 0), ('.', 0), (',', 0), ('a', 0), ('methane', 0), ('-', 0), ('producing', 0), ('archaeon', 0), ('isolated', 0), ('from', 0), ('methanogenic', 0), ('sludge', 0), ('.', 0)]\n" ] } ], "source": [ "train_getter = SentenceGetter(dataset=train_df, word_col='tokens', tag_col='ner_tags', sent_id_col='id')\n", "valid_getter = SentenceGetter(dataset=valid_df, word_col='tokens', tag_col='ner_tags', sent_id_col='id')\n", "test_getter = SentenceGetter(dataset=test_df, word_col='tokens', tag_col='ner_tags', sent_id_col='id')\n", "\n", "train_sentences = train_getter.sentences\n", "valid_sentences = valid_getter.sentences\n", "test_sentences = test_getter.sentences\n", "print('Sample Sentence')\n", "print(train_sentences[0])" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 412 }, "id": "9sbOeTzd9toq", "outputId": "5494ad1a-6a66-46fb-bfc3-5c1d755dd468" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Number of Sentences: 5733\n", "Maximum sequence length: 132\n", "Number of unique words: 14267\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, ax = plt.subplots(figsize=(20, 6))\n", "ax.hist([len(s) for s in train_sentences], bins=50)\n", "ax.set_title('Number of words in each Sentence')\n", "\n", "maxlen = max([len(s) for s in train_sentences])\n", "print('Number of Sentences:', len(train_sentences))\n", "print ('Maximum sequence length:', maxlen)\n", "\n", "words = list(set(train_df[\"tokens\"].values))\n", "words.append(\"ENDPAD\")\n", "words.append(\"UNK\")\n", "n_words = len(words)\n", "print('Number of unique words:', n_words)" ] }, { "cell_type": "markdown", "metadata": { "id": "3VuLnKpy_RMj" }, "source": [ "**Converting words to numbers and numbers to words**" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "AyLf_F4N_QVi" }, "outputs": [], "source": [ "word2idx = {w: i for i, w in enumerate(words)}\n", "idx2word = {i: w for i, w in enumerate(words)}" ] }, { "cell_type": "markdown", "metadata": { "id": "5n6W0bOK_cxN" }, "source": [ "# Modelling" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "qbnZPCG4_b7H" }, "outputs": [], "source": [ "import tensorflow as tf\n", "from tensorflow import keras\n", "import tensorflow.keras.layers as L\n", "from tensorflow.keras.preprocessing.text import Tokenizer\n", "from tensorflow.keras.preprocessing import sequence\n", "from tensorflow.keras.callbacks import EarlyStopping, CSVLogger, ReduceLROnPlateau\n", "from tensorflow.keras.utils import plot_model, to_categorical" ] }, { "cell_type": "markdown", "metadata": { "id": "HtX7DfgiDy8u" }, "source": [ "**Lets first tokenize the data**" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "xs3PVPxI_QSD", "outputId": "84d17554-0e4b-4961-8cfe-be5bc967d69d" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "X shape (5733, 132) y shape (5733, 132, 2)\n" ] } ], "source": [ "X_train = [[word2idx.get(w[0], len(word2idx)-1) for w in s] for s in train_sentences]\n", "X_train = sequence.pad_sequences(maxlen=maxlen, sequences=X_train, padding=\"post\",value=n_words - 2)\n", "\n", "y_train = [[[w[1]] for w in s] for s in train_sentences]\n", "y_train = sequence.pad_sequences(maxlen=maxlen, sequences=y_train, padding=\"post\", value=0)\n", "y_train = np.array([to_categorical(i, num_classes=2) for i in y_train])\n", "\n", "print('X shape', X_train.shape, 'y shape', y_train.shape)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "gPdgQhvL_QPx", "outputId": "437f058d-2984-464f-b10c-da21b13004a0" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "X shape (830, 132) y shape (830, 132, 2)\n" ] } ], "source": [ "X_valid = [[word2idx.get(w[0], len(word2idx)-1) for w in s] for s in valid_sentences]\n", "X_valid = sequence.pad_sequences(maxlen=maxlen, sequences=X_valid, padding=\"post\",value=n_words - 2)\n", "\n", "y_valid = [[[w[1]] for w in s] for s in valid_sentences]\n", "y_valid = sequence.pad_sequences(maxlen=maxlen, sequences=y_valid, padding=\"post\", value=0)\n", "y_valid = np.array([to_categorical(i, num_classes=2) for i in y_valid])\n", "\n", "print('X shape', X_valid.shape, 'y shape', y_valid.shape)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "kq957YbLDUez", "outputId": "4dde00f5-68b6-4159-c63a-f9214d5c6ede" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "X shape (1630, 132) y shape (1630, 132, 2)\n" ] } ], "source": [ "X_test = [[word2idx.get(w[0], len(word2idx)-1) for w in s] for s in test_sentences]\n", "X_test = sequence.pad_sequences(maxlen=maxlen, sequences=X_test, padding=\"post\",value=n_words - 2)\n", "\n", "y_test = [[[w[1]] for w in s] for s in test_sentences]\n", "y_test = sequence.pad_sequences(maxlen=maxlen, sequences=y_test, padding=\"post\", value=0)\n", "y_test = np.array([to_categorical(i, num_classes=2) for i in y_test])\n", "\n", "print('X shape', X_test.shape, 'y shape', y_test.shape)" ] }, { "cell_type": "markdown", "metadata": { "id": "qbt_iTSKD_Xa" }, "source": [ "**Training Parameters**" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "TQNdDtcP_QNL" }, "outputs": [], "source": [ "class config():\n", " VOCAB = n_words\n", " MAX_LEN = maxlen\n", " N_OUPUT = 2\n", " \n", " \n", " EMBEDDING_VECTOR_LENGTH = 50\n", " DENSE_DIM = 32\n", " NUM_HEADS = 2\n", " \n", " OUTPUT_ACTIVATION = 'softmax'\n", " \n", " LOSS = 'categorical_crossentropy'\n", " OPTIMIZER = 'adam'\n", " METRICS = ['accuracy']\n", " \n", " MAX_EPOCHS = 100" ] }, { "cell_type": "markdown", "metadata": { "id": "d0Vxu0RFEAyi" }, "source": [ "**Lets define a standard Transformer Encoder Block**" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "T3clfbxU_QKi" }, "outputs": [], "source": [ "class TransformerEncoder(L.Layer):\n", " def __init__(self, embed_dim, dense_dim, num_heads, **kwargs):\n", " super().__init__(**kwargs)\n", " self.embed_dim = embed_dim\n", " self.dense_dim = dense_dim\n", " self.num_heads = num_heads\n", " self.attention = L.MultiHeadAttention(num_heads=num_heads, key_dim=embed_dim)\n", " self.dense_proj = keras.Sequential([L.Dense(dense_dim, activation='relu'), L.Dense(embed_dim)])\n", " self.layernorm1 = L.LayerNormalization()\n", " self.layernorm2 = L.LayerNormalization()\n", " \n", " def call(self, inputs, mask=None):\n", " if mask is not None:\n", " mask = mask[: tf.newaxis, :]\n", " attention_output = self.attention(inputs, inputs, attention_mask=mask)\n", " proj_input = self.layernorm1(inputs + attention_output)\n", " proj_output = self.dense_proj(proj_input)\n", " return self.layernorm2(proj_input + proj_output)\n", " \n", " def get_config(self):\n", " config = super().get_confog()\n", " config.update({\n", " \"embed_dim\": self.embed_dim,\n", " \"num_heads\": self.num_heads,\n", " \"dense_dim\": self.dense_dim\n", " })\n", " return config " ] }, { "cell_type": "markdown", "metadata": { "id": "ykTzN1aXEL1Y" }, "source": [ "**Some standard Callbacks**" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "CabuC5rBEK7u" }, "outputs": [], "source": [ "es = EarlyStopping(monitor='val_loss', mode='min', patience=10, restore_best_weights=True)\n", "rlp = ReduceLROnPlateau(monitor='loss', patience=3)\n", "csv_logger = CSVLogger('training_log.csv')" ] }, { "cell_type": "markdown", "metadata": { "id": "bRCFw15DEPdv" }, "source": [ "**Lets define our model**\n", "\n", "A token classification is pretty simple and similar to that of sequence classification, ie there is only one change, since we need predictions for each input tokken we do not use the Global Pooling Layer, therefore the architechture looks something like:\n", "* Input Layer\n", "* Embeddings\n", "* Transformer Encoder Block\n", "* Dropout (optional)\n", "* Classification Layer (where n_units = number of classes, ie 2 in out case)\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 902 }, "id": "0ylxJEnR_QHz", "outputId": "eea094aa-9ae1-4073-acd6-7fac27f5792f" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Model: \"model\"\n", "_________________________________________________________________\n", " Layer (type) Output Shape Param # \n", "=================================================================\n", " input_1 (InputLayer) [(None, None)] 0 \n", " \n", " embedding (Embedding) (None, None, 50) 713350 \n", " \n", " transformer_encoder (Transf (None, None, 50) 23832 \n", " ormerEncoder) \n", " \n", " dropout (Dropout) (None, None, 50) 0 \n", " \n", " dense_2 (Dense) (None, None, 2) 102 \n", " \n", "=================================================================\n", "Total params: 737,284\n", "Trainable params: 737,284\n", "Non-trainable params: 0\n", "_________________________________________________________________\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "inputs = keras.Input(shape=(None, ), dtype=\"int64\")\n", "x = L.Embedding(config.VOCAB, config.EMBEDDING_VECTOR_LENGTH)(inputs)\n", "x = TransformerEncoder(config.EMBEDDING_VECTOR_LENGTH, config.DENSE_DIM, config.NUM_HEADS)(x)\n", "x = L.Dropout(0.5)(x)\n", "outputs = L.Dense(config.N_OUPUT, activation=config.OUTPUT_ACTIVATION)(x)\n", "\n", "model = keras.Model(inputs, outputs)\n", "model.compile(loss=config.LOSS, optimizer=config.OPTIMIZER, metrics=config.METRICS)\n", "\n", "model.summary()\n", "plot_model(model, show_shapes=True)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "FrR__pB1_QDS" }, "outputs": [], "source": [ "%%capture\n", "history = model.fit(X_train, y_train, validation_data=(X_valid, y_valid),\n", " callbacks=[es, rlp, csv_logger], epochs=config.MAX_EPOCHS\n", ")" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 482 }, "id": "BAF-NVehBusb", "outputId": "45d42de0-c10a-45ed-be3d-6bbe6b17314a" }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, ax = plt.subplots(2, 1, figsize=(20, 8))\n", "df = pd.DataFrame(history.history)\n", "df[['accuracy', 'val_accuracy']].plot(ax=ax[0])\n", "df[['loss', 'val_loss']].plot(ax=ax[1])\n", "ax[0].set_title('Model Accuracy', fontsize=12)\n", "ax[1].set_title('Model Loss', fontsize=12)\n", "fig.suptitle('Model Metrics', fontsize=18);" ] }, { "cell_type": "markdown", "metadata": { "id": "yrAApw08EzwT" }, "source": [ "# Evaluation" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "BPJmHAtNBupE", "outputId": "f576c644-c1e5-4a17-c467-4638e04717d7" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Word True \tPred\n", "------------------------------\n", "We 0\t0\n", "have 0\t0\n", "studied 0\t0\n", "fluctuations 0\t0\n", "in 0\t0\n", "a 0\t0\n", "population 0\t0\n", "of 0\t0\n", "the 0\t0\n", "white 1\t1\n", "- 1\t0\n", "throated 1\t1\n", "dipper 1\t0\n", "Cinclus 1\t1\n", "cinclus 1\t1\n", "during 0\t0\n", "31 0\t0\n", "years 0\t0\n", "( 0\t0\n", "1978 0\t0\n", "- 0\t0\n", "2008 0\t0\n", ") 0\t0\n", "in 0\t0\n", "a 0\t0\n", "river 0\t0\n", "system 0\t0\n", "in 0\t0\n", "southern 0\t0\n", "Norway 0\t1\n", "in 0\t0\n", "relation 0\t0\n", "to 0\t0\n", "both 0\t0\n", "large 0\t0\n", "- 0\t0\n", "scale 0\t0\n", "and 0\t0\n", "local 0\t0\n", "weather 0\t0\n", "conditions 0\t0\n", "occurring 0\t0\n", "during 0\t0\n", "the 0\t0\n", "non 0\t0\n", "- 0\t0\n", "breeding 0\t0\n", "season 0\t0\n", ". 0\t0\n", "ENDPAD 0\t0\n" ] } ], "source": [ "i = np.random.randint(0, X_test.shape[0])\n", "p = model.predict(np.array([X_test[i]]))\n", "p = np.argmax(p, axis=-1)\n", "y_true = np.argmax(y_test, axis=-1)[i]\n", "\n", "print(f\"{'Word':15}{'True':5}\\t{'Pred'}\")\n", "print(\"-\"*30)\n", "for (w, t, pred) in zip(X_test[i], y_true, p[0]):\n", " print(f\"{words[w]:15}{t}\\t{pred}\")\n", " if words[w] == 'ENDPAD': \n", " break" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "MjN9oev8BufG" }, "outputs": [], "source": [] } ], "metadata": { "colab": { "collapsed_sections": [], "name": "Named-Emtity-Recognition-Transformers.ipynb", "provenance": [] }, "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.9.7" } }, "nbformat": 4, "nbformat_minor": 1 }