{

 "cells": [

  {

   "cell_type": "markdown",

   "metadata": {},

   "source": [

    "**Generation of a dataset already splited into train, val and test to standarize the evaluation of the different approaches for NER on clinical trial eligibility criteria**\n",

    "\n",

    "In this case, we are not going to consider pregnancy consideration classes, as well as mood entity."

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 42,

   "metadata": {},

   "outputs": [],

   "source": [

    "import numpy as np \n",

    "from datasets import Dataset, DatasetDict\n",

    "from sklearn.model_selection import train_test_split\n",

    "import os\n",

    "import re\n",

    "import pandas as pd\n",

    "import matplotlib.pyplot as plt\n",

    "from huggingface_hub import notebook_login"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 43,

   "metadata": {},

   "outputs": [],

   "source": [

    "# paths\n",

    "root = '..'\n",

    "# root = './drive/MyDrive/ProjectName' # if you are using google drive\n",

    "data_path = f'{root}/data'\n",

    "chia_bio = f'{data_path}/chia/'"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 44,

   "metadata": {},

   "outputs": [],

   "source": [

    "# read all the sentences per file\n",

    "files_train = os.listdir(f'{data_path}/chia/trains')\n",

    "files_test = os.listdir(f'{data_path}/chia/tests')"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 45,

   "metadata": {},

   "outputs": [

    {

     "data": {

      "text/plain": [

       "(1800, 200)"

      ]

     },

     "execution_count": 45,

     "metadata": {},

     "output_type": "execute_result"

    }

   ],

   "source": [

    "len(files_train), len(files_test)"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 104,

   "metadata": {},

   "outputs": [],

   "source": [

    "# dict for the entities (entity to int value)\n",

    "simple_ent = {\"Condition\", \"Value\", \"Drug\", \"Procedure\", \"Measurement\", \"Temporal\", \"Observation\", \"Person\", \"Device\"}\n",

    "sel_ent = {\n",

    "    \"O\": 0,\n",

    "    \"B-Condition\": 1,\n",

    "    \"I-Condition\": 2,\n",

    "    \"B-Value\": 3,\n",

    "    \"I-Value\": 4,\n",

    "    \"B-Drug\": 5,\n",

    "    \"I-Drug\": 6,\n",

    "    \"B-Procedure\": 7,\n",

    "    \"I-Procedure\": 8,\n",

    "    \"B-Measurement\": 9,\n",

    "    \"I-Measurement\": 10,\n",

    "    \"B-Temporal\": 11,\n",

    "    \"I-Temporal\": 12,\n",

    "    \"B-Observation\": 13,\n",

    "    \"I-Observation\": 14,\n",

    "    \"B-Person\": 15,\n",

    "    \"I-Person\": 16,\n",

    "    \"B-Device\": 17,\n",

    "    \"I-Device\": 18\n",

    "}\n",

    "\n",

    "entities_list = list(sel_ent.keys())\n",

    "sel_ent_inv = {v: k for k, v in sel_ent.items()}"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 47,

   "metadata": {},

   "outputs": [],

   "source": [

    "def read_file(file_path):\n",

    "    \"\"\"\n",

    "    Read the file and return a list of sentences with annotations\n",

    "    inputs: file_path: str\n",

    "    outputs: list of sentences with annotations\n",

    "    \"\"\"\n",

    "    ann_file = []\n",

    "    with open(file_path, \"r\") as fd:\n",

    "        sentences_ann = fd.read().split(\"\\n\\n\")\n",

    "    sentences_ann = [sentence for sentence in sentences_ann if sentence != \"\" and sentence != '\\n']\n",

    "\n",

    "    for i in range(len(sentences_ann)):\n",

    "        annotation = []\n",

    "        lines = sentences_ann[i].split(\"\\n\")\n",

    "        for line in lines:\n",

    "            if line != \"\":\n",

    "                spt_line = line.split()\n",

    "                label = spt_line[-1]\n",

    "                if label not in sel_ent:\n",

    "                    label = 'O'\n",

    "                annotation.append((spt_line[0], label))\n",

    "        new_annotation = []\n",

    "        ps = r'(\\.|\\,|\\:|\\;|\\!|\\?|\\-|\\(|\\)|\\[|\\]|\\{|\\}|\\\")'\n",

    "        for i,(word, tag) in enumerate(annotation):\n",

    "            if re.search(ps, word):\n",

    "                # find the ocurrences of the punctuation signs\n",

    "                occurrences = re.finditer(ps, word)\n",

    "                indexes = [(match.start(), match.end()) for match in occurrences]\n",

    "                # create the new tokens\n",

    "                last = 0\n",

    "                for j, (beg, end) in enumerate(indexes):\n",

    "                    if beg > last:\n",

    "                        new_annotation.append((word[last:beg], tag))\n",

    "                    if tag != \"O\":\n",

    "                        label = f'I-{tag.split(\"-\")[1]}'\n",

    "                    else:\n",

    "                        label = \"O\"\n",

    "                    if end < len(word) or (i < len(annotation) - 1 and annotation[i+1][1] == label):\n",

    "                        new_annotation.append((word[beg:end], label))\n",

    "                    else:\n",

    "                        new_annotation.append((word[beg:end], 'O')) \n",

    "                    last = end\n",

    "                if last < len(word):\n",

    "                    new_annotation.append((word[last:], label))\n",

    "            else:\n",

    "                new_annotation.append((word, tag))\n",

    "        ann_file.append(new_annotation)\n",

    "    return ann_file"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 48,

   "metadata": {},

   "outputs": [

    {

     "name": "stdout",

     "output_type": "stream",

     "text": [

      "Number of training files: 1800\n",

      "Total number of sentences in training files: 11102\n"

     ]

    }

   ],

   "source": [

    "# read the training files\n",

    "train_annotations = {}\n",

    "\n",

    "for file in files_train:\n",

    "    train_annotations[file] = read_file(f'{chia_bio}/trains/{file}')\n",

    "print(f'Number of training files: {len(train_annotations)}')\n",

    "print(f'Total number of sentences in training files: {sum([len(train_annotations[file]) for file in train_annotations])}')"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 49,

   "metadata": {},

   "outputs": [

    {

     "name": "stdout",

     "output_type": "stream",

     "text": [

      "Number of testing files: 200\n",

      "Total number of sentences in testing files: 1307\n"

     ]

    }

   ],

   "source": [

    "# read the testing files\n",

    "test_annotations = {}\n",

    "\n",

    "for file in files_test:\n",

    "    test_annotations[file] = read_file(f'{chia_bio}/tests/{file}')\n",

    "print(f'Number of testing files: {len(test_annotations)}')\n",

    "print(f'Total number of sentences in testing files: {sum([len(test_annotations[file]) for file in test_annotations])}')"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 50,

   "metadata": {},

   "outputs": [],

   "source": [

    "def build_df(annotations):\n",

    "    \"\"\"\n",

    "    Build a dataframe with the sentences and annotations\n",

    "    inputs: annotations: dict\n",

    "    outputs: dataframe\n",

    "    \"\"\"\n",

    "    annotations_df = []\n",

    "    for file in annotations:\n",

    "        for i in range(len(annotations[file])):\n",

    "            dict_sent = {\"tokens\": [], \"ner_tags\": [], \"file\": file, \"index\": i}\n",

    "            for word, tag in annotations[file][i]:\n",

    "                dict_sent[\"tokens\"].append(word)\n",

    "                # add the int representation of the entity\n",

    "                dict_sent[\"ner_tags\"].append(sel_ent[tag])\n",

    "            annotations_df.append(dict_sent)\n",

    "    return pd.DataFrame(annotations_df)"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 51,

   "metadata": {},

   "outputs": [],

   "source": [

    "# build the dataframes\n",

    "train_df = build_df(train_annotations)\n",

    "test_df = build_df(test_annotations)"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 54,

   "metadata": {},

   "outputs": [

    {

     "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>tokens</th>\n",

       "      <th>ner_tags</th>\n",

       "      <th>file</th>\n",

       "      <th>index</th>\n",

       "    </tr>\n",

       "  </thead>\n",

       "  <tbody>\n",

       "    <tr>\n",

       "      <th>0</th>\n",

       "      <td>[Patients, refuse, to, follow, the, research]</td>\n",

       "      <td>[0, 13, 14, 14, 14, 14]</td>\n",

       "      <td>NCT03134378_exc.bio.txt</td>\n",

       "      <td>0</td>\n",

       "    </tr>\n",

       "    <tr>\n",

       "      <th>1</th>\n",

       "      <td>[Patient, has, had, previous, eradication, the...</td>\n",

       "      <td>[0, 0, 0, 11, 7, 8, 0, 1, 2, 2, 0]</td>\n",

       "      <td>NCT03134378_exc.bio.txt</td>\n",

       "      <td>1</td>\n",

       "    </tr>\n",

       "    <tr>\n",

       "      <th>2</th>\n",

       "      <td>[The, patient, is, pregnant, or, breastfeeding]</td>\n",

       "      <td>[0, 0, 0, 1, 0, 13]</td>\n",

       "      <td>NCT03134378_exc.bio.txt</td>\n",

       "      <td>2</td>\n",

       "    </tr>\n",

       "    <tr>\n",

       "      <th>3</th>\n",

       "      <td>[Patients, have, a, history, of, allergy, to, ...</td>\n",

       "      <td>[0, 0, 0, 13, 0, 1, 0, 0, 5, 6, 6, 6, 6, 0, 5,...</td>\n",

       "      <td>NCT03134378_exc.bio.txt</td>\n",

       "      <td>3</td>\n",

       "    </tr>\n",

       "    <tr>\n",

       "      <th>4</th>\n",

       "      <td>[Patients, are, known, to, have, impaired, liv...</td>\n",

       "      <td>[0, 0, 0, 0, 0, 3, 9, 10, 0, 0, 0, 9, 10, 3, 4...</td>\n",

       "      <td>NCT03134378_exc.bio.txt</td>\n",

       "      <td>4</td>\n",

       "    </tr>\n",

       "  </tbody>\n",

       "</table>\n",

       "</div>"

      ],

      "text/plain": [

       "                                              tokens  \\\n",

       "0      [Patients, refuse, to, follow, the, research]   \n",

       "1  [Patient, has, had, previous, eradication, the...   \n",

       "2    [The, patient, is, pregnant, or, breastfeeding]   \n",

       "3  [Patients, have, a, history, of, allergy, to, ...   \n",

       "4  [Patients, are, known, to, have, impaired, liv...   \n",

       "\n",

       "                                            ner_tags                     file  \\\n",

       "0                            [0, 13, 14, 14, 14, 14]  NCT03134378_exc.bio.txt   \n",

       "1                 [0, 0, 0, 11, 7, 8, 0, 1, 2, 2, 0]  NCT03134378_exc.bio.txt   \n",

       "2                                [0, 0, 0, 1, 0, 13]  NCT03134378_exc.bio.txt   \n",

       "3  [0, 0, 0, 13, 0, 1, 0, 0, 5, 6, 6, 6, 6, 0, 5,...  NCT03134378_exc.bio.txt   \n",

       "4  [0, 0, 0, 0, 0, 3, 9, 10, 0, 0, 0, 9, 10, 3, 4...  NCT03134378_exc.bio.txt   \n",

       "\n",

       "   index  \n",

       "0      0  \n",

       "1      1  \n",

       "2      2  \n",

       "3      3  \n",

       "4      4  "

      ]

     },

     "execution_count": 54,

     "metadata": {},

     "output_type": "execute_result"

    }

   ],

   "source": [

    "train_df.head()"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 56,

   "metadata": {},

   "outputs": [],

   "source": [

    "# split the training data into training and validation\n",

    "train_df, val_df = train_test_split(train_df, test_size=0.2, random_state=42)"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 120,

   "metadata": {},

   "outputs": [

    {

     "data": {

      "text/plain": [

       "(Index(['tokens', 'ner_tags', 'file', 'index'], dtype='object'),\n",

       " Index(['tokens', 'ner_tags', 'file', 'index'], dtype='object'),\n",

       " Index(['tokens', 'ner_tags', 'file', 'index'], dtype='object'))"

      ]

     },

     "execution_count": 120,

     "metadata": {},

     "output_type": "execute_result"

    }

   ],

   "source": [

    "train_df.columns, val_df.columns, test_df.columns"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 127,

   "metadata": {},

   "outputs": [],

   "source": [

    "# create dataset instance\n",

    "train_dataset = Dataset.from_pandas(train_df)\n",

    "val_dataset = Dataset.from_pandas(val_df)\n",

    "test_dataset = Dataset.from_pandas(test_df)"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 128,

   "metadata": {},

   "outputs": [],

   "source": [

    "train_dataset = train_dataset.remove_columns(['__index_level_0__'])\n",

    "val_dataset = val_dataset.remove_columns(['__index_level_0__'])"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 129,

   "metadata": {},

   "outputs": [],

   "source": [

    "# create the dataset with all the data splited in train, validation and test\n",

    "dataset = DatasetDict({\n",

    "    'train': train_dataset,\n",

    "    'val': val_dataset,\n",

    "    'test': test_dataset\n",

    "})"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 130,

   "metadata": {},

   "outputs": [

    {

     "data": {

      "text/plain": [

       "DatasetDict({\n",

       "    train: Dataset({\n",

       "        features: ['tokens', 'ner_tags', 'file', 'index'],\n",

       "        num_rows: 8881\n",

       "    })\n",

       "    val: Dataset({\n",

       "        features: ['tokens', 'ner_tags', 'file', 'index'],\n",

       "        num_rows: 2221\n",

       "    })\n",

       "    test: Dataset({\n",

       "        features: ['tokens', 'ner_tags', 'file', 'index'],\n",

       "        num_rows: 1307\n",

       "    })\n",

       "})"

      ]

     },

     "execution_count": 130,

     "metadata": {},

     "output_type": "execute_result"

    }

   ],

   "source": [

    "dataset"

   ]

  },

  {

   "cell_type": "markdown",

   "metadata": {},

   "source": [

    "**Analysis of entities distribution on the dataset**"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 97,

   "metadata": {},

   "outputs": [],

   "source": [

    "all_entities_tr = [ent for ents in train_df.ner_tags for ent in ents]\n",

    "all_entities_val = [ent for ents in val_df.ner_tags for ent in ents]\n",

    "all_entities_test = [ent for ents in test_df.ner_tags for ent in ents]"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 98,

   "metadata": {},

   "outputs": [],

   "source": [

    "# get just the main entity (not B- or I-)\n",

    "all_entities_tr = [entities_list[ent][2:] for ent in all_entities_tr if entities_list[ent].startswith('B-')]\n",

    "all_entities_val = [entities_list[ent][2:] for ent in all_entities_val if entities_list[ent].startswith('B-')]\n",

    "all_entities_test = [entities_list[ent][2:] for ent in all_entities_test if entities_list[ent].startswith('B-')]"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 105,

   "metadata": {},

   "outputs": [

    {

     "name": "stdout",

     "output_type": "stream",

     "text": [

      "{'Condition': 8031, 'Procedure': 2285, 'Person': 1136, 'Device': 264, 'Value': 2677, 'Drug': 2479, 'Temporal': 2129, 'Measurement': 2292, 'Observation': 1171}\n",

      "train dict_values([8031, 2285, 1136, 264, 2677, 2479, 2129, 2292, 1171])\n",

      "{'Condition': 1913, 'Procedure': 602, 'Person': 257, 'Device': 59, 'Value': 628, 'Drug': 593, 'Temporal': 510, 'Measurement': 534, 'Observation': 328}\n",

      "val dict_values([1913, 602, 257, 59, 628, 593, 510, 534, 328])\n",

      "{'Condition': 1104, 'Procedure': 311, 'Person': 135, 'Device': 23, 'Value': 345, 'Drug': 443, 'Temporal': 295, 'Measurement': 288, 'Observation': 166}\n",

      "test dict_values([1104, 311, 135, 23, 345, 443, 295, 288, 166])\n"

     ]

    },

    {

     "data": {

      "image/png": "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",

      "text/plain": [

       "<Figure size 640x480 with 1 Axes>"

      ]

     },

     "metadata": {},

     "output_type": "display_data"

    }

   ],

   "source": [

    "# plot the relations\n",

    "x = np.arange(len(simple_ent))\n",

    "width = 0.25  # the width of the bars\n",

    "multiplier = 0\n",

    "\n",

    "fig, ax = plt.subplots(layout='constrained')\n",

    "\n",

    "entities_dict = {\n",

    "    'train': all_entities_tr,\n",

    "    'val': all_entities_val,\n",

    "    'test': all_entities_test\n",

    "}\n",

    "\n",

    "for l in ['train', 'val', 'test']:\n",

    "    offset = width * multiplier\n",

    "    dict_ent = {ent: entities_dict[l].count(ent) for ent in simple_ent}\n",

    "    print(dict_ent)\n",

    "    v = dict_ent.values()\n",

    "    print(l, v)\n",

    "    rects = ax.bar(x + offset, v, width, label=l)\n",

    "    multiplier += 1\n",

    "\n",

    "ax.set_ylabel('Number of examples')\n",

    "ax.set_title('Distriubtion of entities in the dataset')\n",

    "ax.set_xticks(x + width, simple_ent)\n",

    "ax.legend(loc='upper right', ncols=2)\n",

    "\n",

    "plt.xticks(rotation=90)\n",

    "plt.show()"

   ]

  },

  {

   "cell_type": "markdown",

   "metadata": {},

   "source": [

    "**Save dataset in huggingface**"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 137,

   "metadata": {},

   "outputs": [

    {

     "data": {

      "application/vnd.jupyter.widget-view+json": {

       "model_id": "ec47345b20574ccab16428fa5266a7d9",

       "version_major": 2,

       "version_minor": 0

      },

      "text/plain": [

       "VBox(children=(HTML(value='<center> <img\\nsrc=https://huggingface.co/front/assets/huggingface_logo-noborder.sv…"

      ]

     },

     "metadata": {},

     "output_type": "display_data"

    }

   ],

   "source": [

    "notebook_login()"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 138,

   "metadata": {},

   "outputs": [

    {

     "name": "stderr",

     "output_type": "stream",

     "text": [

      "Pushing split train to the Hub.\n",

      "Creating parquet from Arrow format: 100%|██████████| 9/9 [00:00<00:00, 432.05ba/s]\n",

      "Pushing dataset shards to the dataset hub: 100%|██████████| 1/1 [00:01<00:00,  1.34s/it]\n",

      "Pushing split val to the Hub.\n",

      "Creating parquet from Arrow format: 100%|██████████| 3/3 [00:00<00:00, 404.70ba/s]\n",

      "Pushing dataset shards to the dataset hub: 100%|██████████| 1/1 [00:01<00:00,  1.40s/it]\n",

      "Pushing split test to the Hub.\n",

      "Creating parquet from Arrow format: 100%|██████████| 2/2 [00:00<00:00, 347.64ba/s]\n",

      "Pushing dataset shards to the dataset hub: 100%|██████████| 1/1 [00:00<00:00,  1.13it/s]\n"

     ]

    }

   ],

   "source": [

    "dataset.push_to_hub('JavierLopetegui/chia_v1')"

   ]

  }

 ],

 "metadata": {

  "kernelspec": {

   "display_name": "TER",

   "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.10.13"

  }

 },

 "nbformat": 4,

 "nbformat_minor": 2

}