Main_Analysis.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "\n",
    "%autoreload 2\n",
    "\n",
    "from medcat.cat import CAT\n",
    "from medcat.utils.vocab import Vocab\n",
    "from medcat.cdb import CDB\n",
    "from medcat.prepare_cdb import PrepareCDB\n",
    "\n",
    "from reconcile import map_medcat_annos_to_icd9, remove_duplicate_mapped_assigned_codes\n",
    "\n",
    "from icd9cms import search\n",
    "import os\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from collections import defaultdict\n",
    "import json\n",
    "from matplotlib import pyplot as plt\n",
    "import seaborn as sns\n",
    "import scipy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "634709"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "codes.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(484744, 10)"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "joined_df_fine_tuned.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 353,
   "metadata": {},
   "outputs": [],
   "source": [
    "codes = pd.read_csv('data/admission_codes.csv')\n",
    "df = codes.groupby('icd9_code').count()\n",
    "df.reset_index(inplace=True)\n",
    "df.columns = ['cui', 'count', '_', '_']\n",
    "clean_codes = df.loc[:, ['cui', 'count']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Top 5 Occurring Codes in MIMIC-III"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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>cui</th>\n",
       "      <th>count</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1920</th>\n",
       "      <td>4019</td>\n",
       "      <td>20703</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2066</th>\n",
       "      <td>4280</td>\n",
       "      <td>13111</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2055</th>\n",
       "      <td>42731</td>\n",
       "      <td>12891</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1977</th>\n",
       "      <td>41401</td>\n",
       "      <td>12429</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2897</th>\n",
       "      <td>5849</td>\n",
       "      <td>9119</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        cui  count\n",
       "1920   4019  20703\n",
       "2066   4280  13111\n",
       "2055  42731  12891\n",
       "1977  41401  12429\n",
       "2897   5849   9119"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clean_codes.sort_values('count', ascending=False).head(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# needed columns \n",
    "# cui,str,onto,tty,tui,sty,desc,is_unique,examples\n",
    "code_meta_dir = defaultdict(list)\n",
    "for row in clean_codes.itertuples():\n",
    "    found_code = search(row.cui)\n",
    "    code_meta_dir['cui'].append(row.cui)\n",
    "    code_meta_dir['count'].append(row.count)\n",
    "    code_meta_dir['str'].append(found_code.short_desc)\n",
    "    code_meta_dir['onto'].append('icd9')\n",
    "    parent_code = found_code\n",
    "    if  found_code.code[0] != 'E' and len(found_code.code) > 3:\n",
    "        parent_code = search(found_code.code[0:3])\n",
    "    elif found_code.code[0] == 'E' and len(found_code.code) > 4:\n",
    "        parent_code = search(found_code.code[0:4])\n",
    "    code_meta_dir['tui'].append(parent_code.code)\n",
    "    code_meta_dir['sty'].append(parent_code.short_desc)\n",
    "    code_meta_dir['desc'].append(found_code.long_desc or found_code.short_desc)\n",
    "    code_meta_dir['is_unique'].append(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "cdb_df = pd.DataFrame(code_meta_dir).sort_values('count', ascending=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "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>cui</th>\n",
       "      <th>count</th>\n",
       "      <th>str</th>\n",
       "      <th>onto</th>\n",
       "      <th>tui</th>\n",
       "      <th>sty</th>\n",
       "      <th>desc</th>\n",
       "      <th>is_unique</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1920</th>\n",
       "      <td>4019</td>\n",
       "      <td>20703</td>\n",
       "      <td>Hypertension NOS</td>\n",
       "      <td>icd9</td>\n",
       "      <td>401</td>\n",
       "      <td>Essential hypertension</td>\n",
       "      <td>Unspecified essential hypertension</td>\n",
       "      <td>-1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2066</th>\n",
       "      <td>4280</td>\n",
       "      <td>13111</td>\n",
       "      <td>CHF NOS</td>\n",
       "      <td>icd9</td>\n",
       "      <td>428</td>\n",
       "      <td>Heart failure</td>\n",
       "      <td>Congestive heart failure, unspecified</td>\n",
       "      <td>-1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2055</th>\n",
       "      <td>42731</td>\n",
       "      <td>12891</td>\n",
       "      <td>Atrial fibrillation</td>\n",
       "      <td>icd9</td>\n",
       "      <td>427</td>\n",
       "      <td>Cardiac dysrhythmias</td>\n",
       "      <td>Atrial fibrillation</td>\n",
       "      <td>-1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1977</th>\n",
       "      <td>41401</td>\n",
       "      <td>12429</td>\n",
       "      <td>Crnry athrscl natve vssl</td>\n",
       "      <td>icd9</td>\n",
       "      <td>414</td>\n",
       "      <td>Other forms of chronic ischemic heart disease</td>\n",
       "      <td>Coronary atherosclerosis of native coronary ar...</td>\n",
       "      <td>-1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2897</th>\n",
       "      <td>5849</td>\n",
       "      <td>9119</td>\n",
       "      <td>Acute kidney failure NOS</td>\n",
       "      <td>icd9</td>\n",
       "      <td>584</td>\n",
       "      <td>Acute kidney failure</td>\n",
       "      <td>Acute kidney failure, unspecified</td>\n",
       "      <td>-1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>811</th>\n",
       "      <td>25000</td>\n",
       "      <td>9058</td>\n",
       "      <td>DMII wo cmp nt st uncntr</td>\n",
       "      <td>icd9</td>\n",
       "      <td>250</td>\n",
       "      <td>Diabetes mellitus</td>\n",
       "      <td>Diabetes mellitus without mention of complicat...</td>\n",
       "      <td>-1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>931</th>\n",
       "      <td>2724</td>\n",
       "      <td>8690</td>\n",
       "      <td>Hyperlipidemia NEC/NOS</td>\n",
       "      <td>icd9</td>\n",
       "      <td>272</td>\n",
       "      <td>Disorders of lipoid metabolism</td>\n",
       "      <td>Other and unspecified hyperlipidemia</td>\n",
       "      <td>-1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2484</th>\n",
       "      <td>51881</td>\n",
       "      <td>7497</td>\n",
       "      <td>Acute respiratry failure</td>\n",
       "      <td>icd9</td>\n",
       "      <td>518</td>\n",
       "      <td>Other diseases of lung</td>\n",
       "      <td>Acute respiratory failure</td>\n",
       "      <td>-1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2965</th>\n",
       "      <td>5990</td>\n",
       "      <td>6555</td>\n",
       "      <td>Urin tract infection NOS</td>\n",
       "      <td>icd9</td>\n",
       "      <td>599</td>\n",
       "      <td>Other disorders of urethra and urinary tract</td>\n",
       "      <td>Urinary tract infection, site not specified</td>\n",
       "      <td>-1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2576</th>\n",
       "      <td>53081</td>\n",
       "      <td>6326</td>\n",
       "      <td>Esophageal reflux</td>\n",
       "      <td>icd9</td>\n",
       "      <td>530</td>\n",
       "      <td>Diseases of esophagus</td>\n",
       "      <td>Esophageal reflux</td>\n",
       "      <td>-1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        cui  count                       str  onto  tui  \\\n",
       "1920   4019  20703          Hypertension NOS  icd9  401   \n",
       "2066   4280  13111                   CHF NOS  icd9  428   \n",
       "2055  42731  12891       Atrial fibrillation  icd9  427   \n",
       "1977  41401  12429  Crnry athrscl natve vssl  icd9  414   \n",
       "2897   5849   9119  Acute kidney failure NOS  icd9  584   \n",
       "811   25000   9058  DMII wo cmp nt st uncntr  icd9  250   \n",
       "931    2724   8690    Hyperlipidemia NEC/NOS  icd9  272   \n",
       "2484  51881   7497  Acute respiratry failure  icd9  518   \n",
       "2965   5990   6555  Urin tract infection NOS  icd9  599   \n",
       "2576  53081   6326         Esophageal reflux  icd9  530   \n",
       "\n",
       "                                                sty  \\\n",
       "1920                         Essential hypertension   \n",
       "2066                                  Heart failure   \n",
       "2055                           Cardiac dysrhythmias   \n",
       "1977  Other forms of chronic ischemic heart disease   \n",
       "2897                           Acute kidney failure   \n",
       "811                               Diabetes mellitus   \n",
       "931                  Disorders of lipoid metabolism   \n",
       "2484                         Other diseases of lung   \n",
       "2965   Other disorders of urethra and urinary tract   \n",
       "2576                          Diseases of esophagus   \n",
       "\n",
       "                                                   desc  is_unique  \n",
       "1920                 Unspecified essential hypertension         -1  \n",
       "2066              Congestive heart failure, unspecified         -1  \n",
       "2055                                Atrial fibrillation         -1  \n",
       "1977  Coronary atherosclerosis of native coronary ar...         -1  \n",
       "2897                  Acute kidney failure, unspecified         -1  \n",
       "811   Diabetes mellitus without mention of complicat...         -1  \n",
       "931                Other and unspecified hyperlipidemia         -1  \n",
       "2484                          Acute respiratory failure         -1  \n",
       "2965        Urinary tract infection, site not specified         -1  \n",
       "2576                                  Esophageal reflux         -1  "
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cdb_df.sort_values('count', ascending=False).head(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Link Pre-trained UMLS to ICD-9-CM\n",
    "CSV mapping file from: https://bioportal.bioontology.org/ontologies/ICD9CM/?p=summary\n",
    "\n",
    "After testing with ICD9 mapping. Many mappings appear to be missing with UMLS. Using the trained / built ICD10 to UMLS mapping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# mapping = pd.read_csv('ICD9CM.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mapping ICD9 to ICD10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "codes = pd.read_csv('data/admission_codes.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "icd9_to_10_mapping = pd.read_csv('refdata/icd9toicd10cmgem.csv')\n",
    "sorted_codes = codes.icd9_code.value_counts().reset_index().sort_values('icd9_code', ascending=False)\n",
    "sorted_codes.columns = ['code', 'count']\n",
    "count = 0\n",
    "icd10 = []\n",
    "for c in sorted_codes.code:\n",
    "    mapped_rows = icd9_to_10_mapping[icd9_to_10_mapping.icd9cm == c]   \n",
    "    icd10.append(','.join(mapped_rows.icd10cm.tolist()) if \n",
    "                 mapped_rows.shape[0] > 1 else mapped_rows.icd10cm.iloc[0])\n",
    "sorted_codes['icd10'] = icd10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "total_assigned_codes = sorted_codes['count'].sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "450732"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted_codes['count'].iloc[:300].sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Code Proportions of Total Assigned Codes\n",
    "We go with thea top 400 ICD-9 codes in the following analysis, giving  is a reasonable number for 'majority' coverage of the codes in MIMIC-III without validating all ~6k. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "code_ranges = [50, 100, 200, 300, 400, 500, 600]\n",
    "props_of_total_codes = [(r, round((sorted_codes['count'].iloc[:r].sum() / total_assigned_codes) * 100, 2)) for r in code_ranges] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(50, 38.24),\n",
       " (100, 50.11),\n",
       " (200, 63.39),\n",
       " (300, 71.01),\n",
       " (400, 76.2),\n",
       " (500, 79.96),\n",
       " (600, 82.9)]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "props_of_total_codes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Filter Down to top 400 ICD-9 Codes\n",
    "That have first been mapped to ICD-10 codes, then mapped to UMLS CUI Codes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "icd10_mapping = pd.read_csv('refdata/UMLS_to_ICD10.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "icd10_mapping = icd10_mapping.loc[:, ['Class ID', 'CUI', 'Semantic type UMLS property']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "icd10_mapping['tuis'] = icd10_mapping['Semantic type UMLS property']\\\n",
    "    .str.split('|').dropna().apply(\\\n",
    "        lambda tui_list: ','.join([l.split('/')[-1] for l in tui_list]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "icd10_mapping['code'] = icd10_mapping['Class ID'].str.split('/').apply(lambda l: l[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import chain\n",
    "icd10_codes_to_keep = list(chain.from_iterable(sorted_codes[0:400].icd10.str.split(',').tolist()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "icd10_mapping['code'] = icd10_mapping.code.str.replace('.', '')\n",
    "tuis_to_keep = chain.from_iterable([icd10_mapping[icd10_mapping.code == code].tuis.tolist() for code in icd10_codes_to_keep])\n",
    "tuis_to_keep = set(chain.from_iterable([tui.split(',') for tui in tuis_to_keep]))\n",
    "cuis_to_keep = chain.from_iterable([icd10_mapping[icd10_mapping.code == code].CUI.tolist() for code in icd10_codes_to_keep])\n",
    "cuis_to_keep = list(chain.from_iterable([cui.split('|') for cui in cuis_to_keep]))\n",
    "cuis_to_keep = list(set(cuis_to_keep))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "icd10_mapping = pd.read_csv('refdata/UMLS_to_ICD10.csv')\n",
    "icd10_mapping['icd10'] = icd10_mapping['Class ID'].str.split('/').apply(lambda l: l[-1])\n",
    "icd10_mapping['icd10'] = icd10_mapping.icd10.str.replace('.', '')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Code Reconciliation\n",
    "Given a set of predicted UMLS concepts for the DD subsections made by MedCAT, we aim to reconcile the codes assigned to the discharge diagnosis subsections in MIMIC-III."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Firstly, we map the predicted codes back into their ICD-9 counterparts. MedCAT already contains a UMLS to ICD-10-CM mapping, so we directly use that mapping supplied by the tool."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "notes = pd.read_csv('data/mimic_dd_icd9_sections.csv')\n",
    "notes['name'] = notes.name.str.split(':').apply(lambda l: l[1])\n",
    "codes = pd.read_csv('data/admission_codes.csv')\n",
    "objs = json.load(open('data/mimic_dd_annos.json'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Map parsed UMLS concepts with attached ICD-10 codes to ICD9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "parsed_dd_mapped_to_icd9 = map_medcat_annos_to_icd9(objs, notes, codes, cuis_to_keep)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reconcile Codes\n",
    "As UMLS codes can map many-to-many to ICD-10 and ICD-9 codes, a single UMLS prediction by MedCAT can map to many associated ICD codes. If the MIMIC-III assigned codes matches one of these UMLS assigned codes we assume the MIMIC-III assigned code is correct and remove all others that refer to the same span of text.\n",
    "\n",
    "Then split the reconciled codes into 3 datasets:\n",
    "- Assigned in MIMIC-III and Not Predicted by MedCAT, denoted **A_NP** in the paper.\n",
    "- Predicted by MedCAT and Assigned in MIMIC-III, denoted **P_A** in the paper. \n",
    "- Predicted by MedCAT and Not Assigned in MIMIC-III, denoted **P_NA** in the paper. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "joined_df = remove_duplicate_mapped_assigned_codes(notes, codes, parsed_dd_mapped_to_icd9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot Base Predictions by MedCAT of DD Susections\n",
    "- Predicted codes that match with Assigned codes from MIMIC-III\n",
    "- Predicted codes but have no matching assigned codes. (These are the most interesting cases, where we can begin to argue where the coding is unreliable).\n",
    "- We accept the gap between assigned codes and no predictions is large due to:\n",
    " - codes coming from outside the DD subsection\n",
    " - possibly overcoding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_y(joined_df, filter_unvalidated_codes=None):\n",
    "    matched_codes = joined_df[joined_df.match == 'match'].icd9.unique()\n",
    "    joined_df_assignedno_pred = joined_df[joined_df.match == 'assigned_no_pred']\n",
    "    joined_df_assignedno_pred = joined_df_assignedno_pred[joined_df_assignedno_pred.icd9.isin(matched_codes)].shape[0]\n",
    "    pred_no_assn = joined_df[joined_df.match == 'pred_no_assign']\n",
    "    matched = joined_df[joined_df.match == 'match']\n",
    "    \n",
    "    print(len(matched.icd9.unique()))\n",
    "    if filter_unvalidated_codes:\n",
    "        matched = matched[~matched.icd9.isin(filter_unvalidated_codes)]\n",
    "        pred_no_assn = pred_no_assn[~pred_no_assn.icd9.isin(filter_unvalidated_codes)]\n",
    "\n",
    "    y = [joined_df[joined_df.match == 'assigned_no_pred'].shape[0],  # raw code counts\n",
    "         joined_df_assignedno_pred, # raw code counts not including the codes that had at least one match in MedCAT\n",
    "         matched.shape[0], # raw code counts that match with assigned codes\n",
    "         pred_no_assn.shape[0] # raw code counts that were not assigned but were predicted.\n",
    "        ]\n",
    "    return y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MedCAT Fine-Tuning / Validation Stratified Sampling \n",
    "We sub-sample each of the three datasets by:\n",
    " - by ICD-9 Code\n",
    " - by HADMD ID\n",
    "\n",
    "The **A_NP** dataset is used for MedCAT 'fine-tuning', so the model can include additional synoyms or abbreviations for codes.\n",
    "\n",
    "**P_A** and **P_NA** are used to validate the tool ensuring the model predictions are valid."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 429,
   "metadata": {},
   "outputs": [],
   "source": [
    "random_state = 42\n",
    "def sample_dataset(dataset, sample_size, num_discard_lead_samples=0, only_sample_codes=None):\n",
    "    samples = []\n",
    "    for code, group_df in dataset.groupby('icd9'):\n",
    "        if only_sample_codes is not None and code not in only_sample_codes:\n",
    "            continue\n",
    "        sample_df = group_df.sample(min(group_df.shape[0], sample_size), random_state=random_state).loc[:, ['hadm']]\n",
    "        sample_df.iloc[num_discard_lead_samples:]\n",
    "        sample_df['icd9'] = code\n",
    "        sample_df['text'] = [notes[notes.name == str(sample.hadm)].text.iloc[0] for sample in sample_df.itertuples()]\n",
    "        samples.append(sample_df)\n",
    "    return pd.concat(samples).reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sample - Prediction and Assigned"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 430,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample_dataset(joined_df[joined_df.match == 'match'], 10).to_csv('sampled_correct_preds.csv', index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sample - Pred and Not Assigned"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample_dataset(joined_df[joined_df.match == 'pred_no_assign'], 10).to_csv('sampled_preds_no_assign.csv', index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sample - Assigned, No Pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample_dataset(joined_df[joined_df.match == 'assigned_no_pred'], 10).to_csv('sampled_assigned_no_pred.csv', index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Create Datasets to be evaluated in MedCATTrainer\n",
    "We use a running instance of the [MedCATTrainer](https://github.com/Cogstack/MedCATTrainer) interface.\n",
    "\n",
    "We use the ReST API for creating datasets / projects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests\n",
    "import json\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### First 'Login' to the API with Username and Password.\n",
    "The returned API token once logged in is used in subsequent request headers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "headers = {\n",
    "    'Authorization': f'Token {json.loads(requests.post(\"http://localhost:8001/api/api-token-auth/\", json={\"username\": \"admin\", \"password\": \"admin\"}).text)[\"token\"]}',\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create Datasets for Fine-Tuning / Validation\n",
    "Each ICD-9 Code for each of the 3 (**A_NP**, **P_A**, **P_NA**) are created."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_datasets(filename, dataset_name_prefix, dataset_desc_prefix):\n",
    "    dataset_ids = []\n",
    "    for code, group_df in list(pd.read_csv(filename).groupby('icd9')):\n",
    "        group_df.columns = ['name', 'icd9', 'text']\n",
    "        payload = {\n",
    "            'dataset_name': f'{dataset_name_prefix}{code}',\n",
    "            'dataset': group_df.loc[:, ['name', 'text']].to_dict(),\n",
    "            'description': f'{dataset_desc_prefix}{code}',\n",
    "        }\n",
    "        resp = requests.post('http://localhost:8001/api/create-dataset/', json=payload, headers=headers)\n",
    "        dataset_ids.append(json.loads(resp.text)['dataset_id'])\n",
    "    return dataset_ids"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assn_no_pred_dataset_ids = create_datasets('sampled_assigned_no_pred.csv', 'Assn No Pred ', 'Assigned with no prediction for code ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "assn_pred_dataset_ids = create_datasets('sampled_correct_preds.csv', 'Corr No Pred ', 'Assigned and predicted for code ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "preds_no_assgn_dataset_ids = create_datasets('sampled_preds_no_assign.csv', 'Preds No Assn ', 'Predicted but no assignment for code ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create Projects for Fine-Tuning / Validation\n",
    "Each ICD-9 Code for each of the 3 (**A_NP**, **P_A**, **P_NA**) are created.\n",
    "\n",
    "We create an associated .csv file for each of 3 datasets to track the manual validation / fine-tuning effort."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "icd10_mapping.icd10_code = icd10_mapping.icd10_code.str.replace('.', '')\n",
    "icd9_to_10_mapping.reset_index(inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_projects(project_prefix, filename, dataset_ids):\n",
    "    code_maps = {'icd9_code': [], 'icd9_long_title': [], 'icd10_code': [], 'umls_cuis': []}\n",
    "    for dataset_id, (code, group_df) in zip(dataset_ids, pd.read_csv(filename).groupby('icd9')):\n",
    "        icd10_mapped_codes = icd9_to_10_mapping[icd9_to_10_mapping.icd9cm == code].icd10cm.tolist()\n",
    "        cuis = list(chain.from_iterable([c.split('|') for c in icd10_mapping[icd10_mapping.icd10_code.isin(icd10_mapped_codes)].CUI.tolist()]))\n",
    "        payload = {\n",
    "            'name': f'{project_prefix} - DS: {dataset_id} code: {code} desc: {codes[codes.icd9 == code].iloc[0].short_title}',\n",
    "            'description': '',\n",
    "            'cuis': ','.join(cuis),\n",
    "            'tuis': '',\n",
    "            'require_entity_validation': True,\n",
    "            'train_model_on_submit': True,\n",
    "            'dataset': dataset_id,\n",
    "            'concept_db': 3, # UMLS Full CDB \n",
    "            'vocab': 1, # vocab full\n",
    "            'members': [1]\n",
    "        }\n",
    "        code_maps['icd9_code'].append(code)\n",
    "        code_maps['icd9_long_title'].append(search(code).long_desc)\n",
    "        code_maps['icd10_code'].append(icd10_mapped_codes)\n",
    "        code_maps['umls_cuis'].append(cuis)\n",
    "        resp = requests.post('http://localhost:8001/api/project-annotate-entities/', json=payload, headers=headers)\n",
    "        if resp.ok:\n",
    "            print(f'created project for dataset:{dataset_id}')\n",
    "        else:\n",
    "            print(f'error creating project for dataset:{dataset_id}')\n",
    "            print(resp.text)\n",
    "            raise Exception()\n",
    "    return code_maps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = list(pd.read_csv('sampled_assigned_no_pred.csv').groupby('icd9'))\n",
    "icd9_to_10_mapping[icd9_to_10_mapping.icd9cm == '00845'].icd10cm.tolist()\n",
    "df = list(pd.read_csv('sampled_correct_preds.csv').groupby('icd9'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "metadata": {},
   "outputs": [],
   "source": [
    "code_maps_asssn_no_preds = create_projects('Assn No Prd', 'sampled_assigned_no_pred.csv', assn_no_pred_dataset_ids)\n",
    "pd.DataFrame(code_maps_asssn_no_preds).to_csv('code_maps_sampled_assgned_no_pred.csv', index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "code_maps_preds_no_assign = create_projects('Prd N Asn', 'sampled_preds_no_assign.csv', preds_no_assgn_dataset_ids)\n",
    "pd.DataFrame(code_maps_preds_no_assign).to_csv('code_maps_sampeld_preds_no_assn.csv', index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [],
   "source": [
    "code_maps_correct_preds = create_projects('Cor Prd', 'sampled_correct_preds.csv', assn_pred_dataset_ids)\n",
    "pd.DataFrame(code_maps_correct_preds).to_csv('code_maps_sampled_correct_preds.csv', index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Manual validation of above samples of each Dataset\n",
    "Each csv dataset has an associated .xlsx, with further columns added for validation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Further Samples of Assigned but no prediction from MedCAT\n",
    "- During validation of the 'Assigned with no prediction of code', we annotate if more samples are required.\n",
    "- Re-sample only those with 'TRUE' in the column of more_samples_required."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 422,
   "metadata": {},
   "outputs": [],
   "source": [
    "code_maps_assn_no_preds_complete = pd.read_excel('code_maps_sampled_assgned_no_pred.xlsx')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 425,
   "metadata": {},
   "outputs": [],
   "source": [
    "icd9_codes_to_resample = code_maps_assn_no_preds_complete[code_maps_assn_no_preds_complete.more_samples_required].icd9_code.tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 433,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample_dataset(joined_df[joined_df.match == 'assigned_no_pred'], 10, 10, icd9_codes_to_resample).to_csv('sampled_assigned_no_pred_more.csv', index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Analyse Annotations\n",
    "Group annotations by top level axis and plot "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_root_axis(code): \n",
    "    par = code.parent\n",
    "    if par is not None:\n",
    "        return find_root_axis(par)\n",
    "    else:\n",
    "        return code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-108-54d51beb618b>:13: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  all_assn_no_pred['root_axis'] = all_assn_no_pred.icd9.apply(lambda code: find_root_axis(search(code))).apply(str)\n"
     ]
    }
   ],
   "source": [
    "assn_no_pred = pd.DataFrame(json.load(open('data/MedCAT_Export_With_Text_Assn_No_Pred.json'))['projects'])\n",
    "assn_no_pred = assn_no_pred.iloc[:-3]\n",
    "assn_no_pred['icd9'] = assn_no_pred.loc[:, 'name'].str.split(':').apply(lambda l: l[2].strip().split(' ')[0])\n",
    "\n",
    "assn_no_pred['root_axis'] = assn_no_pred.icd9.apply(lambda code: find_root_axis(search(code))).apply(str)\n",
    "assn_no_pred['annotations'] = assn_no_pred.loc[:, 'documents'].apply(lambda docs: [a for d in docs for a in d['annotations']])\n",
    "assn_no_pred['annos_len'] = assn_no_pred.annotations.apply(len)\n",
    "annos_by_axis = assn_no_pred.loc[:, ['root_axis', 'annos_len']].groupby('root_axis').sum()\n",
    "# clean up the axis-names\n",
    "x_axis_ticks = [s.split(':')[0] for s in annos_by_axis.index]\n",
    "\n",
    "all_assn_no_pred = joined_df[joined_df.match == 'assigned_no_pred']\n",
    "all_assn_no_pred['root_axis'] = all_assn_no_pred.icd9.apply(lambda code: find_root_axis(search(code))).apply(str)\n",
    "all_assn_no_pred = all_assn_no_pred.loc[:, ['icd9', 'root_axis']]\n",
    "all_assn_no_pred['root_axis'] = all_assn_no_pred.root_axis.str.split(':').apply(lambda l: l[0])\n",
    "all_assn_no_pred = all_assn_no_pred.groupby('root_axis').count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjgAAAGoCAYAAABL+58oAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOzdeXgVRdbA4d9JwhrwAqIQwqqgIn6KsqOiIiqiorhgENlU3EBUBhWRGa8rIiLCOAMDOhJERBQXwAUZUNxARAVkkU32IKuEfT/fH1UJNyEJCbk3CeG8z3Of9K3urj7dacyxqrpLVBVjjDHGmMIkKr8DMMYYY4wJN0twjDHGGFPoWIJjjDHGmELHEhxjjDHGFDqW4BhjjDGm0LEExxhjjDGFTkx+B2CMKaSCgYrAKOBioCTBZMmHGBS4jWDyB3l+7KNjmQRsJpjcOQ+PWR/4CahBMHllnh3XmALAEhxjTnbBwGnAOqAssB/YBtQmmLw6lzX3AioBdYEduazreMUBf+XTsY0x+cgSHGNME2AuweRdBAONgK1hSG4AagI/E0xeGoa6jk8w+c98O7YxJl9ZgmOMaQp875cvCVnOWjBwH/AYUBVYDfQnmDzCr1sJVPPLHYHEDLtmgoEzgVeBRkBpYDHwD4LJk0K2uRkIArWAPcBvQFuCyRsIBqoArwOXAsV9HEGCyWP9vmm7qFwCNxQ4F1gEPAV8ClxBMPlrgoHLga+AFsCLwP8BC4F7CSb/EhJTU6Af0ADXQjQBeIJg8na/viTwb+BWYBcwOJvXtLE/biPgIPAzcCfB5CSCgWJAf6AdEADmAL0IJn8Xsn9L4DWgOq5ramgGxzhW7M2Al4HzgEO438ldBJPnZ+scjCkgbJCxMSejYKAqwcA2goFtQE/gPr/8InCTX/fvLPZvg0ssXsP9IRwM/Jtg4Aa/RQPgf8A4XDfRw5nUVAr4HLgKuAAYD3xIMHCOP05FYCyQCNQGmgFvh+z/b6AkcAVQB3gE18WWUcylgEnA70A94HFgQCZx9QN6AxcBW4B3CAbE1/N/wJe4xOAC4GZcN9x/Q/Z/xZ/TLcCVwIU+9swFAxfgkqtluHFLjYH3OPI/oi8DtwN3+fp+A74gGIjz+1cBPgam+Hj+6fcJPUbWsQcDMcAnwHd+fSPc7/hQlrEbUwBZC44xJ6ck3B+2U4DZuD9ku3CtAtfhWkJ2ZrF/L+Btgsmv++9LCAbqAU8AEwkmbyIY2AfsybKbKJg8F5gbUvKCT5JuBZ7HjeEpAnxAMHmV3ya0JaEaMN7XA7Aii5jbA9HA3QST9wALCAZeAN7JYNu/E0z+ysUYeBb3Bz8eWItrtXqPYPLAI+cReAD4lWDgdGA3cDeu1WOyX9/F75uVx4E5BJPvDSlb5PePBR4A7iGY/Kkvux9oDnQD+vr1q4EeBJMV+J1g4CzguZD6jhX7QaAM7ne43G/x+zHiNqZAsgTHmJNRMPkgsJJgoC3wE8HkeQQDFwMbCCZ/k40aapO2xQJcEtA6Z3EEYoGngetxLT1FcF1N8/wWc3EtQfMJBr70yx8QTN7k1w8GhvmumanARwSTf87kaOe4epL3hJT9mMm280KWk/zP03FJSj2gJsHA7SHbpDwhdiYuwSkKzDhynsk7CQZ+y+RYKS4EPspk3Zm4a3Ok+zCYfIhgYAauuw3c72SmT25SzCCtrGMPJs8gGBgJTCYYmIq7ph+EaUyWMXnKuqiMORkFAwsIBnbiunsa+uWpQHWCgZ0EAwuOs2Y99iZpvALcBvwduAzXqjQLlyC4P+Jwtf/Mw7WMLPXdORBMfhOoAbwFnAX8QDAQPM7YQx0IWU45p6iQn2/4WFM+F+DGCM0Jw7FzKifX/NixB5O74Fr0vsElrIsJBq4JY7zG5AlrwTHm5NQK1yIwFdc18jNurMtI4AvS/oHPyCLcOJE3Q8ouwQ3IzYlLgFEEk8cDEAwUx7VWLEndwrVIzABm+O6iBbixKHP9+rXAcGA4wcATuPE+wQyO9TvQiWCgREgrTsMcxgvwC1CHYPKyDNcGA8tx168x8Icvi8WNVVqe4T7Or7gup4wsxz3Cf3FqHcFANO4JuDF+m0XALQQDEtKK0zhHsaeeQ2rXYX+Cgc+BTsDkLPcxpoCxBMeYk1EweZUfwFsBN6hUcYN0xxNMXp+NGgYA7xMM/IwbtNoSN8bl5hxGsgRoQzDwCS4peBrXReXjDDTGPdE0GdiA68apQkoiFQwMxg1SXoIbT9SSzJOsMbhxPSMIBl7Eje/p49flpBWkPzCTYGAY8B/cO37OAW4gmHyf7456E5ccbMJ1cf0DN/4nKwN8vcOBfwF7cU+HfUkweTXBwFBf52bcWKNHcb+/lMHgw4C/Aa/5AeL/B9yfs9gDNYD7cIOQ1wFnAOeT0dNYxhRw1kVlzMnrctz4m724loy12UxuIJj8MfAQ7o/sQlyryYMEkyfmMIaewEbgW1yiMtMvp0jGtVpMApYCA4HnCCaP9uujcE8LLcQ9PbQB19qQUcw7gBtwidyvuIQi6NfuzXbEweR5uCeiqgPTcS0d/fyxU/TCPRH1kf85H9flk1W9c3DJ3Dm46/AjkMCR1rQncE9VvYXrTjofaJn6O3PjZG7GJXlzcb+b3jmMfTeuq+99XNKYiBuE3T/L2I0pgEQ1p13mxhhTSAQDN+KSkNMJJm/O73CMMeFjXVTGmJNHMNAJNy5mDW5MzGu4R6ItuTGmkLEExxhzMqkAPIN7JP1P3FuMn8jXiIwxEWFdVMYYY4wpdGyQcYSISEsRWSwiy0Sk97H3OHmJSBUR+UpEForIAhF52JeXE5EpIrLU/yzry0VEhvhrO09ELgqpq5PffqmIdAopryciv/l9hoiIHB1J4Sci0SLyq4hM8t9riMiP/rq8JyJFfXkx/32ZX189pI4nffliEbkmpNzueUBEyojIByLyu4gsEpEmdi+Hl4g86v9bMV9E3hWR4nYv546I/FdENorI/JCyiN+3mR0jLFTVPmH+4B4HXY57xLIo7kmFc/M7roL6wXUXXOSXS+Oe3jgXN49Ob1/eG+jvl1vhnrgR3Hs+fvTl5XDjK8oBZf1yWb9ult9W/L7X5vd559O17ol7XHqS/z4OSPDLw4AH/PKDwDC/nAC855fP9fdzMdwL9pb7+93u+SPXOBG4xy8XxU19YPdy+K5vPO4x+RL++zigs93Lub6uzXBzr80PKYv4fZvZMcLxsRacyGgILFPVP1R1P+4Fajfmc0wFlqquV9Vf/PIO3AvL4nHXLNFvlgjc5JdvBEapMxMoIyJxwDXAFFXdqqp/4R4bbunXnaKqM9X9KxoVUtdJQ0Qq4+aZesN/F9yL5T7wm6S/xinX/gPgSr/9jcBYVd2nqitwE0M2xO55AEQkgPtD8SaAqu5X1W3YvRxuMUAJEYnBTba6HruXc0VVvwG2pivOi/s2s2PkmiU4kRGPe0ojxVpfZo7BNx9fiHsHSAVVTXkvy5+4AaKQ+fXNqnxtBuUnm9dwby0+7L+fCmxT1YP+e+h1Sb2Wfn2y3z6n1/5kUwPYBLzluwLfEJFY7F4OG1Vdh5viYzUusUnGvYnb7uXwy4v7NrNj5JolOKbAEJFSwHjgEVXdHrrOZ/02Iv44icj1wEZVzWwiShMeMbhm/qGqeiFuhvY0YzjsXs4dP0bjRlwyWQmIxb3c0ERQXty34T6GJTiRsQ73OvkUlX2ZyYSIFMElN++o6oe+eINv2sT/3OjLM7u+WZVXzqD8ZHIx0FpEVuKa3JvjZuIu45v5Ie11Sb2Wfn0A2ELOr/3JZi2wVlVTZin/AJfw2L0cPi2AFaq6SVUPAB/i7m+7l8MvL+7bzI6Ra5bgRMZPQC0/qr8obmDbhHyOqcDy/eFvAotU9dWQVRM48tr9Trg5k1LKO/qR/I2BZN/EORm4WkTK+v/LuxqY7NdtF5HG/lgdQ+o6Kajqk6paWVWr4+7HaaraHjeNwK1+s/TXOOXa3+q3V1+e4J9MqYGbhXoWds8DoKp/AmtE5GxfdCVuGgm7l8NnNdBYREr6a5Byje1eDr+8uG8zO0buhWu0sn2OGpHeCvc00HLgqfyOpyB/cDNKKzAPN8fOHH/9TsXNdr0U+B9Qzm8vuMkIlwO/AfVD6roLN1hwGdAlpLw+bj6g5cDr+HdAnYwf3BxUKU9RnYH7j/oy3PxDxXx5cf99mV9/Rsj+T/nruJiQJ3jsnk+9DnWB2f5+/hj3NIndy+G9xs/gZoefD7yNexLK7uXcXdN3cWOaDuBaIu/Oi/s2s2OE42Mv+jPGGGNMoWNdVMYYY4wpdCzBMcYYY0yhYwmOMcYYYwodS3CMMcYYU+hYghNBInJvfsdQ2Nk1zht2nSPPrnHk2TWOvIJ0jS3BiawC84suxOwa5w27zpFn1zjy7BpHXoG5xpbgGGOMMabQsffgRJCIaMmSJfM7jELt4MGDxMTEHHtDkyt2nSPPrnHk2TWOvPy4xrt371ZVParBxn7TEVSyZEl27dqV32EYY4wxhZaI7Mmo3LqojDHGGFPoWIJjjDHGmELHEhxjjDHGFDqW4BhjjDGm0LFBxsYYcwLYvn07Gzdu5MCBA/kdijF5qkiRIpx++umccsopOdrPEhxjjCngtm/fzoYNG4iPj6dEiRKISH6HZEyeUFX27NnDunXrAHKU5FgXlTHGFHAbN24kPj6ekiVLWnJjTioiQsmSJYmPj2fjxo052tcSHGOMKeAOHDhAiRIl8jsMY/JNiRIlctw9awmOMcacAKzlxpzMjuf+twTHGGOMMYWOJTjGGGNOWqtXr6ZUqVIcOnQov0PJNhFh2bJlAHTu3Jm+ffvmc0RpYyoo7CkqY4w5AVXv/WlE61/50nU53ufyyy9n7ty5/PnnnxQrViwCUaW1cuVKatSowYEDB7I9wWP16tV54403aNGiBQBVq1Zl586dkQwzQ7NmzSIYDPLDDz8QFRVFzZo1eeCBB+jSpUuexzJy5EjeeOMNvvvuuzw/diRZC44xxphcW7lyJd9++y0iwoQJE/I7nAJtxowZNG/enMsuu4xly5axZcsWhg4dyueff57foRUqluAYY4zJtVGjRtG4cWM6d+5MYmJimnWdO3emW7duXHfddZQuXZpGjRqxfPny1PUiwrBhw6hVqxZlypShW7duqCoAhw8f5vnnn6datWqcfvrpdOzYkeTkZACaNWsGQJkyZShVqhQzZsxg+fLlNG/enFNPPZXy5cvTvn17tm3bBkCHDh1YvXo1N9xwA6VKleLll19m5cqViAgHDx4EICkpidatW1OuXDlq1qzJiBEjUuMMBoO0bduWjh07Urp0aerUqcPs2bNT1/fv35/4+HhKly7N2WefzdSpUzO8Vo899hidOnXiiSeeoHz58ogI9erVY9y4canbjBgxgpo1a1KuXDlat25NUlJStn4PkyZNom7dupQpU4amTZsyb9681HVr1qzh5ptv5rTTTuPUU0+le/fuLFq0iPvvv58ZM2ZQqlQpypQpA8C+ffvo1asXVatWpUKFCtx///3s2XNk0u4BAwYQFxdHpUqV+O9//5ut2PKadVFFUO3AXggG8jsMYwq+YHJ+R2ByadSoUfTs2ZNGjRrRuHFjNmzYQIUKFVLXjx07ls8//5yLLrqITp068dRTTzF27NjU9ZMmTeKnn35i+/bt1KtXjxtuuIGWLVsycuRIRo4cyVdffZWa4HTv3p23336bb775hho1arBt27bULqply5bx5JNP0qxZM7Zv384tt9xCMBjktdde4+233+bbb79N00W1cuXKNOeRkJDAeeedR1JSEr///jtXXXUVZ555Js2bNwdgwoQJfPjhh7z11lv07duX7t27M3PmTBYvXszrr7/OTz/9RKVKlVi5cmWG43p2797NjBkzeO655zK9ltOmTePJJ5/kyy+/pE6dOvTq1YuEhAS++eabLH8Hv/76K3fddRcTJ06kfv36jB49mtatW7N48WJiYmK4/vrrad68OW+//TbR0dHMnj2b2rVrM2zYsKO6qHr37s3y5cuZM2cORYoU4Y477uDZZ5+lX79+fPHFF7zyyitMnTqVGjVq0LVr1yzjyi/WgmOMMSZXvvvuO1atWkXbtm2pV68eZ555JmPGjEmzTZs2bWjYsCExMTG0b9+eOXPmpFnfu3dvypQpQ9WqVbniiitS17/zzjv07NmTM844g1KlStGvXz/Gjh2b2uKSXs2aNbnqqqsoVqwYp512Gj179mT69OnZOo81a9bw/fff079/f4oXL07dunW55557GDVqVOo2l1xyCa1atSI6OpoOHTowd+5cAKKjo9m3bx8LFy7kwIEDVK9enTPPPPOoY/z1118cPnyYuLi4TON45513uOuuu7jooosoVqwY/fr1Y8aMGUclY+kNHz6c++67j0aNGhEdHU2nTp0oVqwYM2fOZNasWSQlJTFgwABiY2MpXrw4l1xySYb1qCrDhw9n0KBBlCtXjtKlS9OnT5/UhHTcuHF06dKF8847j9jYWILB4DGubP6wBMcYY0yuJCYmcvXVV1O+fHkA7rjjjqO6qSpWrJi6XLJkyaMG9ma2PikpiWrVqqWuq1atGgcPHmTDhg0ZxrJhwwYSEhKIj4/nlFNO4c4772Tz5s3ZOo+kpKTUP+ihx0uZJiCjOPfu3cvBgwepWbMmr732GsFgkNNPP52EhIQMu5XKli1LVFQU69evzzKO0HMuVaoUp556apo4MrJq1SoGDhxImTJlUj9r1qwhKSmJNWvWUK1atWwNxt60aRO7d++mXr16qfW0bNmSTZs2pcZXpUqVNNeoICqwCY6IfCUi16Qre0REhopIJxFZ6j+dQta/ICJrRCTTIfEi8paI3Jeu7CYR+dwvPywi80VkgYg8ErLNbb7ssIjUD9+ZGmPMiWvPnj2MGzeO6dOnU7FiRSpWrMigQYOYO3duautGblSqVIlVq1alfl+9ejUxMTFUqFAhw5e/9enTBxHht99+Y/v27YwePTp1PA9k/cK4SpUqsXXrVnbs2JHmePHx8dmK9Y477khtzRIRnnjiiaO2KVmyJE2aNGH8+PFZxhF6zrt27WLLli3HjKNKlSo89dRTbNu2LfWze/du2rVrR5UqVVi9enWGLV/pr0n58uUpUaIECxYsSK0nOTk5NemMi4tjzZo1qduvXr06y7jyS4FNcIB3gYR0ZQm+/GmgEdAQeFpEyvr1E33ZcdUrIucBXX0dFwDXi0hNv8184GYg605QY4w5iXz88cdER0ezcOFC5syZw5w5c1i0aBGXXnppmq6d49WuXTsGDRrEihUr2LlzJ3369OH2228nJiaG0047jaioKP7444/U7Xfs2EGpUqUIBAKsW7eOAQMGpKmvQoUKabYPVaVKFZo2bcqTTz7J3r17mTdvHm+++SZ33nnnMeNcvHgx06ZNY9++fRQvXpwSJUoQFZXxn9iXX36ZkSNHMmDAALZs2QLA3LlzSUhISD3nt956izlz5rBv3z769OlDo0aNqF69epYxdO3alWHDhvHjjz+iquzatYtPP/2UHTt20LBhQ+Li4ujduze7du1i7969fP/996nXZO3atezfvx+AqKgounbtyqOPPpo6/9O6deuYPHkyAG3btmXkyJEsXLiQ3bt388wzzxzz+uSHgjzI+APgeREpqqr7RaQ6UAmIB6ao6lYAEZkCtATeVdWZviyreqcCiSISp6rrRSQWaAHcC1wD/Kiqu30903FJzcuquigbdRtjTJ44nvfUREJiYiJdunShatWqacq7d+9Ojx496N+/f67qv+uuu0hKSqJZs2bs3buXa665hn/+85+Aaw156qmnuPjiizlw4ABffPEFTz/9NB07diQQCFCzZk06dOjAoEGDUut78skneeihh3j88cfp27cvt956a5rjvfvuu9x///1UqlSJsmXL8swzz6QOSM7Kvn376N27N4sWLaJIkSI0bdqU4cOHZ7ht06ZNmTZtGk8//TTPP/880dHR1KpVi27dugHQokULnnvuOW655Rb++usvmjZtmmZAdmbq16/PiBEj6N69O0uXLqVEiRJccsklNGvWjOjoaCZOnEiPHj2oWrUqIsIdd9zBxRdfTPPmzalTpw4VK1YkKiqKzZs3079/f5599lkaN27M5s2biY+P54EHHuCaa67h2muv5ZFHHqF58+ZERUXx/PPP88477xwzvrwmoU13BY2ITAJGqOonItIbKA/8CRRX1ef9Nn8H9qjqKyH77VTVUlnU+zqwVFUHi0gCcKuq3ioitYFPgCbAHlwyNFtVHwrZ92ugl6rOzqBqROReXLIEUTH1qj328fFfAGMKsILyB/ZksGjRImrXrp3fYRiTrzL7dyAiu1U1Nn15Qe6igrTdSSndUxGr17fS9Ae+BL4A5gA5en+3qg5X1fqqWl+iosMUrjHGGGNyoqAnOJ8AV4rIRUBJVf0ZWAdUCdmmsi/LkIhEi8gc/3nWF/8AxInIBUBTIPWd56r6pqrWU9VmwF/AkvCekjHGGGMirSCPwUFVd4rIV8B/OdJ6Mxl4MWRg8dXAk1nUcQiom65MReQ9IBH4XFX3pqwTkdNVdaOIVMWNv2kcthMyxhhjTJ4o6C044BKbCzjSjbQVeA74yX+eDRlw/LKIrAVKishaEQlmt94Q40VkIe6JrG6qus3X3cbX3QT4VEQmh+sEjTHGGBNeBboFB0BVPwYkXdl/ca066bd9HHg8m/XOSV+vL780k+0/Aj7KTt3GGGOMyV8FPsE5kZUoGm1PmhhjjDH54EToojLGGGOMyRFLcIwxxhhT6FiCY4wxpsCpU6cOX3/9dZ4ft3PnzvTt2zdPjhUMBrM1DYQ5PpbgGGPMiSgYiOznOFx++eWULVuWffv25fr0FixYwOWXX57resJt/fr13H333cTFxVG6dGnOOeccnn76aXbt2pXfoQEuaRIRBg8enKZ88ODBiAjBYBCAr7/+msqVK6euv/zyyxGRoyZIbdOmDSKSmmymT8pUlSFDhnDeeecRGxtL5cqVue222/jtt98yjC+j477xxhsZrsstS3CMMcbk2sqVK/n2228RESZMmJDf4UTE1q1badKkCXv27GHGjBns2LGDKVOmsG3bNpYvX57f4aU666yzjproNDExkbPOOitH+23ZsoUZM2Zw2mmnZbrPww8/zODBgxkyZAhbt25lyZIl3HTTTXz66aeZ7pNX7CmqCKod2Hvc/ydUIAWT8zsCY0wBNWrUKBo3bkyjRo1ITEzktttuS1332Wef0atXL9asWcMpp5zCo48+Sq9evdi8eTOdO3fmu+++Iyoqijp16jB9+nSioqKoXr06b7zxBi1atGDPnj3cf//9TJgwgYoVK9KlSxeGDBnC2rVrAahevTrdu3dn1KhRrFq1ipYtW5KYmEjx4sUBmDRpEn379mXlypWce+65DBs2jPPPPx+AX3/9lbvvvpulS5fSqlWrLCdUfvXVVyldujSjR49OnSm8SpUqaVpLfvjhBx5++GGWLFnCWWedxeDBg2natCkAK1asoHPnzvzyyy80btyYs88+O039M2fOpGfPnixcuJBq1aoxePDg1FaskSNH8uyzz7Jp0ybKly/P888/T/v27TOMs0GDBvz8888sWLCAOnXqsGDBAvbu3UuDBg2y/B22b9+e4cOH8/LLLxMdHc27775LmzZtmDhxYobbL126lH/961/MmDGDhg0bpqmnILAWHGOMMbk2atQo2rdvT/v27Zk8eTIbNmxIXXf33Xfzn//8hx07djB//nyaN28OwMCBA6lcuTKbNm1iw4YNvPjiixkmGM888wwrV67kjz/+YMqUKYwePfqobcaNG8cXX3zBihUrmDdvHiNHjgRcAnPXXXfxn//8hy1btnDffffRunVr9u3bx/79+7npppvo0KEDW7du5bbbbmP8+PGZnuP//vc/br755tTkJr2tW7dy3XXX0aNHD7Zs2ULPnj257rrr2LJlCwB33HEH9erVY/Pmzfz9738nMTExdd9169Zx3XXX0bdvX7Zu3corr7zCLbfcwqZNm9i1axc9evTg888/Z8eOHfzwww/UrVs3wxhSdOjQIbU1JjExkQ4dOmS5PUClSpU499xz+fLLLwH3O+3YsWOm20+dOpXKlSunSW4KkjxNcETkUMi8UHP8DOGISA0R+VFElonIeyJS1JcX89+X+fXVQ+p60pcvFpFrMjleZxHZlO6Y5/p1/UVkvv/cHrJPcxH5xZcnikiMLy8rIh+JyDwRmSUi50XuShljzInju+++Y9WqVbRt25Z69epx5plnMmbMmNT1RYoUYeHChWzfvp2yZcty0UUXpZavX7+eVatWUaRIES699NIME5xx48bRp08fypYtS+XKlenRo8dR2/To0YNKlSpRrlw5brjhBubMmQPA8OHDue+++2jUqBHR0dF06tSJYsWKMXPmTGbOnMmBAwd45JFHKFKkCLfeemuWrRxbtmwhLi4u0/WffvoptWrVokOHDsTExNCuXTvOOeccJk6cyOrVq/npp5947rnnKFasGM2aNeOGG25I3Xf06NG0atWKVq1aERUVxVVXXUX9+vX57LPPAIiKimL+/Pns2bOHuLg46tSpk+Xv5M477+Tdd9/lwIEDjB07NtuDmTt27MioUaP4/fff2bZtG02aNDnu65Hf8roFZ4+q1g35vOTL+wODVLUmboLLu3353cBfvnyQ3w6fpCQAdYCWwL9FJLOpu99Ld8yFInIdcBFujqpGQC8ROUVEonDzUyWo6nnAKqCTr6cPMEdVzwc6AoOPPpQxxpx8EhMTufrqqylfvjzgWipCWyfGjx/PZ599RrVq1bjsssuYMWMGAI899hg1a9bk6quv5owzzuCll17KsP6kpCSqVDkyx3LocoqKFSumLpcsWZKdO3cCsGrVKgYOHEiZMmVSP2vWrCEpKYmkpCTi4+PTJFXVqlXL9DxPPfVU1q9fn+n6pKSko/avVq0a69atIykpibJlyxIbG5vhsVatWsX777+fJs7vvvuO9evXExsby3vvvcewYcOIi4vjuuuu4/fff880DoCqVatSs2ZN+vTpQ61atTK8Zhm5+eabmTZtGq+//voxW32OdT1Wr15Nqb018NEAACAASURBVFKlUj95Ld+7qMTdWc2BD3xRInCTX77Rf8evv9JvfyMwVlX3qeoKYBmQkzayc4FvVPWgqu4C5uESpVOB/aqaMoP4FOCWkH2mAajq70B1EamQo5M1xphCZs+ePYwbN47p06dTsWJFKlasyKBBg5g7d27qEzkNGjTgk08+YePGjdx00020bdsWgNKlSzNw4ED++OMPJkyYwKuvvsrUqVOPOkZcXFzqeBuANWvWZDu+KlWq8NRTT7Ft27bUz+7du2nXrh1xcXGsW7cOVU3dfvXq1ZnW1aJFCz766CMOHz6c4fpKlSqxatWqNGWrV68mPj6euLg4/vrrrzRPW4Ueq0qVKnTo0CFNnLt27aJ3794AXHPNNUyZMoX169dzzjnn0LVr12Oee8eOHRk4cGCW3UzplSxZkmuvvZahQ4ceM8G58sorWbt2LbNnz85wfdWqVdm5c2fqJ6/l9SDjEiIyJ+R7P2AqsE1VD/qytUC8X44H1gCo6kERScYlIfHAzJB6QvdJ73YRuSTkexNgLvC0iAwESgJXAAuBzUCMiNRX1dnArUBK2jsXN7v4tyLSEKgGVAY2hNSNiNwL3AtAVAzV946h0Oj9qU09YYxJ4+OPPyY6OprffvuNokWLppa3bduWUaNG0a9fP95//32uv/56AoEAp5xySuoYlkmTJnHOOedw5plnEggEiI6OznB8S9u2benXrx8NGjRg9+7dvP7669mOr2vXrrRp04YWLVrQsGFDdu/ezddff02zZs1o0qQJMTExDBkyhAcffJCJEycya9Ysrrjiigzr6tmzJ6NHj6ZTp048//zzqa0zAwcOpHPnzrRq1YqHHnqIMWPG0LZtW8aPH8/ChQu5/vrrKV++PPXr1+fpp5/mxRdfZNasWUycOJHWrVsDrkupQYMGTJ48mRYtWnDgwAFmzpxJzZo1KVKkCDNnzqRFixaUKFGCUqVKZToOKNTtt99O5cqVufjii7N9vQBefPFF7rnnHqpXr57ldrVq1eLBBx+kXbt2jBgxgqZNm3L48GE+/vhjVq5cmZqc5Ze8TnD2qGqakVEiUj7Cx3xPVbunK/tSRBoAPwCbgBnAIVVVEUkABolIMeBL4JDf5yVgsE/QfgN+DVmXSlWHA8MBoooU1/TrjTEmLArIU42JiYl06dKFqlWrpinv3r07PXr0oF+/frz99tt0796dQ4cOcfbZZ/POO+8A7imc7t27s2nTJsqWLcuDDz6YYXLxj3/8g/vvv58aNWoQFxdH+/bteeutt7IVX/369RkxYgTdu3dn6dKllChRgksuuYRmzZpRtGhRPvzwQ7p27Urfvn1p1aoVN998c6Z1lStXjh9++IG+ffvSqFEjdu3aRXx8PO3ataNmzZqULFmSSZMm8fDDD/PAAw9Qs2ZNJk2alNp1N2bMGDp16kS5cuVo0qQJHTt2ZNu2bYBrwfnkk094/PHHadeuHdHR0TRs2JChQ4dy+PBhXn31VTp27IiIULduXYYOHXrMcy9RogQtWrTI1nUKValSJSpVqpStbYcMGcKQIUPo1q0bK1asoGzZslxyySX84x//yPFxw01Cm+YifjCRnapaKl2Z4JKMir6VpgkQVNVrRGSyX57hB/v+CZwG9AZQ1X6+jslAEDeuJqXdrhVwNVA/gwQnfVxjgNGq+lm68quBe1S1bQYxrwDOV9XtmdUbVaS4Vv1b5iPyT0TWgmNM3lu0aBG1a9fO7zAKjKFDhzJ27FimT5+e36GYPJTZvwMR2a2qsenL830MjroM6ytcdxC4Qb2f+OUJHBnkeyswzW8/AUjwT1nVAGoBs1T1XyGDiZMyO6aIRIvIqX75fOB8XGsNInK6/1kMeAIY5r+XSXm6C7gHN4Yn0+TGGGNMeKxfv57vv/+ew4cPs3jxYgYOHEibNm3yOyxTwOX3GJwvVLU3LpEYKyLP47p+3vTr3wTeFpFlwFbck1Oo6gIRGYcbN3MQ6KaqR3UXeenH4DwI/IIbSwOwHbgzZAzQYyJyPS75G6qq03x5bSBRRBRYwJEnvYwxxkTQ/v37ue+++1ixYgVlypQhISGBBx98ML/DMgVcnnZRnWysi8oYEw7WRWVMzruobKqGCCpRNNoSAmOMMSYf5PsYHGOMMceW2btXjDkZHM/9bwmOMcYUcLGxsaxbt479+/djwwrMyURV2b9/P+vWrUvzFujssDE4ERQbG6uhb600xpjjcfjwYTZv3kxycjIHDx489g7GFCIxMTEEAgHKly+f4QsOMxuDYwlOBFmCY4wxxkRWgX0PjjHGGGNMuNlTVBFUO7AXgoH8DuPEUkBeP2+MMebEZi04xhhjjCl0LMExxhhjTKFT4BMcEXlURBaIyHwReVdEiotIDRH5UUSWich7KXNE+bmp3vPlP4pI9UzqvEBEZojIbyIyUURO8eVFReQtXz5XRC4P2ed2EZnnY+mfB6dujDHGmONUoBMcEYkHeuBmBD8PiMbNR9UfGKSqNYG/ODIv1N3AX758kN8uI28AvVX1/4CPgMd8eVcAX34VMFBEovzEnAOAK1W1DlBRRK4M79kaY4wxJlwKdILjxeAm6YwBSgLrgebAB359InCTX77Rf8evv1L8jJrpnAV845enALf45XOBaQCquhHYBtQHzgCWquomv93/QvYxxhhjTAFToJ+iUtV1IvIKsBrYA3wJ/AxsC5n9ey0Q75fjgTV+34MikgycCmxOV/UCXDL0MXAbUMWXzwVai8i7vqye/zkNONt3ea3FJVRFM4pZRO4F7gUgKobqe8cc38mfrHp/mt8RFFo2L5ox5mRSoFtwRKQsLhGpAVQCYoGWYaj6LuBBEfkZKA3s9+X/xSUws4HXgB+AQ6r6F/AA8B7wLbASOJRRxao6XFXrq2p9iYoOQ6jGGGOMyakC3YIDtABWpHQNiciHwMVAGRGJ8a04lYF1fvt1uBaXtb5LKwBsEZG3gAuBJFVtpaq/A1f7Os8CrgPX6gM8mnJwEfkBWOLXTQQm+vJ7ySTBMcYYY0z+K9AtOLiuqcYiUtKPpbkSWAh8Bdzqt+kEfOKXJ/jv+PXT1OmiqnVVtRWAiJzuf0YBfYFh/ntJEYn1y1cBB1V1Ybp9ygIP4gYqG2OMMaYAKtAtOKr6o4h8APwCHAR+BYYDnwJjReR5X/am3+VN4G0RWQZsxT1xlZF2ItLNL38IvOWXTwcmi8hhXGtQh5B9BovIBX75WVVdkusTNMYYY0xE2GSbERRVpLhW/dv4/A7DGMAGGRtjCiebTTwf2GzixhhjTGTZbOLGGGOMOWlYgmOMMcaYQscSHGOMMcYUOpbgGGOMMabQyVaCIyIBEamQrqyTiAzw74sxxhhjjCkwsvUUlYh8DGxQ1fv8997Ai8BuoDjQVlU/jGSgJ6L6laJ19r2l8juMgiuYnN8RGGOMOcHl9imqBrhZt1N0AwaoaincG3175T5EY4wxxpjwyG6CcyrwJ4CInIub+DLl7b/vA7XDHxqIyNkiMifks11EHhGRuiIy05fNFpGGfnsRkSEiskxE5onIRZnUOyikziUisi1kXX8Rme8/t4eUNxeRX3x5op/ryhhjjDEFUHb/SG/FJTUAVwB/+gkrAaL9J+xUdTFQF0BEonHTJ3wEjACeUdXPRaQV8DJwOXAtUMt/GgFD/c/09YZOqPkQbiJOROQ64CJ/zGLA1yLyObATSASuVNUlIvIsbs6rN9PXbYwxxpj8l90WnK+Af4jIPcDfODK5JcDZuEkxI+1KYLmqrgIUOMWXB4Akv3wjMMpPsDkTN+t43DHqbQe865fPBb5R1YOquguYB7TEtWDtD5l/agpwSzhOyhhjjDHhl90E5zHgL+BfuK6qYMi6O4DvwxtWhhI4kog8AgwQkTXAK8CTvjweWBOyz1pfliERqQbUAKb5orlASz+reHlca1UVYDMQIyL1/Xa3+nJjjDHGFEDZ6qJS1STg0kxW34jrwokYESkKtOZIIvMA8KiqjheRtriuohbHUXUC8IGqHgJQ1S9FpAHwA7AJmAEcUlUVkQRgkIgUA74EDmUS673AvQBExVB975jjCCt/2GSMxhhjCotcv+hPVTeq6u5wBJOFa4FfVHWD/94JSHks/X2goV9eR9qWlcrAOhF5IWVQcbp6Q1uFAFDVF1S1rqpeBQiwxJfPUNVLVbUh8E1KeXqqOlxV66tqfYmKyNAkY4wxxhxDpi04IvJvoL+qrvLLWVFV7Rbe0NIIHScDbszNZcDXQHNgqS+fAHQXkbG4wcXJqroeeMp/UonIOUBZXCtNSlk0UEZVt4jI+cD5uNYaROR0Vd3oW3CeAF4I90kaY4wxJjyy6qJqAwwHVgE34wb2ZkZx78YJOxGJBa4C7gsp7goM9o9q7yWlSwg+A1oBy3AvIeySRdUJwFhN+6bDIsC3IgKwHbhTVQ/6dY+JyPW4Vq+hqjoNY4wxxhRI2XqTsTk+UUWKa9W/jc/vMLLNxuAYY4w50eT2TcbGGGOMMSeM7M5F9QzuxXqHM1hXFhihqrdGIL4TWmxsrO7atSu/wzDGGGMKrdy24DwBTBeRNO9+EZHLcC/Dy+wRcmOMMcaYPJfdBOdioAIwV0TaikiUiLwITAUWARdEKkBjjDHGmJzK9iBj/zTTUKA97g3BFYC/q+qAyIV3YrMuKmOMMSaycj3I2M/N9BmwH/cyvUWke0meMcYYY0xBkK2pGkSkJPA67g3CicAo3Izec0XkHlX9KHIhnrhqB/ZCMJDfYeROMDm/IzDGGGNyLLstOHNwL/trr6p3qerXwIW4Fp0PROQ/EYrPGGOMMSbHspvgbAbqqurYlAJV3amqHYCOwO2RCM4YY4wx5nhkN8G5VFVXZrRCVd8B6oYtohAicnbKJJn+s11EHvHrHhKR30VkgYi8HLLPkyKyTEQWi8g1mdT7WEid80XkkIiUO8bxLhCRGSLym4hMFJFTInHOxhhjjMm9bI3BUdVDGZX7iSdvwrXihP09/6q6GJ88+Ykw1wEficgVwI3ABaq6T0RO99uci5tjqg5QCfifiJyVPn7/5NcAv88NwKOquhXYmtHx/G5vAL1UdbqI3AU8Bvw93OdsjDHGmNw7rqkaRORiERkO/Il7kurCsEaVsSuB5aq6CngAeElV9wGo6ka/zY24CTT3qeoK3KSbDY9Rb/qZyjM6HsBZwDd+eQpwy3GfiTHGGGMiKlstOAAiUh3XUtMBOMMXfwX8E5gU7sAykMCRROQs4FIReQE3m3gvVf0JiAdmhuyz1pdlyD8d1hLofozjASzAJVAfA7fhHpXPqM57SZndPCqG6nvHHOu8Crben+Z3BOYEZhO4GmPyS5YtOCJSSkTuEpHpuNaQILATeNpv8qyqfpJZF1a4iEhRoDXwvi+KAcoBjXFdReNERI6j6huA7333VFbHA7gLeFBEfgZK494HdBRVHa6q9VW1vkRFH0dIxhhjjMmtTBMcEXkH1wU1AtdiMhj3JNWFuFab40kojte1wC+qusF/Xwt8qM4s4DBQHjdmJrRlpTKwTkS6hQwcrhSyPn0rTWbHQ1V/V9WrVbWe32d52M7OGGOMMWGVVQtOO6AE7l0356vq31R1Xt6ElWEsoYnIx8AVACJyFlAU9yj7BCBBRIqJSA2gFjBLVf+lqnX9J8nvFwAuAz7JxvEIGcgcBfQFhoXx/IwxxhgTRlklOC8Aq3FPR60WkQ9EpLWIZHvcTjj4ObCuAj4MKf4vcIaIzAfGAp18a84CYBywEPgC6JZF91kb4Es/BcWxjgfQTkSWAL8DScBbuTszY4wxxkTKMSfb9I9kd8K9yTgW2IJrKekCXK6q30Y6yBNVVJHiWvVv4/M7DGPyjQ0yNsZEWmaTbeZkNvGSwK24ZOdy3BicJbj3w7wdOl7FODabuDHGGBNZuU5w0lVWhSOPjJ8FHFDVYrmOspCxBMcYY4yJrMwSnON60Z+qrlHVF1T1HOBi3JgYY4wxxpgC4bhacEz2WAuOMcYYE1lhbcExxhhjjCnILMExxhhjTKGTp++0OdnUDuyFYOBIQTA5/4IxxhhjTiLWgmOMMcaYQifHCY6IFBWRCiJiM0kaY4wxpkDKdoIjIleJyA/ALtyklhf48n+LSNtIBCciZ4dMkjlHRLaLyCMh6/8mIioi5f13EZEhIrJMROaJyEWZ1DsopM4lIrItZN2hkHUTQsqbi8gvIjJfRBLzesoKY4wxxmRfthIcEWkFfA4cAJ5Jt9963LQNYaeqi1MmyQTqAbuBj3xMVYCrcfNlpbgWN8FmLeBeYGgm9T4aUu8/STvv1J6QiTlb+2NFAYlAgqqeB6zCvdHZGGOMMQVQdltwngXeUdXLgJfSrZsH/F9Yo8rYlcByVV3lvw8CHgdCX+RzIzDKT7w5EygjInHHqPeomcMzcCqwX1WX+O9TgFtyFL0xxhhj8kx2E5w6wGi/nP7NgH8B5cMWUeYS8ImIiNwIrFPVuem2iQfWhHxf68syJCLVgBrAtJDi4iIyW0RmishNvmwzECMi9f33W4EqmdR5r99/9s8boqi+d8yRT+9Ps3mqxhhjjMmN7I4j2QmUy2RdVVwCEDEiUhRoDTzpJ/3sg+ueyq0E4ANVPRRSVk1V14nIGcA0EflNVZeLSAIwSESKAV8ChzKqUFWHA8PBzSYehhiNMcYYk0PZbcGZCjwhIqVCylREigAPApPDHlla1wK/+BnLz8S1uswVkZVAZeAXEamIG/wc2rJSGVgnIi+kDBxOV29qq1AKVV3nf/4BfA1c6L/PUNVLVbUh8A1uJnVjjDHGFEDZTXCewrXU/A68juum6gn8jEs4gpEILkTqOBlV/U1VT1fV6qpaHdcNdZGq/glMADr6p6kaA8mqul5VnwoZVAyAiJwDlAVmhJSV9S00+CezLgYW+u+n+5/FgCeAYRE+Z2OMMcYcp2wlOKq6HGgATAduAwS4HlgANFbVNVnsnisiEgtcRdonnTLzGfAHsAwYgWtdykwCMFbTzjZaG5gtInOBr4CXVHWhX/eYiCzCDaqeqKrTMMYYY0yBdFyziYtIlKoejkA8hUpUkeJa9W/j05StfOm6fIrGGGOMKXwym038uBIckz2xsbG6a9eu/A7DGGOMKbQyS3AyfYpKRP6dg/pVVbsdV2TGGGOMMWGWaQuOiPxJ2nfexAKlfNl24BTcWJydwE5VrRTZUE881oJjjDHGRFZmLTiZDjJW1YqqGqeqccBNwDagM1BSVcsCJXFTNGzDvUHYGGOMMaZAyO6L/l4DBqjqqJQCVd0HJIpIGWAI0CQC8RljjDHG5Fh234NTF/cOnIwsxM8sbowxxhhTEGS3BWcjcDNuksn0bgE2hS2iQqR2YC8EA5GpPJgcmXqNMcaYQiC7Cc4/gZf923zfBzYAFYC2uPE3j0cmPGOMMcaYnMvum4xfAR4CmgJjgP/5n02Ah1R1YCSCE5GzU+aQ8p/tIvKIiNwmIgtE5HDIDN8p+zwpIstEZLGIXJNJvY+F1DlfRA6JSDkRKS4is0Rkrq//mZB9movIL377RBHJbnJojDHGmDyWoxf9+T/qNYA4YD2wQlUPRii29MeOxk2m2Qj3BNdh4D9AL1Wd7bc5FzdnVUOgEi4ROyvdbOHp670BeFRVm4uIALGqutNPJPod8DAwC1gFXKmqS0TkWWCVqr6ZVcz1K0Xr7HtLZbXJ8bMuKmOMMSbnj4lnRFUPqupSVf3G/8yT5Ma7EliuqqtUdZGqLs5gmxtx80vtU9UVuDmpGh6j3tCJPFVVd/ryIv6jwKnAflVNmUF8Cm7skTHGGGMKoGwnOL67aLSIrBGRXf7nKBE5O5IBhkjAJyJZiAdCJ/5c68syJCIlgZbA+JCyaBGZgxtYPUVVfwQ2AzEh3WG3AlVyfAbGGGOMyRPZGkciIhcC3+C6hT4D/gQqAq2Bm0TkUlWdG6kgRaSoP9aTYa76BuB7Vd2aUuC7s+r69/t8JCLnqep8EUkABolIMeBLIMNuLxG5F7gXgKgYqu8dE+aQbcJOY4wx5liyO1D2JWApbgzKXymFIlIWmOrXXxv+8FJdC/yiqhuOsd060rasVAbWiUg3oKsva6WqSX4501YhVd0mIl/hWnjmq+oM4FIAEbkaOCuT/YYDw8HNJn6sEzPGGGNM+GW3i6op8EJocgPgv78AXBzuwNJJHSdzDBOABBEpJiI1gFrALFX9l6rW9Z8kABEJAJcBn6TsLCKn+ZYbRKQEcBX+BYf+EXl8C84TwLCwnZ0xxhhjwiq7CY6QSZeML5fwhJPBgUVicYnGhyFlbURkLe4x9U9FZDKAqi4AxuHervwF0C2LJ6jaAF+qauhsmHHAVyIyD/gJNwZnkl/3mIgsAuYBE1V1WthO0hhjjDFhla3HxH1XTTFcF9WekPLiuEex96nqlRGL8gQVVaS4Vv3b+GNvmEM2BscYY4xxMntMPLsJzsW4sTbJuC6d9RwZZFwGaO7HqJgQsbGxumvXrmNvaIwxxpjjklmCk61Bxqr6vYhcAgSB24HSwA5gOvCMqv4cxliNMcYYY3IlR28yTt1JJDqrtwMbx1pwjDHGmMjK8ZuMxblKRM5Jvy4luRGRc0TkqvCGaowxxhiTO1k9RXUHbrxNVtMxHAQ+FpHbwhqVMcYYY0wuZJXgdABGquqyzDbw60YCXcIclzHGGGPMcctqkHE94N/ZqGMy8EZ4wilcagf2QjAQ/optJnFjjDEmS1m14JwCbM1ifYqtQAT+ihtjjDHGHJ+sEpwtZG/G7Cp+W2OMMcaYAiGrBOcH3DicY+kAfB+ecI4mImVE5AMR+V1EFolIExGpKyIzRWSOiMwWkYZ+WxGRISKyTETmichFmdQ5yO87R0SWiMi2kHWdRGSp/3QKKb/d17lARPpH6nyNMcYYk3tZjcEZDHwtIi8BT6V/742IRAMvAtfgJq2MlMHAF6p6q4gUBUri5pt6RlU/F5FWwMvA5bhZx2v5TyNgqP+Zhqo+GnIeDwEX+uVywNNAfUCBn0VkAi4RHADUU9VNIpIoIleq6tQInbMxxhhjciHTBEdVvxWRPkA/4E4R+QJY5VdXA1riJqfso6rfRSI4P+N3M6Czj2k/sF9EFDdGCNz4nyS/fCMwSt3bC2f61p84VV2fxWHa4ZIacMnaFFXd6o8/BXeey4ClqrrJb/c/4Bbc9BXGGGOMKWCynKpBVfuLyC9Ab1xXVBG/6gDwHdBFVadEML4awCbgLRG5APgZeBh4BJgsIq/gWlea+u3jgTUh+6/1ZRkmOCJSzR8jZWbwzPb/AjhbRKr7spuAopnUeS9wLwBRMVTfOya755p9vT/N9qY2MacxxpiT0THnovIJzBQRKQZU8MUbVHVfRCNzYoCLgIdU9UcRGYxLtgLAo6o6XkTaAm8CLY6j/gTgg2NNO6Gqf4nIA8B7wGHc+KQzM9l2ODAc3GzixxGTMcYYY3Ipq0HGaajqPlVd7T95kdyAay1Zq6o/+u8f4BKeTsCHvux9oKFfXkfaJ78qA+tE5IWUQcXp6k8A3g35nuH+AKo6UVUbqWoTYDGwJFdnZowxxpiIyXaCkx9U9U9gjYic7YuuBBbixtykDGxuDiz1yxOAjv5pqsZAsqquV9WnVLWuqtZNqdvPsVUWmBFyyMnA1SJSVkTKAlf7MkTkdP+zLPAg9nJDY4wxpsA6ZhdVAfAQ8I5/guoP3LQQnwCDRSQG2EvKmBf4DGiFGxS8m6ynkEgAxmrIdOqqulVEngN+8kXPpgw49se7IKTcWnCMMcaYAkpC/r6bMIsqUlyr/m18vsZgg4yNMcYUZiKyW1Vjjyq3BCdyYmNjddeuXfkdhjHGGFNoZZbgFOgxOMYYY4wxx+OYY3BE5AzcC/TOA8rhHpNeD3wLfJyHT1QZY4wxxmRLpl1UfiqGQcADQHTIqkPAHqAULtHppKr/i3CcJyTrojLGGGMi63i6qPoAXYEg0AA4H7gf92bhp4DquHfQTBSR+mGO1xhjjDHmuGXVgrMCGKaq/dOVXwX/396dh8lVlO0f/95DQsAAYZM1QLMLIgTMj0XZBERgEFQUwiuyiEYWFQTRQV418ooOoiAosggqKAgioMFmXwREAkIMkLBGaCAhgOyQGNbn90dVm844PemZ6U73tPfnuuaa7jp1qp/qnsw8qapzisuBFSJijqSLgSUiwpfr9OARHDMzs8aqNoLT1xqclYG7eim/k7Sj95rANNLO3r7pXS82GDUXJoxqdhj/3Sa83OwIzMysCfqaonqcdJfgnnYCAngmP3+eeZtwmpmZmTVdXyM4pwMnS1qatJv2G8CWwFeAKyLiuVxvPeCxhkZpZmZm1g9VR3Ai4jTgBOBA0tYIVwHfIu33dGBF1dnA9xsVoKSSpPvyZpl35bIxkiaVyyRtnssl6TRJ0yXdK2mzPtrdW9L9kqZJurCi3dtz2b2S9qmov4OkyZKmSjovbxNhZmZmLWiBdzKWtASwCeny8Icr9mZaKCSVgLEVI0ZIuhY4JSKukrQb8LWI2D4//hJpP6otgFMjYote2lyXtHZoh4h4UdIKEfGspPWAiIhHJK0C3A1sALxCmrLbMSIelnQ88HhEnNtX7GNXWSTuGr9EHd4FGzCvwTEza2sDvpNxRLwWEbdFxKSFndz0IYCl8uNRpN3FId2Q8PxIJgFLS1q5l/M/D5weES8CRMSz+fvDEfFIfvwU8CzwbmA54I2KDTavA/aqf7fMzMysHvo9zSKpA3gN+EBETKl/SP8hgGslBXBWRJwNHAlcI+mHpCTtA7nuqsCTFefOyGWzerS5HoCk20g3MZwQEVdXVsjTXosC/8gxDJM0NiLuAj4JrNZbsJLGU97dvGMYhbkXDqTPQ5o3+DQzs2YbyDoSAYux8Pax2joiZkpaAbhO0oOkBOMrEXGppL2Bc0lXd9VqGLAusD0wGrhF0vsi4iWAPOrza9Jdmt/JZeOAUySNAK4lTdn9h5yAnQ1pCuvSAgAAIABJREFUN/F+99bMzMwGreU324yImfn7s6QbDG4OHABclqtckssAZjL/yMpoYKakE/KC5PKI0wxgYkS8GRGPAQ+TEh4kLQUUgePyNFc5jtsjYpuI2By4JZ9jZmZmLailExxJIyUtWX4M7AxMJa252S5X2wF4JD+eCOyfr6baEng5ImZFxHERMSYixuR6fyCN3iBpedKU1aOSFiUlUedHxO97xLJC/j4C+DpwZiP6bGZmZoPX7ymqiHhb0q4snBGMFYHLJUGK9cKIuFrSa8Cp+VLtuZTXvMCVpCuopgNzgIOqtHsNsLOk+0lTTcdExPOS9gO2BZaTdGCue2Bea3SMpN1JSeEZEXFjnftqZmZmdbLAy8Rt4DqGLxarH31ps8NY6LzI2MzMFpZql4nXch+cjUj3lvkgaX+qIF2VdCvw04i4v/7htgdvtmlmZtZYA7oPjqSDgMmkqZ65wM2kxOZ10r1k/i7pM/UP18zMzGzgqo7gSFofuIe0XuXQfOO7yuOrAmcAHwY2Lt8gz+bxCI6ZmVljDWQE5xDSTe726pncwL8v394LeBQ4tF6BmpmZmQ1WXwnOtsC5EfFWtQoR8SbpJnvbVatjZmZmtrD1leCsCdxXQxv3AmvVJxwzMzOzwevrPjhLkXbRXpBXAW+Z3YsNRs2FCaOaHUb78k7hZmZWRV8jOB3AO3Vox8zMzGyhWtCdjH8iaUGjOEvVK5jeSCqRRoneBt6KiLGSTgI+CrxBWgh9UMVGmccCB+f6X46Ia3ppc3vgj8BjueiyiDg+Xzl2cUXVtYBvRcSPJW1C2p5hCaAEfDoiahnhMjMzs4WsrwTnTtJN/ZZcQBuR6zbShyLiuYrn1wHHRsRbkk4EjgW+LmlDYBzwXmAV4HpJ60VEbzt/3xoRu1cWRMRDwBgASYuQNu+8PB8+B/hqRNws6bPAMcA369dFMzMzq5eqCU5EbLkwA+mPiLi24ukk4JP58Z7ARRHxOvCYpOmkncZvH8DL7Aj8IyIez8/XI+0iDinBugYnOGZmZi2p35ttNkEA10oK4KyIOLvH8c8yb1ppVVLCUzYjl/VmK0n3kHYm/2pETOtxfBzw24rn00gJ1B+ATwGr9daopPGUN//sGEZh7oXVe2aD01VsdgRty/uJmdlQV3VxsKSCpNsk7dFHnY/mOqMbEx4AW0fEZsCuwOGStq14/eOAt4AL+tnmZGCNiNgE+Akpafk3SYsCewCXVBR/FjhM0t2kabs3ems4Is6OiLERMVYdi/QzLDMzM6uHvq5+OhJYPCImVqsQEVcAI4Aj6h1YxWvMzN+fJa2H2RxA0oHA7qTFvuX9JmYy/8jKaGCmpMMlTclfq0TEKxHxWm73SmC4pOUrztsVmBwRz1TE8WBE7BwR7yeN7PyjEf01MzOzwesrwdmZdJfiBTkX2K0+4cxP0khJS5Yf55imStoF+BqwR0TMqThlIjBO0ghJawLrAndGxOkRMSZ/PSVpJUnK7W5Oeh+er2hnX+afnkLSCvl7B/C/pCuqzMzMrAX1tQZnTWBqDW3cn+s2worA5TkXGQZcGBFX58XDI4Dr8rFJEXFIREyT9Lsc01vA4VWuoPokcKikt4B/AePKo0A5kfow8IUe5+wr6fD8+DLgl/XsqJmZmdVPX7uJvwp8PCKu77MBaSfg8ohY0OXk/3U6hi8Wqx99abPDMOs3LzI2s6Gi2m7ifY3gPAJsBfSZ4AAfyHWth8UXXcR/KMzMzJqgrzU4lwNfltTr5dAAktYAvgh4mMLMzMxaRl8JzinAC8DfJB1aeSm4pNGSDiXdc+YF4NTGhmlmZmZWu6prcCAlMsBFpGmoYN7mmx2AgNuAfSNiRoPjHJJGjhwZs2fPbnYYZmZmbWsga3DIicvWkrYBdmLePWaeBK6PiFvrHqmZmZnZIPU5gmOD4xEcMzOzxhrQCI4Nzgaj5sKEUc0Ow1rVhJebHYGZWduqmuBIeoS07qYWERHr1yckMzMzs8HpawTnbmpPcMzMzMxaRtUEJyLGLcxA+iJpEeAuYGZE7J73kfou8CngbeCMiDgtl59K2htrDnBgREzupb0DgZNIm3MC/DQizsnHrga2BP4SEbtXnLMD8ENgUVLyd3BEvNWI/pqZmdng9HUfnFZyBPBAxfMDSVd0vSciNiBdyg5pF/B189d44Iw+2ry4YgPOcyrKTwI+U1kxb7B5HmnPqo2Ax4EDBt4dMzMza6SWT3DyvXg6gcok5FDg+Ih4ByAins3lewLnRzIJWFrSyv15vYi4AXi1R/FywBsR8XB+fh2wV/96YmZmZgvLULiK6sfA14DKzTzXBvaR9HHgn8CXI+IRYFXSPXrKZuSyWb20u5ekbYGHga9ExJO91Cl7DhgmaWxE3EXajbzXLSwkjSeNHkHHMApzL1xwD/+Lea8uMzNrhJYewZG0O/BsRNzd49AIYG5EjAV+Dvyin01fARQiYmPSaMx5fVWOdLOgccApku4kjfC8XaXu2RExNiLGqmORfoZlZmZm9dDqIzgfBPaQtBuwGLCUpN+QRmYuy3UuB36ZH89k/pGV0cBMSSeQprnIa26er6hzDvCDBQUSEbcD2wBI2hlYb6CdMjMzs8Zq6RGciDg2IkZHRIE0gnJjROwH/AH4UK62HWmaCWAisL+SLYGXI2JWRBxXXlAM0GNdzh7Mv4C5V5JWyN9HAF8Hzhx8D83MzKwR+rrR3wr9aahioe/C0A1cIOkrwGvA53L5laRLxKeTLhM/qMr5X5a0B/AWaTf0A8sHJN0KvAdYQtIM0uXg1wDH5CmzDtJl6TfWvVdmZmZWF1X3opL0Dv240V9EeMFJDx3DF4vVj7602WG0NC8yNjOzwai2F1VfCc4h9C/BOWvg4bUnb7ZpZmbWWP1OcGzwnOCYmZk1VrUEp9+LjCWtI2kLSe+qT2hmZmZm9VVzgiPp4Lzo9iHgr6SFuEj6fZ7OMjMzM2sJNSU4eXPKs4EbSXswqeLwHcA+dY/MzMzMbIBqHcE5Bjg1IvYHftvj2APk0RwzMzOzVlDrnYzXBopVjr0KLFOfcNrLBqPmwoRRzQ7DzMysuSa8vNBfstYRnBeosrkkacuC3jazNDMzM2uKWhOcIvC/kiqTnJC0NHAk8Me6RwZIWkzSnZLukTRN0ndy+Q6SJkuaKuk8ScNyuSSdJmm6pHslbbaA9veSFJLG5ucFSf+SNCV/nVlRd5/c5jRJJzaiv2ZmZlYftSY4x+W69wN/It0A8If5+XDgOw2JDl4HdoiITYAxwC6SPkDa/XtcRGwEPE5a+AywK7Bu/hoPnFGtYUlLAkeQFklX+kd536qIOCTXXQ44CdgxIt4LrCRpx3p10szMzOqrpgQn7zO1GXAa8G7Srt3LkhKNLSLixUYEF8lr+enw/PU28EZElDfYvA7YKz/eEzg/nzcJWLrHxpqV/g84EZhbQyhrAY9ExD/z8+srXtPMzMxaTM33wYmIl/Ku3GMjYvWI2DTv9t2Q5KZM0iKSpgDPkpKZO4Fh5Wkl4JPMWx+0KvBkxekzclnPNjcDVouI3hZOrynp75JulrRNLpsOrJ+nsIYBH6P6miQzMzNrspquopL0feC8iHiwwfH8h4h4GxiT1/tcDrwXGAecImkEcC1pVKcmkjqAk6nYQbzCLGD1iHhe0vuBP0h6b0S8KOlQ4GLgHdKNDteu0v540vQYdAyjMPfCWkMzMzNrS6UmvGatIzhfBKZJukvSlyW9u5FB9SYiXgJuAnaJiNsjYpuI2By4BShPV81k/pGV0cBMSSeUFw4DSwIbAX+WVAK2BCZKGhsRr0fE8/n17gb+QbpKjIi4IiK2iIitSHdzfpheRMTZeZRrrDq8wbqZmVkz1JrgrADsD/wT+BEpafiTpL3zKEpDSHp3HrlB0uLAh4EHJa2Qy0YAXwfKVztNBPbPV1NtCbwcEbPy1Fp54fDLEbF8RBQiogBMAvaIiLvy6y2S216LtFj50fy8/JrLAIcB5zSq32ZmZjY4NU1RRcS/gAuACyStCHw6f10EvCLpkoj4fAPiWxk4LycdHcDvIuJPkk6StHsuOyMibsz1rwR2I62ZmQMc1M/X2xY4XtKbpKmoQyLihXzsVEmb5MfHVyxyNjMzsxajiBj4ydKHgPOBVSLC8zE9dAxfLFY/+tJmh2FmZtZUpe7OhrUtaU5EjOxZXutWDZUNjSBdRbQfsDNp481q2ziYmZmZLXQ1j+BI2h74DOn+L0sBd5FGby6KiOcaFeBQNnLkyJg9e3azwzAzM2tbgxrBkfQE8+4x81Pg1xHxUH1DNDMzM6uPWqeoriUlNTc3MhgzMzOzehjUImPrm6eozMzMGqvaFFXNWzVIWlHS9yT9RdL9kjbM5YdVbJtgZmZm1nS1rsF5D+mOwcOBvwFbAYvlw+sDHyBdVWUVNhg1FyaManYY9Tfh5WZHYGZm1qdaR3B+CDwGrEm6kZ4qjt1GSnjMzMzMWkKti4y3A/aLiJfKWxlUeJp0x2EzMzOzllDzGhyq79i9HPCvOsTSK0mLSbpT0j2Spkn6Ti6/QNJDkqZK+oWk4blckk6TNF3SvZI2q9LuIZLuy5tw/qViTdFwSeflYw9IOrbinCPy602TdGSj+mxmZmaDU2uCcxfpJn+92Yu0YWWjvA7sEBGbAGOAXfJGmhcA7wHeBywOfC7X35W0Sea6wHjgjCrtXhgR74uIMcAPgJNz+aeAERHxPuD9wBckFSRtBHwe2BzYBNhd0jr17aqZmZnVQ60JzgnAXpKuICUAAWwr6Sxgb+B7DYqPSF7LT4fnr4iIK/OxAO4ERuc6ewLn50OTgKUl/ccUWkS8UvF0JKlP5O8jJQ0jJU5vAK8AGwB3RMSciHgLuBn4RF07a2ZmZnVR627i10vaG/gxUN4x62TgKWDviLitQfEBkNf93A2sA5weEXdUHBtOGl06IheV77hcNiOXzeql3cOBo4BFgR1y8e9JSdIs4F3AVyLiBUlTgRMklafkdiONbPVsczxp5Ag6hlGYe+HAOt3Kulpv67FGbuRmZmZDT81rcCLiMmANYGNgJ2BTYPWI+EODYqt87bfzVNJoYPM8XVT2M+CWiLh1AO2eHhFrA18H/jcXb05ab7QK6aqxoyWtFREPACeS7up8NTCFXtYlRcTZETE2Isaqwxusm5mZNUN/FhmXp4umRsSNEXFPRLwj6UOS7mxUgD1e/yXgJmAXAEnfBt5NGoUpmwmsVvF8NDBT0gl5QfGUXpq+iLRDOsD/AFdHxJsR8SzpMvix+fXPjYj3R8S2wIvAw/XrnZmZmdVLvxKcKpYlLcZtCEnvlrR0frw48GHgQUmfAz4C7BsR71ScMhHYP19NtSXwckTMiojjImJMHglC0roV53QCj+THT5CnqySNBLYEHszPV8jfVyetv2nD+SczM7Ohr9b74DTTysB5eR1OB/C7iPiTpLeAx4HbJQFcFhHHA1eS1sdMB+YAB1Vp94uSdgLeJI3GHJDLTwd+KWka6YaGv4yIe/OxS/ManDeBw/OIkpmZmbWYlk9wcnKxaS/lvcaer6o6vIZ2j6hS/hrpSrHejm2zoHbNzMys+Vo+wRnKFl90EV/dY2Zm1gRVExxJq9TYxrJ1isXMzMysLvoawZnBvJvf9UU11jMzMzNbKPpKcA7DiYuZmZkNQUprcq0RRo4cGbNnz252GGZmZm1L0pyIGNmzvB73wTEzMzNrKb6KqoE2GDUXJoxqdhitb8LLzY7AzMzajEdwzMzMrO04wTEzM7O209IJjqTVJN0k6X5J0yQdkcs3kXS7pPskXSFpqYpzjpU0XdJDkj5Spd09Jd2bN9+8S9LWFceulvSSpD/1OGcHSZMlTZV0niRP75mZmbWolk5wgLeAoyNiQ9Kml4dL2hA4B+iKiPcBlwPHAORj44D3knYc/1new6qnG4BN8sabn83tlZ0EfKaysqQO4DxgXERsRNoD6wDMzMysJdWc4EhaQ9JZeeTj+fz9zLyzdkPkXcAn58evAg8AqwLrAbfkatcBe+XHewIXRcTrEfEYacPNzXtp97WYd338SCru9xMRNwCv9jhlOeCNiHi4l9c0MzOzFlPTNEuewrkaeBu4BrgZWBHYF9hP0s4R8deGRZliKJA23bwDmEZKZv5A2hhztVxtVWBSxWkzcllv7X0c+D6wArCgDaOeA4ZJGhsRdwGfrHjNnu2OB8YD0DGMwtwLF9B0+/H+W2Zm1my1juCcTEoq1oiIvSPiSxGxN1Agjaqc0qD4AJC0BHApcGREvEKaVjpM0t3AksAb/W0zIi6PiPcAHwP+bwF1gzT1dYqkO0kjPG9XqXt2RIyNiLHq6G12zMzMzBqt1gTnfcD3I+KlysKIeJE0CrJxvQMrkzSclNxcEBGX5dd9MCJ2joj3A78F/pGrz2T+kZXRwExJh+cFxVN6biIaEbcAa0lavq84IuL2iNgmIjYnTY893Fd9MzMza55aE5yn+qjbAcyqTzjzkyTgXOCBiDi5onyF/L0D+F/gzHxoIjBO0ghJawLrAndGxOkRMSZ/PSVpndw2kjYDRgDPLyCW8muOAL5e8ZpmZmbWYmq91PmHwLcl3RoR/ywX5j/63wR+0IjggA+Srmi6T9KUXPYNYF1Jh+fnlwG/BIiIaZJ+B9xPugLr8IjobSppL2B/SW8C/wL2KS86lnQr8B5gCUkzgIMj4hrgGEm7kxK6MyLixgb018zMzOqgps02Jf0c+AjpaqJbgWdIi4y3IS3AvaaiekTEF+of6tDTMXyxWP3oS5sdxkLnRcZmZrawVNtss9YEpz9TUBERqyy4WvvzbuJmZmaNVS3BqWmKKiJWrn9IZmZmZo3R6ncyNjMzM+u3mvdTylcPfQbYDlgWeAG4iXT59uuNCc/MzMys/2pdg/Nu4EbSHk/PAE8DK5EWGk8FdoiI5xoY55DkNThmZmaNVW0NTq1TVCcCKwMfjoiVI2LTvC7nw6RE58T6hWpmZmY2OLWO4DwLHBcRP+/l2Hjg/yJixQbEN6SNXWWRuGv8Es0OY+ib8HKzIzAzsxY12BGcpYAnqhx7PB83MzMzawm1JjgPk3YO780+NGhfJkmrSbpJ0v2Spkk6IpePkTQp7y11l6TNc7kknSZpuqR78zYMvbV7VG7zXkk3SFqj4tgP8ms9kNsqb+mwT64/TZKn5MzMzFpYrVdRnQKcmxcbX0Dae2ol0g7buwMHNyY83gKOjojJkpYE7pZ0HWlriO9ExFWSdsvPtwd2Je0/tS6wBXBG/t7T34GxETFH0qH5/H0kfYC0PUR589C/ANtJug84CXh/RPxT0nmSdoyIGxrUbzMzMxuEWm/098ucYHyLlEQEINKl4kdGxK8aEVxEzCJv5BkRr0p6AFg1v355WmwUaTNQgD2B8/O+UpMkLS1p5dxOZbs3VTydBOxXPgQsBixK6t9w0lVjawGPVOzDdT1pPysnOGZmZi2o5vvgRMRpks4ANmLefXCmRsSbjQqukqQCsClwB3AkcI2kH5Km2T6Qq60KPFlx2oxc1tdWEwcDVwFExO2Sbsr1Bfw0Ih6QtAywfo5hBvAxUhJkZmZmLahqgiPpUeDjEXFPuSwnM39fGIH1iGUJ4FLSaNErkr4LfCUiLpW0N3AusNMA2t0PGEu6eSGS1gE2AEbnKtdJ2iYibs1TWRcD7wB/Bdau0uZ4YDwAHcMozL2wv2FV5U0szczMatPXIuMCMGIhxVGVpOGk5OaCiLgsFx8AlB9fAmyeH88EVqs4fTQwU9IJeUHylIp2dwKOA/aouBPzx4FJEfFaRLxGGtnZCiAiroiILSJiK+AhqiysjoizI2JsRIxVxyKD67yZmZkNSEvvRZWvYDoXeCAiTq449BR51AXYAXgkP54I7J+vptoSeDkiZkXEcRExJiLG5HY3Bc4iJTfPVrT7BGlR8bCcWG0HPJDPWSF/XwY4DDinAV02MzOzOljQGpwF3wWwsT5I2v/qvorRl28AnwdOlTQMmEt5SgiuBHYDpgNzgIOqtHsSsARwSb4K/ImI2AP4PSlhuo/U96sj4op8zqmSNsmPj4+Ihlwab2ZmZoNX9U7Gkt4BrgZq2WMqIuKAegbWDjqGLxarH31p3drzGhwzM7P5VbuT8YISnKeBWnYKj4hYa3Ahth9vtmlmZtZY1RKcBU1RfSwi7mxQTGZmZmYN0dKLjM3MzMwGwgmOmZmZtR0nOGZmZtZ2qq7BiQgnP2ZmZjYk1bwXlfXfBqPmwoRRzQ7D7L/PhJebHYGZNZlHaczMzKztOMExMzOzttPSCY6k1STdJOl+SdMkHdHj+NGSQtLy+bkknSZpuqR7JW1Wpd2jcpv3SrpB0hq5/EPlTTnz11xJH8vHdpA0WdJUSeflbSLMzMysBbV0ggO8BRwdERsCWwKHS9oQUvID7EzaILNsV2Dd/DUeOKNKu38HxkbExqT9p34AEBE3VWzKuQNpP6trJXUA5wHjImIj4HHSjuZmZmbWglo6wck7gU/Oj18l7ey9aj58CvA15t8QdE/g/EgmAUtLWrmXdm+KiDn56SRgdC8v/0ngqlxvOeCNig02rwP2GlzvzMzMrFGGzDSLpAKwKXCHpD2BmRFxT94NvGxV4MmK5zNy2aw+mj4YuKqX8nHAyfnxc8AwSWMj4i5S8rNalTjHU97dvGMYhbkX9tmv/zbeMNTMzBaGIZHgSFoCuBQ4kjRt9Q3S9NRg290PGAts16N8ZeB9wDWQdhKVNA44RdII4Frg7d7ajIizgbMh7SY+2BjNzMys/1o+wZE0nJTcXBARl0l6H7AmUB69GQ1MlrQ5MJP5R1ZGAzMlnQB0AuT1NUjaCTgO2C4ieu6YvjdweUS8WS6IiNuBbfK5OwPr1buvZmZmVh8tvQZHKYM5F3ggIk4GiIj7ImKFiChERIE0DbVZRDwNTAT2z1dTbQm8nNfxHFexeBhJmwJnAXtExLO9vPS+wG97xLJC/j4C+DpwZiP6bGZmZoPX6iM4HwQ+A9wnaUou+0ZEXFml/pXAbsB00hVQB1WpdxKwBHBJHgV6IiL2gH+v9VkNuLnHOcdI2p2UFJ4RETcOpENmZmbWeIrwMpFG6Ri+WKx+9KXNDqOleJGxmZnVk6Q5ETHyP8qd4DTOyJEjY/bs2c0Ow8zMrG1VS3Baeg2OmZmZ2UA4wTEzM7O24wTHzMzM2o4THDMzM2s7TnDMzMys7bT6fXCGtA1GzYUJoxrT+ISXG9OumZlZG/AIjpmZmbUdJzhmZmbWdlo+wZH0C0nPSpray7GjJYWk5fNzSTpN0nRJ90rarEqbR0m6P9e5QdIauXwNSZMlTZE0TdIhFefsk+tPk3Rio/prZmZmg9fyCQ7wK2CXnoWSVgN2Bp6oKN4VWDd/jQfOqNLm34GxEbEx8HvgB7l8FrBV3pRzC6BL0iqSliPtX7VjRLwXWEnSjoPtmJmZmTVGyyc4EXEL8EIvh04BvgZU7jWxJ3B+JJOApSWt3EubN0XEnPx0EjA6l78REa/n8hHMe3/WAh6JiH/m59cDew2iW2ZmZtZAQ/IqKkl7AjMj4p68G3jZqsCTFc9n5LJZfTR3MHBVRdurAUVgHeCYiHhK0r+A9fNO4zOAjwGLVoltPGn0CDqGUZh7YX+6VruuYmPa/S/ijT/NzNrXkEtwJL0L+AZpemqwbe0HjAW2K5dFxJPAxpJWAf4g6fcR8YykQ4GLgXeAvwJr99ZmRJwNnA1pN/HBxmhmZmb91/JTVL1YG1gTuEdSiTS9NFnSSsBMYLWKuqOBmZJOyAuHp5QPSNoJOA7Yo2Ja6t8i4ilgKrBNfn5FRGwREVsBDwEPN6R3ZmZmNmhDLsGJiPsiYoWIKEREgTRltFlEPA1MBPbPV1NtCbwcEbMi4riIGJMXDyNpU+AsUnLzbLltSaMlLZ4fLwNsTUpmkLRCRflhwDkLq89mZmbWPy0/RSXpt8D2wPKSZgDfjohzq1S/EtgNmA7MAQ6qUu8kYAngkryG54mI2APYAPiRpAAE/DAi7svnnCppk/z4+IjwCI6ZmVmLUoSXiTRKx/DFYvWjL212GFaFFxmbmQ19kuZExMj/KHeC0zgjR46M2bNnNzsMMzOztlUtwRlya3DMzMzMFsQJjpmZmbUdJzhmZmbWdpzgmJmZWdtp+cvEh7INRs2FCaOaHUZjTHi52RGYmZlV5REcMzMzaztOcMzMzKzttHyCI2kXSQ9Jmi6pK5etKemOXHaxpEVz+baSJkt6S9In+2iz13qS1sjlUyRNk3RIxbF9JN2by09sZJ/NzMxscFo6wZG0CHA6sCuwIbCvpA2BE4FTImId4EXg4HzKE8CBwIULaLpavVnAVnnPqi2ALkmrSFqOtL3DjhHxXmAlSTsOsntmZmbWIC2d4ACbA9Mj4tGIeAO4CNgT2AH4fa5zHvAxgIgoRcS9wDt9NVqtXkS8UbGz+AjmvT9rAY9ExD/z8+uBvQbVMzMzM2uYVr+KalXgyYrnM0gjKy9FxFsVZavW6wUlrQYUgXWAYyLiKUn/AtaXVMiv9zFg0SrnjwfGA9AxjMLcBQ0mDVFdxbo36b2hzMysXlp9BGehi4gnI2JjUoJzgKQVI+JF4FDgYuBWoAS8XeX8syNibESMVcciCytsMzMzq9DqCc5MYLWK56Nz2dKShvUoq0rSCXnh8JRaXzgingKmAtvk51dExBYRsRXwEPBw7d0wMzOzhanVE5y/Aevmq6YWBcYBE4GbgPLVTwcAf+yrkYg4LiLG5MXDVUkaLWnx/HgZYGtSMoOkFSrKDwPOGXCvzMzMrKFaOsHJ62y+CFwDPAD8LiKmAV8HjpI0HVgOOBdA0v+TNAP4FHCWpGm9tdtHvQ2AOyTdA9wM/DAi7svHTpV0P3Ab0B0RHsExMzNrUYqIZsfQtjqGLxarH31ps8MYMrzI2MzM+kvSnIgY+R/lTnAaZ+TIkTF79uxmh2FmZta2qiU4LT1GhLZWAAAQeUlEQVRFZWZmZjYQTnDMzMys7TjBMTMzs7bjBMfMzMzajhMcMzMzaztOcMzMzKztOMExMzOztuMEx8zMzNqOExwzMzNrO05wzMzMrO04wTEzM7O24wTHzMzM2o4THDMzM2s7TnDMzMys7TjBMTMzs7ajiGh2DG1L0jvAv5odRwMNA95qdhAN4r4NXe3cP/dt6Grn/jW7b4tHxH8M2AxrRiT/RSZHxNhmB9Eoku5q1/65b0NXO/fPfRu62rl/rdo3T1GZmZlZ23GCY2ZmZm3HCU5jnd3sABqsnfvnvg1d7dw/923oauf+tWTfvMjYzMzM2o5HcMzMzKztOMExMzOztuMEp0Ek7SLpIUnTJXU1O57BkLSapJsk3S9pmqQjcvkESTMlTclfuzU71oGQVJJ0X+7DXblsWUnXSXokf1+m2XEOhKT1Kz6fKZJekXTkUP3sJP1C0rOSplaU9fpZKTkt/xu8V9JmzYu8NlX6d5KkB3MfLpe0dC4vSPpXxWd4ZvMiX7Aqfav6cyjp2PzZPSTpI82JujZV+nZxRb9Kkqbk8qH2uVX7/d/6/+4iwl91/gIWAf4BrAUsCtwDbNjsuAbRn5WBzfLjJYGHgQ2BCcBXmx1fHfpXApbvUfYDoCs/7gJObHacdejnIsDTwBpD9bMDtgU2A6Yu6LMCdgOuAgRsCdzR7PgH2L+dgWH58YkV/StU1mv1ryp96/XnMP9+uQcYAayZf58u0uw+9KdvPY7/CPjWEP3cqv3+b/l/dx7BaYzNgekR8WhEvAFcBOzZ5JgGLCJmRcTk/PhV4AFg1eZG1XB7Auflx+cBH2tiLPWyI/CPiHi82YEMVETcArzQo7jaZ7UncH4kk4ClJa28cCIdmN76FxHXRkT5LrGTgNELPbA6qPLZVbMncFFEvB4RjwHTSb9XW1JffZMkYG/gtws1qDrp4/d/y/+7c4LTGKsCT1Y8n0GbJASSCsCmwB256It5GPIXQ3UaBwjgWkl3Sxqfy1aMiFn58dPAis0Jra7GMf8v2Xb47KD6Z9WO/w4/S/rfcdmakv4u6WZJ2zQrqEHq7eewnT67bYBnIuKRirIh+bn1+P3f8v/unOBYzSQtAVwKHBkRrwBnAGsDY4BZpGHYoWjriNgM2BU4XNK2lQcjjbsO6fspSFoU2AO4JBe1y2c3n3b4rKqRdBxpv58LctEsYPWI2BQ4CrhQ0lLNim+A2vLnsId9mf8/FkPyc+vl9/+/teq/Oyc4jTETWK3i+ehcNmRJGk764b4gIi4DiIhnIuLtiHgH+DktPITcl4iYmb8/C1xO6scz5WHV/P3Z5kVYF7uS9kZ7Btrns8uqfVZt8+9Q0oHA7sCn8x8T8vTN8/nx3aR1Kus1LcgB6OPnsC0+O0nDgE8AF5fLhuLn1tvvf4bAvzsnOI3xN2BdSWvm/zmPAyY2OaYBy3PI5wIPRMTJFeWV86ofB6b2PLfVSRopacnyY9KCzqmkz+uAXO0A4I/NibBu5vtfZDt8dhWqfVYTgf3zVR1bAi9XDKkPGZJ2Ab4G7BERcyrK3y1pkfx4LWBd4NHmRDkwffwcTgTGSRohaU1S3+5c2PHVwU7AgxExo1ww1D63ar//GQr/7pq1urndv0gryR8mZefHNTueQfZla9Lw473AlPy1G/Br4L5cPhFYudmxDqBva5Gu1rgHmFb+rIDlgBuAR4DrgWWbHesg+jgSeB4YVVE2JD87UpI2C3iTNLd/cLXPinQVx+n53+B9wNhmxz/A/k0nrWko/9s7M9fdK//MTgEmAx9tdvwD6FvVn0PguPzZPQTs2uz4+9u3XP4r4JAedYfa51bt93/L/7vzVg1mZmbWdjxFZWZmZm3HCY6ZmZm1HSc4ZmZm1nac4JiZmVnbcYJjZmZmbWdYswMw+29V6Cp+Bjih1N25en5+P/DTUnfnz+r4GlsBPwY2At4FbFrq7pxSr/YXlkJXcXtge+D4UnfnOwM4fwxpr5zTSt2dL/Q4FsB3St2dEwYfaespdBV/BWxf6u4s5OcF4DHgoFJ356/q/FpLA0cCE0vdnZPr2G6BBsVs7csjOGbN837gboBCV3EJYP3y8zo6l/QfmY8CW5HuzTQUbQ98m4H/zhqTz1+2l2NbAecMsF2b39Kk93mzZgdi5hEcs+Z5P3BNfrwZ8A7phoN1UegqdpCSphNK3Z031qvddlPq7pzU7BjMrP6c4Jg1QU4+xgDfy0VjgftL3Z1zazx/qXzuJ0h3FC0BZwI/LnV3RqGreCDwy1z9m4Wu4jeBx8vTFL20tw7pf95bAyuR7sp6DfCNUnfnixX1fkW6/fxHgdNISdpM4Eel7s4zK+qVX38r4Eu5/mvA74GvVfaz0FVcGTiRdHfUJUl3rv1BqbvzN/n4hBwbwJuFriIApe5O5ePfye2vA7xBuuPqN8qJS4/34pHy+cCape7OUm9TVIWu4i75NcfkNm8Cvl7q7nyoos6fSb9DJwA/AN5DuuX+N0vdnZdX1Fsv9++DwFKkPXvuAPYtdXe+RRWFruJI4JvAp0j7+bwI3AYcVurufCbX2Zz0c7Al6Q6yk4BjS92d/d7WoNBV3A74Fmk/qA7gL8DRpe7OqT3qfRz4KrAJKSl/EPgu6X1/LFf7eaGr+PP8+N/TSoWu4idI205sTHpfr8uv8URF++8CfgjsA4wAbiS9v2b94ikqs4Wo0FUs/0F9G1gCuDI//xGwcaGrGPmr0EcbHUAROCif91HgauBk4IRcrUhKViBNU21F2uunmlVI2wEcCXwEOB7YEbiyl7pLARcCvwH2JO29dkahq/ihXur+mnTL9k+Qdo4+HDi2oi8jgZtJm4F+g7RO5j7g14Wu4vhc7ZzcB3KftspfZasCp+RYDiQlELcUuorvq3gvvpsff6ri/F73x8nJTZGUkO0DHEpaw/SXQldx1R7V1wZOJb33n8htXpITxrJijvFQ0nvbBbxOH79/C13FRUl//L9Eut3/7sAXgReAZXKdjUnv3TK53/uTPpubC13FTaq1XeX1Okm33X8N2A/4H1KyeWuhq7haRb0vAZeR3uMDSO/n5UAh9/0Tuer3mfc+F/O5h5A2bLwf+CTwBdL7enOhq7hkRThnAZ9j3nv6EOnnzaxfPIJjtnDtBixK+mP0EeDTufwW0ojBTfn5UwtoY2vmX3B5bU4Wji50FU8udXf+s9BVLI+8zFjQNEypu/OWHAMAha7iX0l7IN1a6CpuWuru/HtF9SVJowg35bq35L7sWxF/2YWl7s7y6Mv1ha7iFrleuewg0maDHyp1d/45l11V6CquCHy30FU8t9TdOaPQVSxvVnhHz1GPUnfn5yriXoSU7E0j/ZE8Ir8X/8hVppS6O6f39V6QkqFHgV3Lr1XoKt5OWr90NHBURd3lgW1L3Z2P5HqTSX/o9wa+V+gqLk8aWdqz1N1ZueHugv5g70dKDnqe9/uKx98iJUo7lro7X8qvfx1pNO/bzEs2anEqcHOpu3PPckGhq3gT6X04GjiyYtTw8lJ3Z2Xb11ScU/45ebTyZy6vMTsR+GWpu/OzFeV3khKYg4EfF7qK65OSq+NK3Z3dudq1+fxD+tEfMyc4ZgtTqbvzfoBCV/E44M+l7s4pha7iuqSk4ZJSd+eMPhtItiVNDfT8I/kb0h+KrYAr+hNXHjH4KinxWgNYrOLw+kBlgjOnnNzkPr1e6Co+DKzeS9PFHs/vI01xlW0LzKxIbsp+Q5pW2jCf01fsO5E2ZtyY+RcRP9b7GX22NZK0Hup7lYlUqbvzsUJX8TZgux6nPFJObnK9ZwtdxWeZ9148T0oSunPS9ufK+n3YGXi6R3LT07bAn8rJTX79VwpdxYmkUb2a5J+/tUkJWeXfhDnA7fl1AD5AGnU8u9a2K2xFGl26oMdrPEma4tqWdLXfFqSRrd/1OP8inOBYPznBMVtI8uiC8tMPAl/Lv+y3Ia1jeTo/f7vU3dnXLrjLAi+Uujvf6FH+dMXx/vo+aTrkeOCvwKukdR+XMX+yA2ktSE+v91IP0pRKz3ojKp4vS+9TRTX1pdBV3Iw0jXYNKbmbRZr+O6dKPAuyDOkzqhbTGj3KevYPKt6LvB7qw6R1Ot8Hlit0FR8DTip1d57RRxzLkX4m+tLXe7fMAs6ttEL+fi7zpgIrldfHLJe/15KEV3uN66scL/9MrZy/P9PjeM/nZgvkBMds4bmB+UcAfp2/yt7M3z8E/LmPdl4Ali10FRftkeSsVHG8v8YB55e6O8trVcrTCo32AmmEqKda+7IX8BbwiVJ3Z/n9o9BVXAZ4qepZ1b0IRMXr94yp3+9tqbvzUWD/QldRpIW5XwR+VugqlkrdnVdVOe050vqUvrzQR5y9JaHVPJ+/H0vvCUj5Z+y5/H1VYGov9Wp5jQNJ04c9vZq/lxO2FUkjX1Q8N+sXJzhmC88XSFNR+5AW0+6by68krYEor2V46D9Pnc/NwDGkBZ4XVJR/mvTH6PYBxPYu5iVYZQcNoJ3+uhn4VKGr+MFSd+dtFeX/Q1rIen9+/nr+vjjz/hhCivttUlICQKGruANpiqhyiqry/KpK3Z2zC13Fu3NME0rdnW/nNtcgTdH8pB9969l2AFMKXcWjSKNNGwHVEpxrgXGFruJHS92d1aYbbwZ2K3QVlyx1d76a41ySND31536E9hBp3c57K9a99OavpEXI46lYd9NDtfe5PCq4Tqm787w+XuMO0vTr3kBlLOP6OMesV05wzBaS8iXG+ZLtYqm78668qHJ54NxSd+fTfTYwz1WkS3jPLHQV3036H/FupEW13y91dz7X18lVXA0cUOgq3kdaXPwJ0h/0RvsVcARwWV6XNIOUqH0Y+EI5wWBeonN0oat4FWka764c95HArwpdxV8C65Eure45vVM+//BCV/E8UjJ3by/TfOTzi8CfCl3Fn5HWnXwHeJl01VrN8pVOpwIXk97XRUijGG+RLn+u5jfA54HfFrqK3yf94V+StJj7x6XuzgeB/yNdXXVDoat4IinJ+zop6Tu+1hjzNNrhwB/zWqzfkUZrViT9DDxR6u48udTd+Wqhq3gs8JNCV/FSUnL9KulS+rml7s6fkKaSniclZ/cCs4HHSt2dzxe6iscAp+ef2atI7+eqpFHNP5e6Oy8sdXc+VOgqXggcn68W/BtpPdJutfbHrMyXiZstRPkPyI6kP8yQLo/+ez+SG/JWBZ3AeaQ/aMX8/CjSYtuB+BIwkXSZ+cWkP6b79nlGHZS6O2eT/sBdS/of+x9J0zifKXV3Vi5m/RPwM+Aw0gjV3/L51wBfJq1p+hPwWdJC6fmulCp1d95DWgfzUVJy+DfSpfG9xXQ16f1cmvTH/kzgAWDrUndnX1e39eZp0hqWo0jv72/z6+5e6u6setfqPN22M+nS+vGkUb6fkZLhF3Kde0l3eH6F9LPwa9IIy3a5vzUrdXdeSVroO5K0fuka0r1nVqJiRLDU3flT5t2X5wLSZd+fJI+W5Z/Nz5HWAF1Pep8/mo+dBexBmpL8de7TBNJ/tCu3D/kCaS3QV0mXoJevrDLrF0X0tZbRzMzMbOjxCI6ZmZm1HSc4ZmZm1nac4JiZmVnbcYJjZmZmbccJjpmZmbUdJzhmZmbWdpzgmJmZWdtxgmNmZmZt5/8D/hcbjDaMvfAAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 576x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(8, 6))\n",
    "indices = range(len(annos_by_axis.annos_len.tolist()))\n",
    "width = np.min(np.diff(indices))/3\n",
    "\n",
    "ax2 = ax.twiny()\n",
    "\n",
    "color_1 = 'tab:blue'\n",
    "color_2 = 'tab:orange'\n",
    "\n",
    "bar1 = ax.barh(indices - width / 2, annos_by_axis.annos_len, width, label='Annotations Collected', color=color_1)\n",
    "ax.set_yticks(indices)\n",
    "ax.set_yticklabels(x_axis_ticks)\n",
    "ax.set_ylabel('Top Level ICD-9 Code Axis', fontsize=16)\n",
    "ax.set_xlabel('# of annotations collected', color=color_1, fontsize=16)\n",
    "\n",
    "bar2 = ax2.barh(indices + width / 2, all_assn_no_pred.icd9, width, label='Assigned Codes MIMIC-III', color=color_2)\n",
    "ax2.set_xlabel('# of assigned codes', color=color_2, fontsize=14)\n",
    "\n",
    "plt.legend([bar1, bar2], [bar1.get_label(), bar2.get_label()], fontsize=12)\n",
    "plt.tight_layout()\n",
    "plt.savefig('./plots/training_data_collected_stacked.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Analysis of Validated Codes\n",
    "- We keep predictions of codes that have been validated as correctly predicted across all instances for both Predicted, Not Assigned and Predicted, Assigned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "pred_corr_assn = pd.DataFrame(json.load(open('data/MedCAT_Export_With_Text_Pred_Corr.json'))['projects'])\n",
    "pred_corr_no_assn = pd.DataFrame(json.load(open('data/MedCAT_Export_With_Text_Pred_No_Assn.json'))['projects'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1588"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum([len(d) for d in pred_corr_assn.documents])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1580"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum([len(d) for d in pred_corr_no_assn.documents])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "projs = json.load(open('data/MedCAT_Export_With_Text_Pred_Corr.json'))['projects'] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "pred_corr_all_corr_projs = [p for p in projs if all([all(a['correct'] for a in d['annotations']) for d in p['documents']])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "95.53"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(len(pred_corr_all_corr_projs) / len(projs) * 100, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "wrong_codes_p_a = set([p['name'].split(':')[2].strip().split(' ')[0] for p in projs]) - set([p['name'].split(':')[2].strip().split(' ')[0] for p in pred_corr_all_corr_projs])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'1120', '185', '3485', '4271', '51889', '58381', '5859', 'V08'}"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wrong_codes_p_a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "projs_no_assn = json.load(open('data/MedCAT_Export_With_Text_Pred_No_Assn.json'))['projects'] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "pred_no_assn_all_corr_projs = [p for p in projs_no_assn if all([all(a['correct'] for a in d['annotations']) for d in p['documents']])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "87.91"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(len(pred_no_assn_all_corr_projs) / len(projs_no_assn) * 100, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [],
   "source": [
    "wrong_codes_p_na = set([p['name'].split(':')[2].strip().split(' ')[0] for p in projs_no_assn]) - set([p['name'].split(':')[2].strip().split(' ')[0] for p in pred_no_assn_all_corr_projs])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "codes_to_remove = wrong_codes_p_a | wrong_codes_p_na"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Analyse Annotations from Fine-Tuned MedCAT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "objs = json.load(open('data/mimic_dd_annos_fine_tuned_cat.json'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "parsed_dd_mapped_to_icd9 = map_medcat_annos_to_icd9(objs, notes, codes, cuis_to_keep)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "joined_df_fine_tuned = remove_duplicate_mapped_assigned_codes(notes, codes, parsed_dd_mapped_to_icd9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'wrong_codes' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-73-154971d86dab>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mjoined_df_fine_tuned\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m~\u001b[0m\u001b[0mjoined_df_fine_tuned\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0micd9\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0misin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrong_codes\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'wrong_codes' is not defined"
     ]
    }
   ],
   "source": [
    "joined_df_fine_tuned[~joined_df_fine_tuned.icd9.isin(wrong_codes)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "assigned_no_pred    399627\n",
       "match                36869\n",
       "pred_no_assign       32207\n",
       "Name: match, dtype: int64"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "joined_df.match.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wrong_codes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "179\n",
      "183\n"
     ]
    }
   ],
   "source": [
    "y_unsupervised = compute_y(joined_df, codes_to_remove)\n",
    "y_supervised = compute_y(joined_df_fine_tuned, codes_to_remove)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "labels = ['Assigned &\\n Not Predicted', 'Assigned &\\nNot Predicted\\n(filtered)', 'Predicted &\\n Assigned', 'Predicted &\\n Not Assigned']\n",
    "indices = range(len(labels))\n",
    "width = np.min(np.diff(indices))/3\n",
    "\n",
    "fig, (ax) = plt.subplots(figsize=(7, 5))\n",
    "ax.bar(indices - width / 2, y_unsupervised, width, label='MedCAT:out-of-the-box')\n",
    "ax.bar(indices + width / 2, y_supervised, width, label='MedCAT:fine-tuned')\n",
    "ax.set_xticks(range(len(labels)))\n",
    "ax.set_xticklabels(labels)\n",
    "ax.set_ylabel('# of codes assigned')\n",
    "\n",
    "ax.legend()\n",
    "\n",
    "plt.savefig(f'./plots/aggregate_code_counts.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[389933, 216116, 42837, 42243]"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_supervised"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "432770"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(y_supervised[-2] + y_supervised[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.16542384139206728"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_supervised[-2] / (y_supervised[-2] + y_supervised[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9.898329366638169"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " y_supervised[-2] / (y_supervised[-2] + y_supervised[0]) * 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Aggregate Prediction Improvements since Fine-Tuning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "26.299999999999997"
      ]
     },
     "execution_count": 270,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(joined_df_fine_tuned[joined_df_fine_tuned.match == 'match'].shape[0] / joined_df[joined_df.match == 'match'].shape[0]  * 100, 2) - 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 373,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9694"
      ]
     },
     "execution_count": 373,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "joined_df_fine_tuned[joined_df_fine_tuned.match == 'match'].shape[0] - joined_df[joined_df.match == 'match'].shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 268,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "49.81999999999999"
      ]
     },
     "execution_count": 268,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(joined_df_fine_tuned[joined_df_fine_tuned.match == 'pred_no_assign'].shape[0] / joined_df[joined_df.match == 'pred_no_assign'].shape[0]  * 100, 2) - 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 374,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16041"
      ]
     },
     "execution_count": 374,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "joined_df_fine_tuned[joined_df_fine_tuned.match == 'pred_no_assign'].shape[0] - joined_df[joined_df.match == 'pred_no_assign'].shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 376,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.12369917886066276"
      ]
     },
     "execution_count": 376,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "joined_df_fine_tuned[joined_df_fine_tuned.match == 'pred_no_assign'].shape[0] / joined_df_fine_tuned[joined_df_fine_tuned.match == 'assigned_no_pred'].shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 380,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.11165392131218169"
      ]
     },
     "execution_count": 380,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_supervised[2]/ y_supervised[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'y_supervised' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-113-6b680809692c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0my_supervised\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'y_supervised' is not defined"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Discussion Section Analysis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### DD Subsection Total Assigned Codes Coverage of text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_annos = json.load(open('data/mimic_dd_annos_fine_tuned_cat.json'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "output_text = []\n",
    "ents = []\n",
    "text_raw = []\n",
    "for doc_annos in all_annos:\n",
    "    t = doc_annos['text']\n",
    "    r_l = 0\n",
    "    for a in doc_annos['entities']:\n",
    "        start = a['start'] - r_l\n",
    "        end = a['end'] - r_l\n",
    "        r_l = a['end'] - a['start']\n",
    "        new_t_tmp = t[:start]\n",
    "        t = new_t_tmp + t[end:]\n",
    "    output_text.append(t)\n",
    "    text_raw.append(doc_annos['text'])\n",
    "    ents.append(doc_annos['entities'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "coverage_df = pd.DataFrame({'text': text_raw, 'parsed_text': output_text, 'ents': ents})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "coverage_df['parsed_text_clean'] = coverage_df.parsed_text.str.lower()\\\n",
    "    .str.replace('\\n', '')\\\n",
    "    .str.replace('\\,|\\.|:|;|\\||\\[|\\]|\\{|\\}|\\||\\(|\\)|\\*|-|\"', '')\\\n",
    "    .str.replace('\\d', '')\\\n",
    "    .str.replace('primary', '')\\\n",
    "    .str.replace('secondary', '')\\\n",
    "    .str.replace('diagnosis', '')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "coverage_df['%_covered'] = round((coverage_df.text.str.len() - coverage_df.parsed_text_clean.str.len()) / coverage_df.text.str.len(), 2) * 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2105, 5)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "coverage_df[coverage_df['%_covered'] == 100.0].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0         46.0\n",
       "1        100.0\n",
       "2         53.0\n",
       "3         49.0\n",
       "4         50.0\n",
       "         ...  \n",
       "48893     28.0\n",
       "48894     86.0\n",
       "48895     33.0\n",
       "48896     26.0\n",
       "48897     72.0\n",
       "Name: %_covered, Length: 48898, dtype: float64"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "coverage_df['%_covered']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "47.37932021759581"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "coverage_df['%_covered'].mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x216 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, (ax, ax2) = plt.subplots(1, 2, figsize=(7, 3))\n",
    "cov = coverage_df['%_covered'].value_counts().sort_index() \n",
    "ax.bar(cov.index, cov.tolist())\n",
    "ax.set_xlabel('% of DD Text Covered \\nby MedCAT Predicted Codes', fontsize=12)\n",
    "ax.set_ylabel('Counts of Admissions', fontsize=12)\n",
    "\n",
    "toks_len = coverage_df.text.str.split(' ').apply(len).value_counts().sort_index().iloc[0:100]\n",
    "ax2.bar(toks_len.index, toks_len.tolist())\n",
    "ax2.set_xlabel('Token Length of \\nDD Subsections', fontsize=12)\n",
    "# ax2.set_ylabel('Counts of Admissions', fontsize=12)\n",
    "plt.tight_layout()\n",
    "plt.savefig('plots/dd_prediction_coverage.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "cov_len_srs = coverage_df.text.str.split(' ').apply(len)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Coverage Distribution: mean:14.542169413881957, sigma: 15.903119444412367\n",
      "Median:10.0, IQR:14.0\n"
     ]
    }
   ],
   "source": [
    "print(f\"Coverage Distribution: mean:{cov_len_srs.mean()}, sigma: {cov_len_srs.std()}\")\n",
    "print(f\"Median:{cov_len_srs.median()}, IQR:{cov_len_srs.quantile(0.75) - cov_len_srs.quantile(0.25)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Entities Extracted: mean: 3.6076935661990266, sigma:3.139975655480332\n",
      "Median:3.0, IQR:4.0\n"
     ]
    }
   ],
   "source": [
    "coverage_df['num_ents'] = coverage_df.ents.apply(len)\n",
    "print(f\"Entities Extracted: mean: {coverage_df.num_ents.mean()}, sigma:{coverage_df.num_ents.std()}\")\n",
    "print(f\"Median:{coverage_df.num_ents.median()}, IQR:{coverage_df.num_ents.quantile(0.75) - coverage_df.num_ents.quantile(0.25)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.0"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "coverage_df.text.str.split(' ').apply(len).median()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predicted and Assigned\n",
    "- Distribution of HADMs that matched\n",
    "- \\# of matches correlation with length of DD, and discharge summary\n",
    "- distribution of matches over codes\n",
    "- top codes that matched"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_ft = joined_df_fine_tuned"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_assigns = df_ft[(df_ft.match == 'assigned_no_pred') | (df_ft.match == 'match')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [],
   "source": [
    "matched = df_ft[df_ft.match == 'match']\n",
    "no_assn = df_ft[df_ft.match == 'assigned_no_pred']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [],
   "source": [
    "h_counts_n_assn = no_assn.groupby('hadm').count().icd9\n",
    "h_counts_match = matched.groupby('hadm').count().icd9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-195-d93ec8528509>:1: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  matched['code_group'] = matched.icd9.apply(lambda c: str(find_root_axis(search(c))).split(':')[0])\n"
     ]
    }
   ],
   "source": [
    "matched['code_group'] = matched.icd9.apply(lambda c: str(find_root_axis(search(c))).split(':')[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ranking\n",
    "- via % predicted vs assigned\n",
    "- via total occurrence\n",
    "- via total predicted"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "00845     7\n",
       "0380     13\n",
       "03811     0\n",
       "03842     0\n",
       "03849     0\n",
       "         ..\n",
       "V5865     0\n",
       "V5867     0\n",
       "V667      0\n",
       "V707      0\n",
       "V8741     0\n",
       "Name: icd9, Length: 400, dtype: int64"
      ]
     },
     "execution_count": 197,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "no_assn.icd9.value_counts().index\n",
    "matched.icd9.value_counts().index\n",
    "combi_index = pd.Index.union(no_assn.icd9.value_counts().index, matched.icd9.value_counts().index)\n",
    "no_assn_cd = no_assn.icd9.value_counts()\n",
    "matched_cd = matched.icd9.value_counts()\n",
    "no_assn_cd.reindex(combi_index, fill_value=0)\n",
    "matched_cd.reindex(combi_index, fill_value=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "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>code</th>\n",
       "      <th>% predicted vs assigned</th>\n",
       "      <th>code_occur_not_matched</th>\n",
       "      <th>code_occurr_matched</th>\n",
       "      <th>toal_occurr</th>\n",
       "      <th>occurrence_rank</th>\n",
       "      <th>desc</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>7470</td>\n",
       "      <td>69.187675</td>\n",
       "      <td>110</td>\n",
       "      <td>247</td>\n",
       "      <td>357.0</td>\n",
       "      <td>196</td>\n",
       "      <td>Patent ductus arteriosus</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>41519</td>\n",
       "      <td>59.022556</td>\n",
       "      <td>327</td>\n",
       "      <td>471</td>\n",
       "      <td>798.0</td>\n",
       "      <td>114</td>\n",
       "      <td>Other pulmonary embolism and infarction</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>7766</td>\n",
       "      <td>56.377551</td>\n",
       "      <td>171</td>\n",
       "      <td>221</td>\n",
       "      <td>392.0</td>\n",
       "      <td>246</td>\n",
       "      <td>Anemia of prematurity</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1550</td>\n",
       "      <td>55.769231</td>\n",
       "      <td>138</td>\n",
       "      <td>174</td>\n",
       "      <td>312.0</td>\n",
       "      <td>305</td>\n",
       "      <td>Malignant neoplasm of liver, primary</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5789</td>\n",
       "      <td>51.834504</td>\n",
       "      <td>617</td>\n",
       "      <td>664</td>\n",
       "      <td>1281.0</td>\n",
       "      <td>26</td>\n",
       "      <td>Hemorrhage of gastrointestinal tract, unspecified</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    code  % predicted vs assigned  code_occur_not_matched  \\\n",
       "0   7470                69.187675                     110   \n",
       "1  41519                59.022556                     327   \n",
       "2   7766                56.377551                     171   \n",
       "3   1550                55.769231                     138   \n",
       "4   5789                51.834504                     617   \n",
       "\n",
       "   code_occurr_matched  toal_occurr  occurrence_rank  \\\n",
       "0                  247        357.0              196   \n",
       "1                  471        798.0              114   \n",
       "2                  221        392.0              246   \n",
       "3                  174        312.0              305   \n",
       "4                  664       1281.0               26   \n",
       "\n",
       "                                                desc  \n",
       "0                           Patent ductus arteriosus  \n",
       "1            Other pulmonary embolism and infarction  \n",
       "2                              Anemia of prematurity  \n",
       "3               Malignant neoplasm of liver, primary  \n",
       "4  Hemorrhage of gastrointestinal tract, unspecified  "
      ]
     },
     "execution_count": 198,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "top_pred_codes = ((matched_cd / (matched_cd + no_assn_cd)).fillna(0) * 100).sort_values(ascending=False).head(50).reset_index()\n",
    "top_pred_codes.columns = ['code', '% predicted vs assigned']\n",
    "top_pred_codes['code_occur_not_matched'] = no_assn_cd[top_pred_codes.code].tolist()\n",
    "top_pred_codes['code_occurr_matched'] = matched_cd[top_pred_codes.code].tolist()\n",
    "top_pred_codes['toal_occurr'] = (matched_cd + no_assn_cd)[top_pred_codes.code].tolist()\n",
    "rank_df = df_ft.icd9.value_counts().reset_index()\n",
    "rank_df.columns = ['code', 'counts']\n",
    "rank_df['icd9'] = rank_df.code.apply(str)\n",
    "top_pred_codes['occurrence_rank'] = top_pred_codes.code.apply(lambda c: rank_df[rank_df.code == c].index[0])\n",
    "top_pred_codes['desc'] = top_pred_codes.code.apply(lambda c: search(c).long_desc or search(c).short_desc)\n",
    "top_pred_codes.head(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "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>code</th>\n",
       "      <th>% predicted vs assigned</th>\n",
       "      <th>code_occur_not_matched</th>\n",
       "      <th>code_occurr_matched</th>\n",
       "      <th>toal_occurr</th>\n",
       "      <th>occurrence_rank</th>\n",
       "      <th>desc</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>4019</td>\n",
       "      <td>35.949664</td>\n",
       "      <td>12012</td>\n",
       "      <td>6742</td>\n",
       "      <td>18754.0</td>\n",
       "      <td>0</td>\n",
       "      <td>Unspecified essential hypertension</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>41401</td>\n",
       "      <td>39.410730</td>\n",
       "      <td>6889</td>\n",
       "      <td>4481</td>\n",
       "      <td>11370.0</td>\n",
       "      <td>2</td>\n",
       "      <td>Coronary atherosclerosis of native coronary ar...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>37</th>\n",
       "      <td>4280</td>\n",
       "      <td>24.439648</td>\n",
       "      <td>9102</td>\n",
       "      <td>2944</td>\n",
       "      <td>12046.0</td>\n",
       "      <td>1</td>\n",
       "      <td>Congestive heart failure, unspecified</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>5990</td>\n",
       "      <td>35.240125</td>\n",
       "      <td>3951</td>\n",
       "      <td>2150</td>\n",
       "      <td>6101.0</td>\n",
       "      <td>10</td>\n",
       "      <td>Urinary tract infection, site not specified</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>48</th>\n",
       "      <td>2724</td>\n",
       "      <td>21.970959</td>\n",
       "      <td>6556</td>\n",
       "      <td>1846</td>\n",
       "      <td>8402.0</td>\n",
       "      <td>5</td>\n",
       "      <td>Other and unspecified hyperlipidemia</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     code  % predicted vs assigned  code_occur_not_matched  \\\n",
       "14   4019                35.949664                   12012   \n",
       "8   41401                39.410730                    6889   \n",
       "37   4280                24.439648                    9102   \n",
       "15   5990                35.240125                    3951   \n",
       "48   2724                21.970959                    6556   \n",
       "\n",
       "    code_occurr_matched  toal_occurr  occurrence_rank  \\\n",
       "14                 6742      18754.0                0   \n",
       "8                  4481      11370.0                2   \n",
       "37                 2944      12046.0                1   \n",
       "15                 2150       6101.0               10   \n",
       "48                 1846       8402.0                5   \n",
       "\n",
       "                                                 desc  \n",
       "14                 Unspecified essential hypertension  \n",
       "8   Coronary atherosclerosis of native coronary ar...  \n",
       "37              Congestive heart failure, unspecified  \n",
       "15        Urinary tract infection, site not specified  \n",
       "48               Other and unspecified hyperlipidemia  "
      ]
     },
     "execution_count": 199,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "top_pred_codes.sort_values('code_occurr_matched', ascending=False).head(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "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>code</th>\n",
       "      <th>% predicted vs assigned</th>\n",
       "      <th>code_occur_not_matched</th>\n",
       "      <th>code_occurr_matched</th>\n",
       "      <th>toal_occurr</th>\n",
       "      <th>occurrence_rank</th>\n",
       "      <th>desc</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>4019</td>\n",
       "      <td>35.949664</td>\n",
       "      <td>12012</td>\n",
       "      <td>6742</td>\n",
       "      <td>18754.0</td>\n",
       "      <td>0</td>\n",
       "      <td>Unspecified essential hypertension</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>37</th>\n",
       "      <td>4280</td>\n",
       "      <td>24.439648</td>\n",
       "      <td>9102</td>\n",
       "      <td>2944</td>\n",
       "      <td>12046.0</td>\n",
       "      <td>1</td>\n",
       "      <td>Congestive heart failure, unspecified</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>41401</td>\n",
       "      <td>39.410730</td>\n",
       "      <td>6889</td>\n",
       "      <td>4481</td>\n",
       "      <td>11370.0</td>\n",
       "      <td>2</td>\n",
       "      <td>Coronary atherosclerosis of native coronary ar...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>48</th>\n",
       "      <td>2724</td>\n",
       "      <td>21.970959</td>\n",
       "      <td>6556</td>\n",
       "      <td>1846</td>\n",
       "      <td>8402.0</td>\n",
       "      <td>5</td>\n",
       "      <td>Other and unspecified hyperlipidemia</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>5990</td>\n",
       "      <td>35.240125</td>\n",
       "      <td>3951</td>\n",
       "      <td>2150</td>\n",
       "      <td>6101.0</td>\n",
       "      <td>10</td>\n",
       "      <td>Urinary tract infection, site not specified</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     code  % predicted vs assigned  code_occur_not_matched  \\\n",
       "14   4019                35.949664                   12012   \n",
       "37   4280                24.439648                    9102   \n",
       "8   41401                39.410730                    6889   \n",
       "48   2724                21.970959                    6556   \n",
       "15   5990                35.240125                    3951   \n",
       "\n",
       "    code_occurr_matched  toal_occurr  occurrence_rank  \\\n",
       "14                 6742      18754.0                0   \n",
       "37                 2944      12046.0                1   \n",
       "8                  4481      11370.0                2   \n",
       "48                 1846       8402.0                5   \n",
       "15                 2150       6101.0               10   \n",
       "\n",
       "                                                 desc  \n",
       "14                 Unspecified essential hypertension  \n",
       "37              Congestive heart failure, unspecified  \n",
       "8   Coronary atherosclerosis of native coronary ar...  \n",
       "48               Other and unspecified hyperlipidemia  \n",
       "15        Urinary tract infection, site not specified  "
      ]
     },
     "execution_count": 200,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "top_pred_codes.sort_values(by='toal_occurr', ascending=False).head(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Proportion of matched assigned codes vs number of assigned codes "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {},
   "outputs": [],
   "source": [
    "combi_index = pd.Index.union(h_counts_n_assn.index, h_counts_match.index)\n",
    "h_counts_n_assn = h_counts_n_assn.reindex(combi_index, fill_value=0) \n",
    "h_counts_match = h_counts_match.reindex(combi_index, fill_value=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_codes_per_hadm = h_counts_n_assn + h_counts_match"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {},
   "outputs": [],
   "source": [
    "distribution_correct = (round(h_counts_match / all_codes_per_hadm,2) * 100).value_counts()\n",
    "# remove occurrence where there are no matches\n",
    "distribution_correct = distribution_correct.iloc[1:]\n",
    "distribution_correct.index = [int(round(i)) for i in distribution_correct.index]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {},
   "outputs": [],
   "source": [
    "binned_distro = [(f'{bin_start}-{bin_start + 9}%', sum([0 if i not in distribution_correct else distribution_correct[i] for i in range(bin_start, bin_start+10)])) for bin_start in range(0, 110, 10)]\n",
    "binned_distro[-1] = ('100%', binned_distro[-1][1])\n",
    "binned_distro[0] = ('1-9%', binned_distro[0][1])\n",
    "acph = all_codes_per_hadm.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, (ax, ax2) = plt.subplots(1, 2, figsize=(8, 4))\n",
    "\n",
    "ax.barh(acph.index, acph.tolist())\n",
    "ax.set_xlabel('Count of Admissions', fontsize=13)\n",
    "ax.set_ylabel('# of Assigned Codes', fontsize=13)\n",
    "\n",
    "ax2.barh([b[0] for b in binned_distro], [b[1] for b in binned_distro])\n",
    "ax2.set_xlabel('Count of Admissions', fontsize=13)\n",
    "ax2.set_ylabel('Proportion of Matched Codes', fontsize=13)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig('plots/distribution_of_matched_compared_with_assigned_codes.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "100 * acph.sort_index().cumsum() / acph.sort_index().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 415,
   "metadata": {},
   "outputs": [],
   "source": [
    "m_cg = matched.code_group.value_counts().sort_index().reset_index()\n",
    "m_cg.columns = ['code_group', 'count']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 416,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0026820367076930062"
      ]
     },
     "execution_count": 416,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m_cg['prob'] = m_cg['count'] / m_cg['count'].sum()\n",
    "scipy.stats.wasserstein_distance(as_np_grouped.prob, cc.prob)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predicted and Not Assigned\n",
    "- Distribution of HADMs that showed not match??\n",
    "- \\# of matches correlateed with length of DD, and discharge summary\n",
    "- distribution of matches over codes\n",
    "- top codes that matched"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 365,
   "metadata": {},
   "outputs": [],
   "source": [
    "p_na = df_ft[df_ft.match == 'pred_no_assign']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 366,
   "metadata": {},
   "outputs": [],
   "source": [
    "p_na_counts = p_na.icd9.value_counts().reset_index()\n",
    "p_na_counts.columns = ['code', 'count']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 367,
   "metadata": {},
   "outputs": [],
   "source": [
    "p_na_hadms = p_na.hadm.value_counts().reset_index()\n",
    "p_na_hadms.columns = ['hadm', 'count']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 368,
   "metadata": {},
   "outputs": [],
   "source": [
    "dds = pd.read_csv('data/mimic_dd_icd9_sections.csv')\n",
    "# print(dds[dds.name = 'Admission ID:173881'].text.iloc[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 369,
   "metadata": {},
   "outputs": [],
   "source": [
    "dds['len'] = dds.text.str.split('\\n').apply(lambda l: len([i for i in l if len(i) > 1]))\n",
    "dds['hadm'] = dds.name.str.split(':').apply(lambda l: l[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 370,
   "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>hadm</th>\n",
       "      <th>count</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>184752</td>\n",
       "      <td>16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>148024</td>\n",
       "      <td>15</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>173881</td>\n",
       "      <td>15</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     hadm  count\n",
       "0  184752     16\n",
       "1  148024     15\n",
       "2  173881     15"
      ]
     },
     "execution_count": 370,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p_na_hadms.head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 371,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0                         hadm  count\n",
       "4675  100001      3\n",
       "1                        hadm  count\n",
       "16906  100003      1\n",
       "2                         hadm  count\n",
       "7800  100006      2\n",
       "3        Empty DataFrame\n",
       "Columns: [hadm, count]\n",
       "Index: []\n",
       "4                         hadm  count\n",
       "3822  100009      3\n",
       "                               ...                       \n",
       "48893                     hadm  count\n",
       "7633  199993      2\n",
       "48894                     hadm  count\n",
       "8355  199994      2\n",
       "48895    Empty DataFrame\n",
       "Columns: [hadm, count]\n",
       "Index: []\n",
       "48896    Empty DataFrame\n",
       "Columns: [hadm, count]\n",
       "Index: []\n",
       "48897    Empty DataFrame\n",
       "Columns: [hadm, count]\n",
       "Index: []\n",
       "Name: hadm, Length: 48898, dtype: object"
      ]
     },
     "execution_count": 371,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dds.hadm.apply(lambda i: p_na_hadms[p_na_hadms.hadm == i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 372,
   "metadata": {},
   "outputs": [],
   "source": [
    "dds = dds.drop('name', axis=1)\n",
    "dds.columns = ['text', 'dd_line_len', 'hadm']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 373,
   "metadata": {},
   "outputs": [],
   "source": [
    "dds = dds.merge(p_na_hadms, on='hadm').sort_values('count', ascending=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 374,
   "metadata": {},
   "outputs": [],
   "source": [
    "top400_codes = set(df_ft.icd9.unique())\n",
    "codes = codes[codes.icd9_code.isin(top400_codes)]\n",
    "codes = codes.hadm_id.value_counts().reset_index()\n",
    "codes.columns = ['hadm', 'assign_code_count']\n",
    "codes['hadm'] = codes.hadm.apply(str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 375,
   "metadata": {},
   "outputs": [],
   "source": [
    "dds = dds.merge(codes, on='hadm')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 376,
   "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>text</th>\n",
       "      <th>dd_line_len</th>\n",
       "      <th>hadm</th>\n",
       "      <th>count</th>\n",
       "      <th>assign_code_count</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>\\n1.  Morbid obesity.\\n2.  Asthma.\\n3.  Chroni...</td>\n",
       "      <td>20</td>\n",
       "      <td>184752</td>\n",
       "      <td>16</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>\\n1.  Dysphagia.\\n2.  Prerenal acute renal fai...</td>\n",
       "      <td>17</td>\n",
       "      <td>148024</td>\n",
       "      <td>15</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>\\nendometriosis\\nmastoiditis\\nhypothyroidism\\n...</td>\n",
       "      <td>35</td>\n",
       "      <td>196904</td>\n",
       "      <td>15</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>\\nHypoxic respiratory failure.\\nProlonged wean...</td>\n",
       "      <td>19</td>\n",
       "      <td>173881</td>\n",
       "      <td>15</td>\n",
       "      <td>13</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>\\nCoronary artery disease.\\nCoronary stent thr...</td>\n",
       "      <td>29</td>\n",
       "      <td>129259</td>\n",
       "      <td>14</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                text  dd_line_len    hadm  \\\n",
       "0  \\n1.  Morbid obesity.\\n2.  Asthma.\\n3.  Chroni...           20  184752   \n",
       "1  \\n1.  Dysphagia.\\n2.  Prerenal acute renal fai...           17  148024   \n",
       "2  \\nendometriosis\\nmastoiditis\\nhypothyroidism\\n...           35  196904   \n",
       "3  \\nHypoxic respiratory failure.\\nProlonged wean...           19  173881   \n",
       "4  \\nCoronary artery disease.\\nCoronary stent thr...           29  129259   \n",
       "\n",
       "   count  assign_code_count  \n",
       "0     16                  8  \n",
       "1     15                  8  \n",
       "2     15                 10  \n",
       "3     15                 13  \n",
       "4     14                  6  "
      ]
     },
     "execution_count": 376,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dds.head(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Stronger positive correlation with our prediction model. Suggesting those notes that have longer discharge diagnosis sections, i.e. those cases that are more complex are missing a fair amount of codes.\n",
    "\n",
    "This makes sense as a Coder generally has a fixed amount of episodes to code, the more complex the episode the more likely something will be missed. Comment on time pressured environment etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 377,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.        , 0.50441746],\n",
       "       [0.50441746, 1.        ]])"
      ]
     },
     "execution_count": 377,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.corrcoef(dds.dd_line_len,  dds['count'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 378,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.        , 0.17173518],\n",
       "       [0.17173518, 1.        ]])"
      ]
     },
     "execution_count": 378,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.corrcoef(dds.dd_line_len, dds.assign_code_count,)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 379,
   "metadata": {},
   "outputs": [],
   "source": [
    "p_na_counts['code_groups'] = p_na_counts.code.apply(lambda c: str(find_root_axis(search(c))).split(':')[0])\n",
    "p_na_plt = p_na_counts.loc[:, ['code_groups', 'count']].groupby('code_groups').sum().sort_index()\n",
    "codes = pd.read_csv('data/admission_codes.csv')\n",
    "codes = codes[codes.icd9_code.isin(top400_codes)]\n",
    "codes['code_groups'] = codes.icd9_code.apply(lambda c: str(find_root_axis(search(c))).split(':')[0])\n",
    "code_counts = codes.code_groups.value_counts()\n",
    "code_counts = code_counts.sort_index()\n",
    "p_na_plt = p_na_plt.reindex(code_counts.index).fillna(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p_na_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(8, 6))\n",
    "indices = range(len(p_na_plt['count'].tolist()))\n",
    "width = np.min(np.diff(indices))/3\n",
    "\n",
    "ax2 = ax.twiny()\n",
    "\n",
    "color_1 = 'tab:blue'\n",
    "color_2 = 'tab:orange'\n",
    "\n",
    "bar1 = ax.barh(indices + width / 2, p_na_plt['count'].tolist(), width, label='Predicted, Not Assigned', color=color_1)\n",
    "ax.set_yticks(indices)\n",
    "ax.set_yticklabels(p_na_plt.index.tolist())\n",
    "ax.set_ylabel('Top Level ICD-9 Code Axis', fontsize=12)\n",
    "ax.set_xlabel('# of Predictions, Not Assigned', color=color_1, fontsize=12)\n",
    "\n",
    "bar2 = bar2 = ax2.barh(indices - width / 2, code_counts.tolist(), width, label='Assigned Codes MIMIC-III', color=color_2)\n",
    "ax2.set_xlabel('# of assigned codes', color=color_2, fontsize=14)\n",
    "\n",
    "plt.legend([bar1, bar2], [bar1.get_label(), bar2.get_label()], fontsize=12)\n",
    "plt.tight_layout()\n",
    "plt.savefig('./plots/distribution_predicted_not_assigned.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 251,
   "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>index</th>\n",
       "      <th>icd9_code</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0389</td>\n",
       "      <td>3725</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>00845</td>\n",
       "      <td>1444</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>07054</td>\n",
       "      <td>1218</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>04111</td>\n",
       "      <td>703</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>07070</td>\n",
       "      <td>674</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>1120</td>\n",
       "      <td>646</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>04104</td>\n",
       "      <td>614</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>042</td>\n",
       "      <td>538</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>03811</td>\n",
       "      <td>515</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>0413</td>\n",
       "      <td>473</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   index  icd9_code\n",
       "0   0389       3725\n",
       "1  00845       1444\n",
       "2  07054       1218\n",
       "3  04111        703\n",
       "4  07070        674\n",
       "5   1120        646\n",
       "6  04104        614\n",
       "7    042        538\n",
       "8  03811        515\n",
       "9   0413        473"
      ]
     },
     "execution_count": 251,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "codes[codes.code_groups == '001-139'].icd9_code.value_counts().reset_index().head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "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>count</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>code</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0389</th>\n",
       "      <td>3343</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>07070</th>\n",
       "      <td>420</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0380</th>\n",
       "      <td>22</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>042</th>\n",
       "      <td>17</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1120</th>\n",
       "      <td>16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>07054</th>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>03811</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>07032</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       count\n",
       "code        \n",
       "0389    3343\n",
       "07070    420\n",
       "0380      22\n",
       "042       17\n",
       "1120      16\n",
       "07054      8\n",
       "03811      1\n",
       "07032      1"
      ]
     },
     "execution_count": 252,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p_na_counts[p_na_counts.code_groups == '001-139'].loc[:, ['code', 'count']].groupby('code').sum().sort_values('count', ascending=False).head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.01587788292311377"
      ]
     },
     "execution_count": 253,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p_na_plt['prob'] = p_na_plt['count'] / p_na_plt['count'].sum()\n",
    "cc = code_counts.reset_index()\n",
    "cc.columns = ['code_groups', 'count']\n",
    "cc['prob'] = cc['count'] / cc['count'].sum()\n",
    "scipy.stats.wasserstein_distance(p_na_plt.prob, cc.prob)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "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>code</th>\n",
       "      <th>count</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>4019</td>\n",
       "      <td>3470</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4011</td>\n",
       "      <td>3470</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0389</td>\n",
       "      <td>3343</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>99591</td>\n",
       "      <td>3343</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5789</td>\n",
       "      <td>1969</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>5859</td>\n",
       "      <td>1886</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>2859</td>\n",
       "      <td>1880</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>496</td>\n",
       "      <td>1183</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>49320</td>\n",
       "      <td>1183</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>4589</td>\n",
       "      <td>1034</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    code  count\n",
       "0   4019   3470\n",
       "1   4011   3470\n",
       "2   0389   3343\n",
       "3  99591   3343\n",
       "4   5789   1969\n",
       "5   5859   1886\n",
       "6   2859   1880\n",
       "7    496   1183\n",
       "8  49320   1183\n",
       "9   4589   1034"
      ]
     },
     "execution_count": 254,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p_na_counts.loc[:, ['code', 'count']].head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "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>code</th>\n",
       "      <th>count</th>\n",
       "      <th>code_groups</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>4019</td>\n",
       "      <td>3470</td>\n",
       "      <td>390-459</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4011</td>\n",
       "      <td>3470</td>\n",
       "      <td>390-459</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   code  count code_groups\n",
       "0  4019   3470     390-459\n",
       "1  4011   3470     390-459"
      ]
     },
     "execution_count": 255,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p_na_counts.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_prop(row):\n",
    "    preds = p_na_counts[p_na_counts.code == row.code]\n",
    "    if preds.shape[0] == 0:\n",
    "        return 0\n",
    "    return preds.iloc[0]['count'] / code_counts[code_counts.code == row.code]['count'].iloc[0] * 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "code_counts = codes.icd9_code.value_counts().reset_index()\n",
    "code_counts.columns = ['code', 'count']\n",
    "code_counts['% missed'] = code_counts.apply(compute_prop, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "code_counts.head(15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p_na"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "code_counts.code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "codes.icd9_code.value_counts()['4019']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p_na_counts['code']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Assigned & and Not Predicted"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [],
   "source": [
    "as_np = df_ft[df_ft.match == 'assigned_no_pred']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-220-779d9059510f>:1: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  as_np['code_groups'] = as_np.icd9.apply(lambda c: str(find_root_axis(search(c))).split(':')[0])\n"
     ]
    }
   ],
   "source": [
    "as_np['code_groups'] = as_np.icd9.apply(lambda c: str(find_root_axis(search(c))).split(':')[0])\n",
    "as_np_grouped = as_np.code_groups.value_counts().sort_index().reset_index()\n",
    "as_np_grouped.columns = ['code_groups', 'count']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(figsize=(8, 6))\n",
    "indices = range(len(as_np_grouped['count'].tolist()))\n",
    "width = np.min(np.diff(indices))/3\n",
    "\n",
    "ax2 = ax.twiny()\n",
    "\n",
    "color_1 = 'tab:blue'\n",
    "color_2 = 'tab:orange'\n",
    "\n",
    "bar1 = ax.barh(indices + width / 2, as_np_grouped['count'].tolist(), width, label='Assigned, Not Predicted', color=color_1)\n",
    "ax.set_yticks(indices)\n",
    "ax.set_yticklabels(as_np_grouped.code_groups.tolist())\n",
    "ax.set_ylabel('Top Level ICD-9 Code Axis', fontsize=12)\n",
    "ax.set_xlabel('# of Assigned, Not Predicted', color=color_1, fontsize=12)\n",
    "\n",
    "bar2 = bar2 = ax2.barh(indices - width / 2, code_counts.tolist(), width, label='Assigned Codes MIMIC-III', color=color_2)\n",
    "ax2.set_xlabel('# of assigned codes', color=color_2, fontsize=14)\n",
    "\n",
    "plt.legend([bar1, bar2], [bar1.get_label(), bar2.get_label()], fontsize=12)\n",
    "plt.tight_layout()\n",
    "plt.savefig('./plots/dsitribution_assigned_and_not_predicted.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4019     12012\n",
       "42731    11840\n",
       "4280      9102\n",
       "25000     8293\n",
       "41401     6889\n",
       "         ...  \n",
       "340        163\n",
       "V293       140\n",
       "1550       138\n",
       "7661       127\n",
       "7470       110\n",
       "Name: icd9, Length: 400, dtype: int64"
      ]
     },
     "execution_count": 225,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "as_np.icd9.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 420,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0026820367076930062"
      ]
     },
     "execution_count": 420,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "as_np_grouped['prob'] = as_np_grouped['count'] / as_np_grouped['count'].sum()\n",
    "cc = code_counts.reset_index()\n",
    "cc.columns = ['code_groups', 'count']\n",
    "cc['prob'] = cc['count'] / cc['count'].sum()\n",
    "scipy.stats.wasserstein_distance(as_np_grouped.prob, cc.prob)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Overall\n",
    "- Silver Standard Clinical Coding Generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 324,
   "metadata": {},
   "outputs": [],
   "source": [
    "p_na_d = []\n",
    "assn_codes_val_counts = df_ft[(df_ft.match == 'assigned_no_pred') | (df_ft.match == 'match')].icd9.value_counts()\n",
    "for g, df in p_na.groupby(['hadm', 'start']):\n",
    "    if df.shape[0] == 2:\n",
    "        code1_count = assn_codes_val_counts[df.icd9.iloc[0]]\n",
    "        code2_count = assn_codes_val_counts[df.icd9.iloc[1]]\n",
    "        if code1_count > code2_count:\n",
    "            p_na_d.append(pd.DataFrame(df.iloc[0, :]).T)\n",
    "        else:\n",
    "            p_na_d.append(pd.DataFrame(df.iloc[1, :]).T)\n",
    "    else:\n",
    "        p_na_d.append(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 326,
   "metadata": {},
   "outputs": [],
   "source": [
    "p_na_d = pd.concat(p_na_d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 335,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "assigned_no_pred    389933\n",
       "pred_no_assign       48248\n",
       "match                46563\n",
       "Name: match, dtype: int64"
      ]
     },
     "execution_count": 335,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_ft.match.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 359,
   "metadata": {},
   "outputs": [],
   "source": [
    "matches = df_ft[df_ft.match == 'match'].loc[:, ['hadm', 'icd9']]\n",
    "new_preds = p_na_d.loc[:, ['hadm', 'icd9']]\n",
    "assn_no_pred = df_ft[df_ft.match == 'assigned_no_pred'].loc[:, ['hadm', 'icd9']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 360,
   "metadata": {},
   "outputs": [],
   "source": [
    "matches['validated'] = 'yes' \n",
    "new_preds['validated'] = 'new_code'\n",
    "assn_no_pred['validated'] = 'no'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 395,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.concat([matches, new_preds, assn_no_pred]).reset_index(drop=True).to_csv('MIMIC-III_Clinical_Codes_Silver_Standard.csv', index=False)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:mimc3_dd]",
   "language": "python",
   "name": "conda-env-mimc3_dd-py"
  },
  "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}