Email Classification V2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import preprocessing\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import os\n",
    "# Load required libraries\n",
    "import matplotlib.pyplot as plt\n",
    "import time\n",
    "import pickle\n",
    "import seaborn as sns\n",
    "import sys\n",
    "sys.setrecursionlimit(1500)\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "NEWLINE = '\\n'\n",
    "\n",
    "HAM = 'ham'\n",
    "SPAM = 'spam'\n",
    "\n",
    "SOURCES = [\n",
    "    ('dataSets/nw/ham',      HAM),\n",
    "    ('dataSets/nw/spam',     SPAM)\n",
    "]\n",
    "\n",
    "SKIP_FILES = {'cmds'}\n",
    "\n",
    "\n",
    "def read_files(path):\n",
    "    '''\n",
    "    Generator of pairs (filename, filecontent)\n",
    "    for all files below path whose name is not in SKIP_FILES.\n",
    "    The content of the file is of the form:\n",
    "        header....\n",
    "        <emptyline>\n",
    "        body...\n",
    "    This skips the headers and returns body only.\n",
    "    '''\n",
    "    for root, dir_names, file_names in os.walk(path):\n",
    "        for path in dir_names:\n",
    "            read_files(os.path.join(root, path))\n",
    "        for file_name in file_names:\n",
    "            if file_name not in SKIP_FILES:\n",
    "                file_path = os.path.join(root, file_name)\n",
    "                if os.path.isfile(file_path):\n",
    "                    past_header, lines = True, []\n",
    "                    f = open(file_path, encoding=\"latin-1\")\n",
    "                    for line in f:\n",
    "                        if past_header:\n",
    "                            lines.append(line)\n",
    "                        elif line == NEWLINE:\n",
    "                            past_header = True\n",
    "                    f.close()\n",
    "                    content = NEWLINE.join(lines)\n",
    "                    yield file_path, content\n",
    "\n",
    "\n",
    "def build_data_frame(l, path, classification):\n",
    "    rows = []\n",
    "    index = []\n",
    "    for i, (file_name, text) in enumerate(read_files(path)):\n",
    "        rows.append({'text': text, 'class': classification})\n",
    "        index.append(file_name)\n",
    "   \n",
    "    data_frame = pd.DataFrame(rows, index=index)\n",
    "    return data_frame, len(rows)\n",
    "\n",
    "def load_data():\n",
    "    data = pd.DataFrame({'text': [], 'class': []})\n",
    "    l = 0\n",
    "    for path, classification in SOURCES:\n",
    "        data_frame, nrows = build_data_frame(l, path, classification)\n",
    "        data = data.append(data_frame)\n",
    "        l += nrows\n",
    "    data = data.reindex(np.random.permutation(data.index))\n",
    "    return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We will load the Email spam dataset into Panadas dataframe here . \n",
    "data=load_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7495\n",
      "                                                   text class\n",
      "0     Subject: 8 th noms\\n\\n- - - - - - - - - - - - ...   ham\n",
      "1     Subject: save your money by getting an oem sof...  spam\n",
      "2     Subject: visual identity and logo now\\n\\nworki...  spam\n",
      "3     Subject: financial freedom\\n\\ndear friend ,\\n\\...  spam\n",
      "4     Subject: re : sales to panenergy at exxon clea...   ham\n",
      "...                                                 ...   ...\n",
      "7490  Subject: fre @ backgammon\\n\\nisrael approved p...  spam\n",
      "7491  Subject: gmt . inc .\\n\\ntom ,\\n\\nplease create...   ham\n",
      "7492  Subject: seagate 20 / 40 gb dat tape drive ( i...  spam\n",
      "7493                                        Subject: \\n  spam\n",
      "7494  Subject: re : executive program on credit risk...   ham\n",
      "\n",
      "[7495 rows x 2 columns]\n"
     ]
    }
   ],
   "source": [
    "data = data.sample(frac=1).reset_index(drop=True)\n",
    "print(len(data))\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = lambda x: ' '.join([item for item in x.split() if item not in [\"Subject\",\"Subject:\",\"subject\"]])\n",
    "data[\"text\"] = data[\"text\"].apply(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We change the dataframe index from filenames to indices here. \n",
    "new_index=[x for x in range(len(data))]\n",
    "data.index=new_index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                                   text class\n",
      "0     8 th noms - - - - - - - - - - - - - - - - - - ...   ham\n",
      "1     save your money by getting an oem software ! n...  spam\n",
      "2     visual identity and logo now working on your c...  spam\n",
      "3     financial freedom dear friend , how would you ...  spam\n",
      "4     re : sales to panenergy at exxon clear lake fo...   ham\n",
      "...                                                 ...   ...\n",
      "7490  fre @ backgammon israel approved plans this we...  spam\n",
      "7491  gmt . inc . tom , please create a spot ticket ...   ham\n",
      "7492  seagate 20 / 40 gb dat tape drive ( internal )...  spam\n",
      "7493                                                     spam\n",
      "7494  re : executive program on credit risk vince , ...   ham\n",
      "\n",
      "[7495 rows x 2 columns]\n"
     ]
    }
   ],
   "source": [
    "print(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We will load the Email spam dataset into Panadas dataframe here . \n",
    "SOURCES = [\n",
    "    ('dataSets/nw/testSet',      HAM)\n",
    "]\n",
    "test_data=load_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from nltk.corpus import stopwords\n",
    "stop = stopwords.words('english')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#We will add two more columns to our dataframe for tokenized text and token count.\n",
    "def token_count(row):\n",
    "    'returns token count'\n",
    "    text=row['tokenized_text']\n",
    "    length=len(text.split())\n",
    "    return length\n",
    "\n",
    "def tokenize(row):\n",
    "    \"tokenize the text using default space tokenizer\"\n",
    "    text=row['text']\n",
    "    lines=(line for line in text.split(NEWLINE) )\n",
    "    tokenized=\"\"\n",
    "    for sentence in lines:\n",
    "        tokenized+= \" \".join(tok for tok in sentence.split())\n",
    "    return tokenized"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "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>class</th>\n",
       "      <th>tokenized_text</th>\n",
       "      <th>token_count</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>8 th noms - - - - - - - - - - - - - - - - - - ...</td>\n",
       "      <td>ham</td>\n",
       "      <td>8 th noms - - - - - - - - - - - - - - - - - - ...</td>\n",
       "      <td>120</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>save your money by getting an oem software ! n...</td>\n",
       "      <td>spam</td>\n",
       "      <td>save your money by getting an oem software ! n...</td>\n",
       "      <td>34</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>visual identity and logo now working on your c...</td>\n",
       "      <td>spam</td>\n",
       "      <td>visual identity and logo now working on your c...</td>\n",
       "      <td>208</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>financial freedom dear friend , how would you ...</td>\n",
       "      <td>spam</td>\n",
       "      <td>financial freedom dear friend , how would you ...</td>\n",
       "      <td>187</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>re : sales to panenergy at exxon clear lake fo...</td>\n",
       "      <td>ham</td>\n",
       "      <td>re : sales to panenergy at exxon clear lake fo...</td>\n",
       "      <td>1375</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                text class  \\\n",
       "0  8 th noms - - - - - - - - - - - - - - - - - - ...   ham   \n",
       "1  save your money by getting an oem software ! n...  spam   \n",
       "2  visual identity and logo now working on your c...  spam   \n",
       "3  financial freedom dear friend , how would you ...  spam   \n",
       "4  re : sales to panenergy at exxon clear lake fo...   ham   \n",
       "\n",
       "                                      tokenized_text  token_count  \n",
       "0  8 th noms - - - - - - - - - - - - - - - - - - ...          120  \n",
       "1  save your money by getting an oem software ! n...           34  \n",
       "2  visual identity and logo now working on your c...          208  \n",
       "3  financial freedom dear friend , how would you ...          187  \n",
       "4  re : sales to panenergy at exxon clear lake fo...         1375  "
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#We will use apply functions on dataframe to add the columns for :\n",
    "\n",
    "#* Tokenized text\n",
    "#* Token Count\n",
    "#* Language\n",
    "#Language column in this case is not necessary as we only have english text. However this approach \n",
    "# is good for properly dealing with multi lingual data.\n",
    "\n",
    "\n",
    "\n",
    "data['tokenized_text']=data.apply(tokenize, axis=1)\n",
    "data['token_count']=data.apply(token_count, axis=1)\n",
    "# Checking the data\n",
    "data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "data['tokenized_text'] = data['tokenized_text'].apply(lambda x: ' '.join([word for word in x.split() if word not in (stop)]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "from nltk.stem import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "from nltk.stem.porter import *\n",
    "stemmer = PorterStemmer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "data['tokenized_text'] = data['tokenized_text'].apply(lambda x: ' '.join([stemmer.stem(word) for word in x.split()]))"
   ]
  },
  {
   "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>text</th>\n",
       "      <th>class</th>\n",
       "      <th>tokenized_text</th>\n",
       "      <th>token_count</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>8 th noms - - - - - - - - - - - - - - - - - - ...</td>\n",
       "      <td>ham</td>\n",
       "      <td>8 th nom - - - - - - - - - - - - - - - - - - -...</td>\n",
       "      <td>120</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>save your money by getting an oem software ! n...</td>\n",
       "      <td>spam</td>\n",
       "      <td>save money get oem softwar ! need softwar pc ?...</td>\n",
       "      <td>34</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>visual identity and logo now working on your c...</td>\n",
       "      <td>spam</td>\n",
       "      <td>visual ident logo work compani ' imag ? start ...</td>\n",
       "      <td>208</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>financial freedom dear friend , how would you ...</td>\n",
       "      <td>spam</td>\n",
       "      <td>financi freedom dear friend , would like make ...</td>\n",
       "      <td>187</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>re : sales to panenergy at exxon clear lake fo...</td>\n",
       "      <td>ham</td>\n",
       "      <td>: sale panenergi exxon clear lake 2 / 99 anita...</td>\n",
       "      <td>1375</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                text class  \\\n",
       "0  8 th noms - - - - - - - - - - - - - - - - - - ...   ham   \n",
       "1  save your money by getting an oem software ! n...  spam   \n",
       "2  visual identity and logo now working on your c...  spam   \n",
       "3  financial freedom dear friend , how would you ...  spam   \n",
       "4  re : sales to panenergy at exxon clear lake fo...   ham   \n",
       "\n",
       "                                      tokenized_text  token_count  \n",
       "0  8 th nom - - - - - - - - - - - - - - - - - - -...          120  \n",
       "1  save money get oem softwar ! need softwar pc ?...           34  \n",
       "2  visual ident logo work compani ' imag ? start ...          208  \n",
       "3  financi freedom dear friend , would like make ...          187  \n",
       "4  : sale panenergi exxon clear lake 2 / 99 anita...         1375  "
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "import nltk\n",
    "# nltk.download('wordnet')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "from nltk.stem.wordnet import WordNetLemmatizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "lemmatizer = WordNetLemmatizer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "data['tokenized_text'] = data['tokenized_text'].apply(lambda x: \" \".join([lemmatizer.lemmatize(word) for word in x.split()]))\n",
    "# test_data['tokenized_text'] = test_data['tokenized_text'].apply(lambda x: \" \".join([lemmatizer.lemmatize(word) for word in x.split()]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "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>class</th>\n",
       "      <th>tokenized_text</th>\n",
       "      <th>token_count</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>8 th noms - - - - - - - - - - - - - - - - - - ...</td>\n",
       "      <td>ham</td>\n",
       "      <td>8 th nom - - - - - - - - - - - - - - - - - - -...</td>\n",
       "      <td>120</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>save your money by getting an oem software ! n...</td>\n",
       "      <td>spam</td>\n",
       "      <td>save money get oem softwar ! need softwar pc ?...</td>\n",
       "      <td>34</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>visual identity and logo now working on your c...</td>\n",
       "      <td>spam</td>\n",
       "      <td>visual ident logo work compani ' imag ? start ...</td>\n",
       "      <td>208</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>financial freedom dear friend , how would you ...</td>\n",
       "      <td>spam</td>\n",
       "      <td>financi freedom dear friend , would like make ...</td>\n",
       "      <td>187</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>re : sales to panenergy at exxon clear lake fo...</td>\n",
       "      <td>ham</td>\n",
       "      <td>: sale panenergi exxon clear lake 2 / 99 anita...</td>\n",
       "      <td>1375</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                text class  \\\n",
       "0  8 th noms - - - - - - - - - - - - - - - - - - ...   ham   \n",
       "1  save your money by getting an oem software ! n...  spam   \n",
       "2  visual identity and logo now working on your c...  spam   \n",
       "3  financial freedom dear friend , how would you ...  spam   \n",
       "4  re : sales to panenergy at exxon clear lake fo...   ham   \n",
       "\n",
       "                                      tokenized_text  token_count  \n",
       "0  8 th nom - - - - - - - - - - - - - - - - - - -...          120  \n",
       "1  save money get oem softwar ! need softwar pc ?...           34  \n",
       "2  visual ident logo work compani ' imag ? start ...          208  \n",
       "3  financi freedom dear friend , would like make ...          187  \n",
       "4  : sale panenergi exxon clear lake 2 / 99 anita...         1375  "
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total emails :  7495\n",
      "total spam emails :  4499\n",
      "total normal emails :  2996\n"
     ]
    }
   ],
   "source": [
    "# Lets look at some information related to the data\n",
    "df=data\n",
    "print(\"total emails : \", len(df))\n",
    "print  (\"total spam emails : \", len(df[df['class']=='spam']) )\n",
    "print  (\"total normal emails : \", len(df[df['class']=='ham']) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Plot of Emails count with languages and email type')"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "data['lang']='en'\n",
    "df1 = df.groupby(['lang','class'])['class','lang'].size().unstack()\n",
    "\n",
    "ax=df1.plot(kind='bar')\n",
    "ax.set_ylabel(\"Total Emails\")\n",
    "ax.set_xlabel(\"Language\")\n",
    "ax.set_title(\"Plot of Emails count with languages and email type\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We randomize the rows to subset the dataframe\n",
    "df.reset_index(inplace=True)\n",
    "df=df.reindex(np.random.permutation(df.index))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "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>text</th>\n",
       "      <th>class</th>\n",
       "      <th>tokenized_text</th>\n",
       "      <th>token_count</th>\n",
       "      <th>lang</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>395</td>\n",
       "      <td>395</td>\n",
       "      <td>aggressive investors and traders shouid be wat...</td>\n",
       "      <td>spam</td>\n",
       "      <td>aggress investor trader shouid watch \" stock w...</td>\n",
       "      <td>620</td>\n",
       "      <td>en</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>391</td>\n",
       "      <td>391</td>\n",
       "      <td>off - site : john griebling ' s organization a...</td>\n",
       "      <td>ham</td>\n",
       "      <td>- site : john griebl ' organ research group je...</td>\n",
       "      <td>254</td>\n",
       "      <td>en</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>647</td>\n",
       "      <td>647</td>\n",
       "      <td>to valentin ' s shop customers ! dear customer...</td>\n",
       "      <td>spam</td>\n",
       "      <td>valentin ' shop custom ! dear custom ! updat s...</td>\n",
       "      <td>49</td>\n",
       "      <td>en</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1783</td>\n",
       "      <td>1783</td>\n",
       "      <td>3 / 4 / 2000 and following noms hpl can ' t ta...</td>\n",
       "      <td>ham</td>\n",
       "      <td>3 / 4 / 2000 follow nom hpl ' take extra 15 mm...</td>\n",
       "      <td>303</td>\n",
       "      <td>en</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>5358</td>\n",
       "      <td>5358</td>\n",
       "      <td>purchase of license for software hello all ! p...</td>\n",
       "      <td>ham</td>\n",
       "      <td>purchas licens softwar hello ! plea order visu...</td>\n",
       "      <td>98</td>\n",
       "      <td>en</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      index                                               text class  \\\n",
       "395     395  aggressive investors and traders shouid be wat...  spam   \n",
       "391     391  off - site : john griebling ' s organization a...   ham   \n",
       "647     647  to valentin ' s shop customers ! dear customer...  spam   \n",
       "1783   1783  3 / 4 / 2000 and following noms hpl can ' t ta...   ham   \n",
       "5358   5358  purchase of license for software hello all ! p...   ham   \n",
       "\n",
       "                                         tokenized_text  token_count lang  \n",
       "395   aggress investor trader shouid watch \" stock w...          620   en  \n",
       "391   - site : john griebl ' organ research group je...          254   en  \n",
       "647   valentin ' shop custom ! dear custom ! updat s...           49   en  \n",
       "1783  3 / 4 / 2000 follow nom hpl ' take extra 15 mm...          303   en  \n",
       "5358  purchas licens softwar hello ! plea order visu...           98   en  "
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total emails for unseen test data :  1000\n",
      "\t total spam emails for enron  :  601\n",
      "\t total normal emails for enron  :  399\n",
      "\n",
      "total emails for model training/validation :  6495\n",
      "\t total spam emails for enron  :  3898\n",
      "\t total normal emails for enron  :  2597\n"
     ]
    }
   ],
   "source": [
    "len_unseen = 1000\n",
    "df_unseen_test= df.iloc[:len_unseen]\n",
    "df_model = df.iloc[len_unseen:]\n",
    "\n",
    "print('total emails for unseen test data : ', len(df_unseen_test))\n",
    "print('\\t total spam emails for enron  : ', len(df_unseen_test[(df_unseen_test['lang']=='en') & (df_unseen_test['class']=='spam')]))\n",
    "print('\\t total normal emails for enron  : ', len(df_unseen_test[(df_unseen_test['lang']=='en') & (df_unseen_test['class']=='ham')]))\n",
    "print()\n",
    "\n",
    "print('total emails for model training/validation : ', len(df_model))\n",
    "print('\\t total spam emails for enron  : ', len(df_model[(df_model['lang']=='en') & (df_model['class']=='spam')]))\n",
    "print('\\t total normal emails for enron  : ', len(df_model[(df_model['lang']=='en') & (df_model['class']=='ham')]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Token length Vs Frequency for Enron Spam Emails')"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtsAAAGZCAYAAABYCP1SAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdeZxsVXnv/89XQAaZ5YgIHA8a0IAD4gnROGHUiJII5kbFGMVcDTHROCT3RlATTW5IjonG4WckwSHiiDiCwQlJRE1EPCgyIygIR6YTFEElKPD8/tirpWh6qO6u3V19+vN+vfard62991Orhn766V1rr0pVIUmSJGn07rbUHZAkSZI2VRbbkiRJUk8stiVJkqSeWGxLkiRJPbHYliRJknpisS1JkiT1ZEUX20kOTnLpItzPi5J8oe/7mea+T0jymqW4b3WS7J7kv5LclOSYpe7PSpbkgUluHYN+7JPkhoHbZyT5vaXs03JlHtdiMI+vLEn+Ksnb2vqC/24s+2I7yY8HltuT3Dxw+zlL3b/FtJA/Bkm2bc/Zr02x7dgk759jvBOS3DLp9TlsPn3bBPwxcHlVbVdVr15osPY63zrpuf1xknuOoK8L7du6JJXktwbatm1t917Kvg0jyTVJfjrpeX3jqO+nqr5dVTuOOu5yZR6/g3l8bK2kPH7PJO9Ncm2SG5NclOQVY9Cvg1t+mPycPWzU91VVr62ql4wq3uajCrRUqmrbifUklwMvrKolOfuwnFXVj5N8DHge8F8T7UnuDjwTOHweYf9fVf3NTDsk2byqlvxMY8/uC1wwnwNneH6+WFVPXFi3env+fwD8vyT/Vgv81qwlen/8RlV9ZZHvc0Uzj4+GebxXKymPvw24FdgHuAl4IPCAEcZfiO9W1S8tdSfmatmf2Z5Nkq2T/FOSq5NsSPIPSbaYZt//m+SciTNwSZ7ebt+Q5MtJ9h3Y95okr0hyXpIfJflAS2jD9OlBSf49yQ+TXDh4pqCdSXhzks+l+7jqP5Pcd2D7IUkuaX16c9rHz+0/uzcDB7X/9K4ZuMtdpos3yfHAM5NsOdD2m8DNwGnt/v+iPZc3tr4/ZpjHPOnxX5Pk/yQ5H7ixte2Z5KQk/53ku0leNLD/Pdrze0OSc5McnfaxcZKt2lnTPSY9h68ZuD3v1zHJM9qxN7bn/QlJnpvkPyc9plcnOWGKx/oh4FnAX7TX5TEzvSfbf+6Xtuf5WuDYeT6/Uz6m6eIneXGS7yS5PsnHk+w66fn9g7b9h0neNEsXTga2pPvjPlX/dk7ywSQbk1yW5M+TpG17Ufvd+KckPwSOGmh7W3s8lyRZm+TIJN9Pd/bl8IH4T0/yrfaafS/Jq+b6HE7T75H1IzN8LNm2faXdx8Yk7x1F/5ezmX5nptjXPG4eN48vLI//CvCBqvpRVd1eVRdU1ScmxXpJksvT5ahjkl/k8Acm+WKSH7RtxyfZbtLj+tMk57fn8tgkuyU5tb0+n02y/Vyfrxb7jCSvS3Jmi/3xdGfpT2yxz5j0Hju2vXY3tmMeMbBtXZJ3TnM/f9Ae+03tff6MWTtXVZvMAlwOPHFS298DXwZ2AXYFvg68um07GLi0rR8DfA3Yud1+BHA18HBgM+BI4NvA5m37NcB/tpirgEuB50/TrxcBX2jr27e4z2lxf4XuTOAvte0nANcBBwBbAB8F3tO23Rv4MV3i3AL4c+DnwO9Nvp+B+5423hT9DPA94HcG2j4BrGvrDwW+2x5zgPsBe00T6wTgNdNsu6a9DvcBtm7Pw7nAK4G70/03fQXwuLb/m+n+SOwI7AVcPPC6bQUUsMdU972Q1xF4DPBD4PF0/5iubn27B90fl/sN3OcFwCHDPBfM/p68Ffjr9lxsPdP7aYbnd7rHdJf4wFPbMQ9pz+dxwKmTnt+P07139wJuAA6a5r7XAe+kK7Qvas/5ti3Gvds+JwIfae2/BFwGPGfgsd0K/EE7duvW9nPgd+k+jfsHuvfpm9pjeFp7nbZqMZ4A7NdeswPofr8ObtseCNw6y3P36Bl+j3vpB3AGd/wefwL4P3S/Y1sDj1rq3LqYC+Zx8/ik+17I64h5fPD5HTaPvx/4FnAE7T09sG0i1ucGXsvvcsf794HAr7d+3Zsut62b9LgmnrfV7bU5E3hwexxfAV45Tb9+8bs+zfYzgAuBNcDOwCV0f4ceR5ezPwwcO7D/84Cd6H6nXg1cCWzRtq0D3jnwmG5t6zu15+7+7fbuwC/PmtcWI3ku1sLUSfr7wK8P3D4UuGjghfsO8E/AfwDbDez3rxO/OANt3wN+deANM5jM3gq8eZp+DSbpIyZ+AQa2Hz/x5qL7hX7bwLbfBs5u60cC/zGw7W50CXi2JD1lvGn6+jfAyW19Z+AWYN92ez+6hPd4WpKbIc4JdGdSbmjLhoFt1wC/O3D7ccAlk47/q4lfCuAqBpIC8FKGT9Lzfh3b6/J30zy+fwX+oq2vba/DlM8Jd03Ss70nf0L7hZ/h/fTzgef2BuD8Sc/vdI/pLvGBDwB/PXB7R+B2ukQ58fyuHdh+MvDyafo2UWwHOBv4fQaKbboz3rdx5z9wLwM+O/DYvj3F4z134PavtHg7DLT9BHjgNH3654nXkeGK7ZsmPbfP7bsf3LnYPpHuY9zdZvod21QXzOPm8Tvu2zw+9WPqO4/fA/hLuhx+K90/Rk+c9FoNvpZ/CpwyTazDga9Oelz/a+D2KcCbBm7/X+CEaWIdTPf344ZJy2Zt+xnAnw3s/0/AJwZuPwM4Y5rYAX4KPKDdnq3YPpR2YmWYZZMeRtI+1rg33S/lhO/R/Scy4V50BcHfVNVNA+33BV7VPrK6Id3MAasmHTv4Ed9P6YqK2dwXeOykuP8L2G2IuPeh+88LgKq6ne4XfjZz6efxwMFJVtH9knyrqi5o93c+cBTd2aPr2sdau84Q65iq2rEte0zaduXA+n2BNZOekz8F7t1ew10n7T/4es5mIa/jnnR/xKdyPN1ZLYDfAz5UQ4yZG/I9eU1V/XyWUKcPPLc7VtV+k7bP9JpPjn+fwf5U1Q10Z3zm/V6vLiv9BV3CHvxY/t50xcUVA22TH//gaz3h2oH1m4FbqupHk9q2BUjyqCSnt48wfwQ8n+4syrCeMum5fd8i9+MVwDbAN9tH3yt6lhLz+Lz6aR43j887j1fVT6rqr6tqf+CewKeAjw0OB+Gur+V9AJLcJ8lH0g2tu5Hu5MvkvDc5j06+PdN7+7JJz9mOVXXbfGKnG8p0ccvPP6T7R2LGHF1VP6R7z7wUuCbJyUlmHUO+SRfb7Q/+NXS/qBNWc+fEdi1wGPDBJAcOtF8J/OWkF3Sbqvr4Art1JfD5SXG3raqXD3Hs1cDgeKO7cedfpFpg36iqS4D1wLOB5wLvnbT9+Kr6NbqPHreiO4Myr7saWL+S7ozA4HOyXVU9vb2G19ElzAmrB9Z/Rnd2YJuBtsFZLxbyOl4J3H+abacDW7UxXocD75tmvzsZ8j254Ndxtm5Mun3VYH+S7ED3UeMwBcD0d1L1KbrH+sKB5mvozrYMvoajfvwn0n1cuGdV7QC8h+6sxWKbVz+q6vtV9b/pCreXAu9OsnqWwzZZ5vG5M4/fiXl8IXfSnUxY12INvmaTX8ur2vo/0J11f1BVbU+X/5ci/84oyZOAPwGeTvcpwM50xfgwOfqUqnoC3T8YVzDEmPxNuthuPgS8tg2SvxfduJw7TX9UVZ8H/jfwqdwxhcxxwJ+kuwAq6aZUelqSbViYTwIPS/KsJFskuXuSRyTZZ4hjTwZ+NclTk2xOd9Zgp4Ht1wJ7ZpoLh+bg+Bb7ALrnD4Ak+yZ5XLoLb25uy21Th5iTr7T4L0938cXmSR6S5IC2/UTg1Ul2SHdR0B9PHNjOCp0LPCfJZummnHvkQOyFvI7vBP4wyWOT3C3dxT/7tPstusR8HPCDqlo/h8c763tykX0I+IN0F3xtBbwe+PequmaW44bxGroxnABU1S1040f/Nt0FU/enG0YyksffzjhtC1xfVf+Tbgq02S9eGbGF9KPlhvu099jEXNyb+kwPszGPz515vGMen6N0Fxke0N7bW9P90//fdOPGJ7yyvZZrgJfQnVgA2I7umoQb20mCP533I+rXdnT/4G2k+/T1r+n+8ZxRuvnWD2nvvVvoHuusvz8rodj+S7qLHs6nG3/0n3QXNtxJVZ1CN4bqM0keUlX/SfcG+xe6P3jfprswakH/rbaPIJ5M95Hn1XT/Df4N3QD92Y69mu5MxVvp3vh70CWoW9oun6Ub73hdkg0L6OaH6T7y+3RVXT/QvjXwxnbfV9MVE3+5gPsBoH0U9lTg1+g+jtpI95/ixMc9r2n3eQXd+K7JszO8hO5K8R/S/Zf6bwOx5/06VtWX6d4Tbwd+RHdxz+DHqMfTXdQx1NmQAUO9J2cxMVvB4PLgOcYAoKr+Dfg7uiLgKrozSs+dT6wpYp9Gd6HNoD9sP78H/DvdH8MPjOj+iu41e0OSm+guPvvIHMN8ftLz+qHZDxlpPx4JnJXkx+2YI6vqqlmO2dSZx+fOPI55fD6x6GrD99Nd9LsBeBTw1HayZMIpdLl9PV2emvhH4y+BR9M9158APjbPPkznflM8Z785jzifAr5EN8Tou3TvzY1DHLcZcDTdJxvX01278yezHZTub4KWo3ZW5Brgt6rqq0vdn8WS5GC6i4WWdK7NdOPXrqW7IO6K2faXpMnM4+bx5aSdNb+ZbnjcQv4ZXFFWwpntTUqSp7SPbrYCXkt3kcNZS9ytlepP6L6UwAQtaWjm8bFiHlfvlv03SK5Aj6X7yH1z4Dzg6VX1s6Xt0sqT7ssmfko3t7IkzYV5fAyYx7VYHEYiSZIk9cRhJJIkSVJPLLYlSZKknvQ2ZjvJu4HfBK6rqge1tp3ppiNaQze10TPbFEokORp4Ad18hS+tqs+19ofTfRnE1sCngZfVEGNfdtlll1qzZs1IH5MkLYazzjrrv6tq1VL3YzGZsyUtV7Pl7D4vkHwP8DbuPJfmUcBpVbUuyVHt9iuT7Ev37U370X0jzxeS7FPdV3AeCxxJ9533nwYOBj4z252vWbOG9evnMj+9JI2HJHP5KutNgjlb0nI1W87ubRhJVX2JbkL0QYfSTSBP+3nYQPsJVXVLVV1G9y1FBybZDdi+qr7azma/d+AYSZIkaawt9pjtXdu3Z018i9a9WvvuwJUD+21obbu39cntkiRJ0tgblwskM0VbzdA+dZDkyCTrk6zfuHGYb92UJEmS+rPYxfa1bWgI7ed1rX0DsOfAfnsAV7X2PaZon1JVHVdVa6tq7apVK+raIkmSJI2hxS62TwaOaOtHACcNtB+eZMskewF7A2e2oSY3JXlEkgDPGzhGkiRJGmt9Tv33IeAgYJckG4DXAuuAE5O8ALgCeAZAVZ2f5ETgAuBW4MVtJhKAP+KOqf8+wxAzkUiSJEnjoLdiu6qePc2mJ0yz/zHAMVO0rwceNMKuSZIkSYtiXC6QlCRJkjY5FtuSJElSTyy2JUmSpJ5YbEuSJEk9sdiWJEmSemKxLUmSJPWkt6n/xs2ao06ZdZ/L1x2yCD2RJM3GnC1pU+GZbUmSJKknFtuSJACSvDvJdUnOG2j7cJKz23J5krNb+5okNw9s++eBYx6e5NwklyZ5a5IsxeORpHGwYoaRSJJm9R7gbcB7Jxqq6lkT60neCPxoYP/vVNX+U8Q5FjgSOAP4NHAw8Jke+itJY88z25IkAKrqS8APptrWzk4/E/jQTDGS7AZsX1VfraqiK9wPG3VfJWm5sNiWJA3jMcC1VXXJQNteSb6Z5PQkj2ltuwMbBvbZ0NokaUVyGIkkaRjP5s5nta8GVlfV9UkeDnwyyX7AVOOza6qASY6kG27C6tWrR9xdSRoPntmWJM0oyebAbwMfnmirqluq6vq2fhbwHWAfujPZewwcvgdw1VRxq+q4qlpbVWtXrVrVV/claUlZbEuSZvNE4KKq+sXwkCSrkmzW1u8H7A18t6quBm5K8og2zvt5wElL0WlJGgcW25IkAJJ8CPgq8IAkG5K8oG06nLteGPlY4Jwk3wI+CryoqiYurvwj4J3ApXRnvJ2JRNKK5ZhtSRIAVfXsadqfP0Xbx4CPTbP/euBBI+2cJC1TntmWJEmSemKxLUmSJPXEYluSJEnqicW2JEmS1BOLbUmSJKknFtuSJElSTyy2JUmSpJ5YbEuSJEk9sdiWJEmSemKxLUmSJPXEYluSJEnqicW2JEmS1BOLbUmSJKknFtuSJElSTyy2JUmSpJ5YbEuSJEk9sdiWJEmSemKxLUmSJPXEYluSJEnqicW2JEmS1BOLbUmSJKknFtuSJElSTyy2JUmSpJ5YbEuSJEk9sdiWJEmSemKxLUmSJPXEYluSJEnqicW2JEmS1BOLbUmSJKknFtuSJElSTyy2JUmSpJ5YbEuSJEk9sdiWJEmSemKxLUmSJPXEYluSJEnqicW2JAmAJO9Ocl2S8wbaXpfk+0nObstTB7YdneTSJBcnefJA+8OTnNu2vTVJFvuxSNK4sNiWJE14D3DwFO1vqqr92/JpgCT7AocD+7Vj3p5ks7b/scCRwN5tmSqmJK0IFtuSJACq6kvAD4bc/VDghKq6paouAy4FDkyyG7B9VX21qgp4L3BYPz2WpPFnsS1Jms1LkpzThpns1Np2B64c2GdDa9u9rU9uv4skRyZZn2T9xo0b++i3JC25JSm2k7wiyflJzkvyoSRbJdk5yalJLmk/dxrYf8pxgZKk3h0L3B/YH7gaeGNrn2ocds3QftfGquOqam1VrV21atUo+ipJY2fRi+0kuwMvBdZW1YOAzejG/R0FnFZVewOntduzjQuUJPWoqq6tqtuq6nbgHcCBbdMGYM+BXfcArmrte0zRLkkr0lINI9kc2DrJ5sA2dIn4UOD4tv147hjjN+W4wEXuryStSG0M9oSnAxMzlZwMHJ5kyyR70V0IeWZVXQ3clOQRbRaS5wEnLWqnJWmMbL7Yd1hV30/yBuAK4Gbg81X1+SS7tiRNVV2d5F7tkN2BMwZCzDj+j+4KeFavXt3XQ5CkTVKSDwEHAbsk2QC8Fjgoyf50Q0EuB/4QoKrOT3IicAFwK/DiqrqthfojuplNtgY+0xZJWpEWvdhuY7EPBfYCbgA+kuT3ZjpkirZpx/8BxwGsXbt2yn0kSVOrqmdP0fyuGfY/Bjhmivb1wING2DVJWraWYhjJE4HLqmpjVf0c+Djwa8C1Ex9Xtp/Xtf2nGxcoSZIkjbWlKLavAB6RZJs2nu8JwIV04/+OaPscwR1j/KYcF7jIfZYkSZLmbCnGbH8tyUeBb9CN8/sm3dCPbYETk7yAriB/Rtt/pnGBkiRJ0tha9GIboKpeS3fhzaBb6M5yT7X/lOMCJUmSpHHmN0hKkiRJPbHYliRJknpisS1JkiT1xGJbkiRJ6onFtiRJktQTi21JkiSpJxbbkiRJUk8stiVJkqSeWGxLkiRJPbHYliRJknpisS1JkiT1xGJbkiRJ6onFtiRJktQTi21JkiSpJxbbkiRJUk8stiVJkqSeWGxLkiRJPbHYliRJknpisS1JkiT1xGJbkiRJ6onFtiRJktQTi21JkiSpJxbbkiRJUk8stiVJkqSebL7UHVhu1hx1yqz7XL7ukEXoiSRJksadZ7YlSZKknlhsS5IkST2x2JYkSZJ6YrEtSZIk9cRiW5IkSeqJxbYkCYAk705yXZLzBtr+IclFSc5J8okkO7b2NUluTnJ2W/554JiHJzk3yaVJ3pokS/F4JGkcWGxLkia8Bzh4UtupwIOq6iHAt4GjB7Z9p6r2b8uLBtqPBY4E9m7L5JiStGJYbEuSAKiqLwE/mNT2+aq6td08A9hjphhJdgO2r6qvVlUB7wUO66O/krQcWGxLkob1v4HPDNzeK8k3k5ye5DGtbXdgw8A+G1qbJK1IfoOkJGlWSV4N3Ap8oDVdDayuquuTPBz4ZJL9gKnGZ9c0MY+kG27C6tWrR99pSRoDntmWJM0oyRHAbwLPaUNDqKpbqur6tn4W8B1gH7oz2YNDTfYArpoqblUdV1Vrq2rtqlWr+nwIkrRkLLYlSdNKcjDwSuBpVfXTgfZVSTZr6/ejuxDyu1V1NXBTkke0WUieB5y0BF2XpLHgMBJJEgBJPgQcBOySZAPwWrrZR7YETm0z+J3RZh55LPDXSW4FbgNeVFUTF1f+Ed3MJlvTjfEeHOctSSuKxbYkCYCqevYUze+aZt+PAR+bZtt64EEj7JokLVsOI5EkSZJ6YrEtSZIk9cRiW5IkSeqJxbYkSZLUE4ttSZIkqScW25IkSVJPLLYlSZKknlhsS5IkST2x2JYkSZJ6YrEtSZIk9cRiW5IkSeqJxbYkSZLUE4ttSZIkqScW25IkSVJPLLYlSZKknmy+1B2QJKkva446ZdZ9Ll93yCL0RNJKtSRntpPsmOSjSS5KcmGSRybZOcmpSS5pP3ca2P/oJJcmuTjJk5eiz5IkSdJcLdUwkrcAn62qBwIPBS4EjgJOq6q9gdPabZLsCxwO7AccDLw9yWZL0mtJkiRpDha92E6yPfBY4F0AVfWzqroBOBQ4vu12PHBYWz8UOKGqbqmqy4BLgQMXt9eSJEnS3C3Fme37ARuBf03yzSTvTHIPYNequhqg/bxX23934MqB4ze0NkmSJGmsLUWxvTlwAHBsVT0M+AltyMg0MkVbTbljcmSS9UnWb9y4ceE9lSRJkhZgKYrtDcCGqvpau/1RuuL72iS7AbSf1w3sv+fA8XsAV00VuKqOq6q1VbV21apVvXRekiRJGtaiF9tVdQ1wZZIHtKYnABcAJwNHtLYjgJPa+snA4Um2TLIXsDdw5iJ2WZIkSZqXpZpn+0+ADyS5O/Bd4PfpCv8Tk7wAuAJ4BkBVnZ/kRLqC/FbgxVV129J0W5IkSRrekhTbVXU2sHaKTU+YZv9jgGN67ZQkSZI0Yn5duyRJktSToYrtJA/quyOSpNEwZ0vS+Bj2zPY/JzkzyR8n2bHXHkmSFsqcLUljYqhiu6oeDTyHbgq+9Uk+mORJvfZMkjQv5mxJGh9Dj9muqkuA1wCvBB4HvDXJRUl+u6/OSZLmx5wtSeNh2DHbD0nyJuBC4NeB36qqX27rb+qxf5KkOTJnS9L4GHbqv7cB7wBeVVU3TzRW1VVJXtNLzyRJ82XOlqQxMWyx/VTg5okvk0lyN2CrqvppVb2vt95JkubDnC1JY2LYMdtfALYeuL1Na5MkjR9ztiSNiWGL7a2q6scTN9r6Nv10SZK0QOZsSRoTwxbbP0lywMSNJA8Hbp5hf0nS0plXzk7y7iTXJTlvoG3nJKcmuaT93Glg29FJLk1ycZInD95fknPbtrcmyQgfmyQtK8MW2y8HPpLky0m+DHwYeEl/3ZIkLcB8c/Z7gIMntR0FnFZVewOntdsk2Rc4HNivHfP2JJu1Y44FjgT2bsvkmJK0Ygx1gWRVfT3JA4EHAAEuqqqf99ozSdK8zDdnV9WXkqyZ1HwocFBbPx74It3c3YcCJ1TVLcBlSS4FDkxyObB9VX0VIMl7gcOAzyzsUUnS8jTsbCQAvwKsacc8LAlV9d5eeiVJWqhR5exdq+pqgKq6Osm9WvvuwBkD+21obT9v65PbJWlFGqrYTvI+4P7A2cBtrbkAi21JGjOLlLOnGoddM7TfNUByJN1wE1avXj26nknSGBn2zPZaYN+qmjJhSpLGyihz9rVJdmtntXcDrmvtG4A9B/bbA7iqte8xRftdVNVxwHEAa9eu9e+LpE3SsBdIngfcu8+OSJJGZpQ5+2TgiLZ+BHDSQPvhSbZMshfdhZBntiEnNyV5RJuF5HkDx0jSijPsme1dgAuSnAncMtFYVU/rpVeSpIWYV85O8iG6iyF3SbIBeC2wDjgxyQuAK4BntFjnJzkRuAC4FXjxxDdWAn9EN7PJ1nQXRnpxpKQVa9hi+3V9dkKSNFKvm89BVfXsaTY9YZr9jwGOmaJ9PfCg+fRBkjY1w079d3qS+wJ7V9UXkmwDbDbbcZKkxWfOlqTxMdSY7SR/AHwU+JfWtDvwyb46JUmaP3O2JI2PYS+QfDHwKOBGgKq6BLjXjEdIkpaKOVuSxsSwxfYtVfWziRtJNmeaeVMlSUvOnC1JY2LYYvv0JK8Ctk7yJOAjwKf665YkaQHM2ZI0JoYtto8CNgLnAn8IfBp4TV+dkiQtiDlbksbEsLOR3A68oy2SpDFmzpak8TFUsZ3kMqYY71dV9xt5jyRJC2LOlqTxMeyX2qwdWN+K7hvEdh59dyRJI2DOlqQxMdSY7aq6fmD5flW9Gfj1nvsmSZoHc7YkjY9hh5EcMHDzbnRnTbbrpUeSpAUxZ0vS+Bh2GMkbB9ZvBS4Hnjny3kiSRsGcLUljYtjZSB7fd0ckSaNhzpak8THsMJI/nWl7Vf3jaLojSVooc7YkjY+5zEbyK8DJ7fZvAV8CruyjU5KkBTFnS9KYGLbY3gU4oKpuAkjyOuAjVfXCvjomSZo3c7YkjYlhv659NfCzgds/A9aMvDeSpFEwZ0vSmBj2zPb7gDOTfILuW8meDry3t15JkhbCnC1JY2LY2UiOSfIZ4DGt6fer6pv9dUuSNF/mbEkaH8MOIwHYBrixqt4CbEiyV099kiQtnDlbksbAUMV2ktcCrwSObk1bAO/vq1OSpPkzZ0vS+Bj2zPbTgacBPwGoqqvwq38laVyZsyVpTAxbbP+sqoruQhuS3KO/LkmSFsicLUljYthi+8Qk/wLsmOQPgC8A7+ivW5KkBTBnS9KYGHY2kjckeRJwI/AA4C+r6tReeyZJmhdztiSNj1mL7SSbAZ+rqicCJmtJGmPmbEkaL7MOI6mq24CfJtlhEfojSVoAc7YkjZdhv0Hyf4Bzk5xKu7odoKpe2kuvJEkLYc6WpDExbLF9SlskSePPnC1JY2LGYjvJ6qq6oqqOX6wOSZLmx5wtSeNntjHbn5xYSfKxnvsiSVoYc7YkjZnZiu0MrN+vz45IkhbMnC1JY2a2YrumWZckjR9ztiSNmdkukHxokhvpzpZs3dZpt6uqtu+1d5KkuTBnS9KYmbHYrqrNFqsjkqSFMWdL0viZ9UttJEkrW5IHJPgUG20AABwZSURBVDl7YLkxycuTvC7J9wfanzpwzNFJLk1ycZInL2X/JWkpDTvPtiRphaqqi4H94RdfB/994BPA7wNvqqo3DO6fZF/gcGA/4D7AF5Ls077dUpJWlCU7s51ksyTfTPJv7fbOSU5Nckn7udPAvp4hkaTx8ATgO1X1vRn2ORQ4oapuqarLgEuBAxeld5I0ZpZyGMnLgAsHbh8FnFZVewOntduTz5AcDLy9nVmRJC2+w4EPDdx+SZJzkrx74CTJ7sCVA/tsaG13kuTIJOuTrN+4cWN/PZakJbQkxXaSPYBDgHcONB8KTHzr2fHAYQPtniGRpCWW5O7A04CPtKZjgfvTDTG5GnjjxK5THH6XqQir6riqWltVa1etWtVDjyVp6S3Vme03A38O3D7QtmtVXQ3Qft6rtQ91hgQ8SyJJPXsK8I2quhagqq6tqtuq6nbgHdxxImQDsOfAcXsAVy1qTyVpTCx6sZ3kN4HrquqsYQ+Zom3KL2vwLIkk9erZDAwhSbLbwLanA+e19ZOBw5NsmWQvYG/gzEXrpSSNkaWYjeRRwNPaFFFbAdsneT9wbZLdqurqlsCva/t7hkSSlliSbYAnAX840Pz3SfanOwFy+cS2qjo/yYnABcCtwIudiUTSSrXoZ7ar6uiq2qOq1tBdaPPvVfV7dGdCjmi7HQGc1NY9QyJJS6yqflpV96yqHw20PbeqHlxVD6mqp00MBWzbjqmq+1fVA6rqM0vTa0laeuM0z/Y64MQkLwCuAJ4BniGRJEnS8rWkxXZVfRH4Ylu/nm7+1qn2OwY4ZtE6JkmSJI2AX9cuSZIk9WSchpGsKGuOOmXWfS5fd8gi9ESSJEl98cy2JEmS1BOLbUmSJKknFtuSJElSTyy2JUmSpJ5YbEuSJEk9sdiWJEmSemKxLUmSJPXEYluSJEnqicW2JEmS1BOLbUmSJKknFtuSJElSTyy2JUmSpJ5YbEuSJEk9sdiWJEmSemKxLUmSJPXEYluSJEnqicW2JEmS1BOLbUmSJKknFtuSJElSTyy2JUmSpJ5YbEuSJEk9sdiWJEmSemKxLUmSJPXEYluSJEnqicW2JEmS1BOLbUmSJKknFtuSJElSTyy2JUmSpJ5svtQdkCRp3K056pRZ97l83SGL0BNJy41ntiVJkqSeWGxLkmaV5PIk5yY5O8n61rZzklOTXNJ+7jSw/9FJLk1ycZInL13PJWlpWWxLkob1+Krav6rWtttHAadV1d7Aae02SfYFDgf2Aw4G3p5ks6XosCQtNYttSdJ8HQoc39aPBw4baD+hqm6pqsuAS4EDl6B/krTkLLYlScMo4PNJzkpyZGvbtaquBmg/79XadweuHDh2Q2uTpBXH2UgkScN4VFVdleRewKlJLpph30zRVnfZqSvajwRYvXr1aHopSWPGM9uSpFlV1VXt53XAJ+iGhVybZDeA9vO6tvsGYM+Bw/cArpoi5nFVtbaq1q5atarP7kvSkrHYliTNKMk9kmw3sQ78BnAecDJwRNvtCOCktn4ycHiSLZPsBewNnLm4vZak8eAwEknSbHYFPpEEur8bH6yqzyb5OnBikhcAVwDPAKiq85OcCFwA3Aq8uKpuW5quS9LSstiWJM2oqr4LPHSK9uuBJ0xzzDHAMT13TZLGnsNIJEmSpJ5YbEuSJEk9sdiWJEmSemKxLUmSJPXEYluSJEnqicW2JEmS1BOLbUmSJKknFtuSJElSTyy2JUmSpJ5YbEuSJEk9sdiWJEmSemKxLUmSJPXEYluSJEnqicW2JEmS1JNFL7aT7JnkP5JcmOT8JC9r7TsnOTXJJe3nTgPHHJ3k0iQXJ3nyYvdZkiRJmo+lOLN9K/BnVfXLwCOAFyfZFzgKOK2q9gZOa7dp2w4H9gMOBt6eZLMl6LckSZI0J4tebFfV1VX1jbZ+E3AhsDtwKHB82+144LC2fihwQlXdUlWXAZcCBy5uryVJkqS5W9Ix20nWAA8DvgbsWlVXQ1eQA/dqu+0OXDlw2IbWJkmSJI21JSu2k2wLfAx4eVXdONOuU7TVNDGPTLI+yfqNGzeOopuSJEnSvC1JsZ1kC7pC+wNV9fHWfG2S3dr23YDrWvsGYM+Bw/cArpoqblUdV1Vrq2rtqlWr+um8JEmSNKSlmI0kwLuAC6vqHwc2nQwc0daPAE4aaD88yZZJ9gL2Bs5crP5KkiRJ87X5Etzno4DnAucmObu1vQpYB5yY5AXAFcAzAKrq/CQnAhfQzWTy4qq6bfG7rWGsOeqUWfe5fN0hi9ATSZKkpbfoxXZVfYWpx2EDPGGaY44BjumtU5IkSVIP/AZJSZIkqScW25IkSVJPLLYlSZKknlhsS5IkST1ZitlINELO/iFJkjS+PLMtSZIk9cRiW5IkSeqJxbYkSZLUE4ttSZIkqScW25IkSVJPLLYlSZKknlhsS5IkST2x2JYkzSjJnkn+I8mFSc5P8rLW/rok309ydlueOnDM0UkuTXJxkicvXe8laWn5pTYC/HIcSTO6FfizqvpGku2As5Kc2ra9qareMLhzkn2Bw4H9gPsAX0iyT1Xdtqi9lqQxYLGtTdps/0T4D4Q0u6q6Gri6rd+U5EJg9xkOORQ4oapuAS5LcilwIPDV3jsrSWPGYSSSpKElWQM8DPhaa3pJknOSvDvJTq1td+DKgcM2MEVxnuTIJOuTrN+4cWOPvZakpWOxLUkaSpJtgY8BL6+qG4FjgfsD+9Od+X7jxK5THF53aag6rqrWVtXaVatW9dRrSVpaFtuSpFkl2YKu0P5AVX0coKqurarbqup24B10Q0WgO5O958DhewBXLWZ/JWlcWGxLkmaUJMC7gAur6h8H2ncb2O3pwHlt/WTg8CRbJtkL2Bs4c7H6K0njxAskNZacHUUaK48Cngucm+Ts1vYq4NlJ9qcbInI58IcAVXV+khOBC+hmMnmxM5FIWqkstiVJM6qqrzD1OOxPz3DMMcAxvXVKkpYJh5FIkiRJPbHYliRJknriMBJJkjQWvF5HmyLPbEuSJEk9sdiWJEmSemKxLUmSJPXEYluSJEnqicW2JEmS1BNnI5EkaYVy9g+pf57ZliRJknpisS1JkiT1xGJbkiRJ6onFtiRJktQTL5CUJGmReEGitPJ4ZluSJEnqicW2JEmS1BOHkUiLxI+PJW2qzG/S9Cy2pVn4R0SSJM2XxbYkSdIUZjvZ4okWDcNiW5KkZcZP3KTlwwskJUmSpJ5YbEuSJEk9sdiWJEmSemKxLUmSJPXEYluSJEnqicW2JEmS1BOLbUmSJKknzrMtSZI2Kc5DrnFisS1JktQTC385jESSJEnqiWe2pWXGsySSJC0fntmWJEmSemKxLUmSJPXEYSTSCuVwFEmS+rdsiu0kBwNvATYD3llV65a4S5KkaZizpdHyBMnytSyGkSTZDPgn4CnAvsCzk+y7tL2SJE3FnC1Jd1guZ7YPBC6tqu8CJDkBOBS4YEl7JUmaijlbGlOeIV98y6XY3h24cuD2BuBXl6gvkgaYuDUFc7YkNamqpe7DrJI8A3hyVb2w3X4ucGBV/cmk/Y4Ejmw3HwBcPEvoXYD/HkEXRxFnnPpiHOMsdYyVHue+VbVqBPe1JFZIzt5U44xTX4xjnKWOMWycGXP2cjmzvQHYc+D2HsBVk3eqquOA44YNmmR9Va1daOdGEWec+mIc4yx1DOMse5t8zt5U44xTX4xjnKWOMao4y+ICSeDrwN5J9kpyd+Bw4OQl7pMkaWrmbElqlsWZ7aq6NclLgM/RTSP17qo6f4m7JUmagjlbku6wLIptgKr6NPDpEYcd+uPLRYgzTn0xjnGWOoZxlrkVkLM31Tjj1BfjGGepY4wkzrK4QFKSJElajpbLmG1JkiRp2bHYliRJknpisS1JkiT1ZNlcIDkukoTuq4h3B4pu7tgza46D342zvOJIC5VkZ6Cq6odL3ZeVZhR5YNxyknGkfo0yZ6+oCyQX+kuc5DeAtwOXAN9vzXsAvwT8cVV93jibXpxxk+TJwGHc+X18UlV91jijizMQb94JN8lq4O+BJwA3AAG2B/4dOKqqLp9Pn1aKERXJC84D45aTjLP8jFN+G6e+jDLOpJjzytt95ewVU2yPKOFeCDxl8pOdZC/g01X1y0P2xTjLKE47ZiySSpI3A/sA76X7lj7o3sfPAy6pqpcZZyRxRpJwk3wVeDPw0aq6rbVtBjwDeHlVPWKYOCvRCAu4BeeBcctJxhkq1ljk7BZjbPLbOPVllHFarAXn7d5ydlWtiAW4EFgzRftewIVDxrgE2HyK9rsDl86hL8ZZXnHeTDdf8OHAo9tyeGt7y2LGAb49TXvoEtOwfTHOzHG+CjwL2GygbbP2ep0xl/fgfLa5jCZnTzzPC80DY5iTjDNznLHJ2S3O2OS3cerLKOO0Yxact/vK2StpzPbm3PFf06DvA1sMGePdwNeTnABc2dr2pHsh3zWHvhhnecV5alXtM7kxyYeBbwPD/uc9ijj/k+TAqjpzUvuvAP8zZD+MM7tdqurDgw3VneU4Icn/m0Ocs5K8HTieO78HjwC+OYc4K9EocjaMJg+MW04yzszGKWfDeOW3cerLKOPAaPJ2Lzl7JQ0jORp4JjDVL/GJVfV3Q8bZF3ga3UdKoftjcHJVXTDH/owqzi8Dh45Rfza5OEnOAV44ORkkORB4V1U9eLHiJDkAOBbYjjsKkT2BG+k+Wj9ryL4YZ+Y4JwA/YOqEu0tVPXPIOHcHXsAUv6N0r/ktw8RZiUaVs1usUeQBc/YyiTNOObvtPzb5bZz6Mso4LdaC83ZfOXvFFNswumSglWVMk8q9GXgfV9U1wx5rnKGOt0geA+Zszcc45uwWbyzy27j1ZVRxxjlvr6hie6GS7AAcTXexxKrWfB1wErCuqm5Y5DgHV7tIo8V8I92V++cBr6iqa5fp4xqrOAPxxiKpJOM1xdamGmdURnWhluZnFHnAnL284gzEG4uc3WKMTX4bp76MMs6o9JGzV0yxPaKE+zm6q1qPn/hla7+EzweeUFVPGrIvo4rzjao6oK2/E7gGeAfw28DjquqwRe7PJhmnHTcWSSVjNsXWphqnxRqbWQhWohEWcAvOA+bs5RWnHTcWObvFGJv8Nk59GWWcgXhjMePXXdQ8r6xcbgvwOeCVwL0H2u4NHAWcOmSMi+ezrcc43xhYP3vStrOXoD+bapzfAC4FPgO8sy2fbW2/sZhxGN0MDcaZOc5YzUKwEpdR5Ox2zILzgDl72cUZm5zd4oxNfhunvowyTjtmbGb8mryspNlI1lTV6wcbqvvPeV2S3x8yxveS/Dndf93XAiTZle6/7itnOrCnOPdK8qd0b4Ltk6TauwK42xL0Z1ON8xbgiTXN3K/AsHO/jiLOqGZoMM7Mxm0WgpVoFDkbRpMHzNnLK8445WwYr/w2Tn0ZZRwYrxm/7mQlFduj+CV+Ft1ZldPbsQVcSzf4fqjZCUYc5x10F25Ad/XtLsDG9rHb2QvoD3Qfb35qjv0Zt+dnVHHGKamM2xRbm2qcUSXc5wPHJpnqAqvnzyHOSjSqwmsUecCcvbzijFPOhvHKb+PUl1HGgdHk7efTQ85eSWO2d6L7JT4UuFdrnvglXldDfqVnkgfSjd85o6p+PND+iwtfhoxzIN1XiX49yX7AwXQfmXx62BhTxNm3xblornGmiPu+qnruAmM8hm6s27k1t7Gyv0r3GH6UZBu61+0A4Hzgb6vqR0PGuTvwbOD7VfWFJM8Bfg24ADiuqn4+ZJxRTRu5qU4/ucnFyZjOQrCSjCpnt1gLztvm7BmPM2fPHmuc8tvY9GXEccZuxq9fxFspxfZMkvx+Vf3rEPu9FHgx3Rij/YGXVdVJbdsvLnwZIs5rgafQ/dd8Kl1yOx14IvC5qjpmnnF+FfjiPOKcPEXzr9NdqEJVPW3IOGdW1YFt/YV0z9Un6ca9faqq1g0Z53zgoVV1a5LjgJ8AH6P7CtaHVtVvDxnnA3TPzdbAj4B7AJ9ocVJVRwwTp8Uaqzl2tThGkXCT8brSflMwbM5u+y44b5uzZ41jztbYWGje7iVnz3ew96a0AFcMud+5wLZtfQ2wni5xA3xzDvd3Lt1XiG5D9x/X9q19a+CcJYjzDeD9wEHA49rPq9v64+YQ55sD618HVrX1e9CdKRk2zoWDfZu0bS4XEZ3Tfm5Od0Zss3Y7c3l+xmkBdgDWARcB17flwta2o3FGE2fgffKrdDNFPL2tZ44xRnKBlctdntehcnbbd8F525w9axxz9syPa2zy2zj1ZZRxBuItKG/3lbPnckHGspbknGmWc4FdZw3Q2azaR5DVXTBxEPCUJP9I9wIP69aquq2qfgp8p6pubDFvBm5fgjhrgbOAVwM/qqovAjdX1elVdfoc4twtyU5J7kn35t7Y+vMT4NY5xDkvd1wA9a0kawGS7AMM9THiQH/uTveR0jZ0v9QAWzKH8XZJdkiyLslFSa5vy4Wtbcc5xDl4Usx3tvfgBwfGXc7mROCHwEFVdc+quifweOAG4CPD9sU4M0s3HdUlwOuApwKHAH8FXNK2DWviAqunVNUL23Iw8KS2TdMYUc6G0eRtc/bMzNkzG6f8Nk59GWWcUeXtfnL2fKv05bbQ/Ze8P3DfScsa4KohY/w7sP+kts3p5mO8bQ59+RqwTVu/20D7Dkw6K7AYcQaO24Puzf025nDmaOD4y4HvApe1n/du7dsyt7MbOwDvAb7THuPPW7zT6T6SHDbOK9px3wNeCpxGd4HSucBr5xBnVFOQDU779U7gb9p78BXAJ4eMMW5TbG2qcUY1rdUlwOZTtN8duHTYOCtxGUXObnEWnLfN2bPGMWfPHGds8ts49WWUcdr+o5gasZecPa+DluNCd1Xro6fZ9sEhY+wx+Ms7aduj5tCXLadp3wV48GLHmeL4Q+guahnVc78NsNc8jtsOeCjwcGDXed73fYD7tPUdgd8BDpxjjLGZYxf4PPDng88H3Vm+VwJfmENfjDNznJEkXLovZflmu//fbcsrW9vRc30/r6RlFDm77bvgvG3OHvo4c/bUccYmv41TX0YZpx234LzdV872AklpFkk+D3yBqacge1JVPXHIOBuAiY+uXwzcv9ovYJJzquohQ8QYnKFh8tRYr6+qHwzZl77iwB1TkK0bg/7MN87YzUIgaTjjlLPbvmOT3zbVnN1ijdWMX3eKabEtzSyjmzbytZOa3l5VE3Ps/n1VPW/IOGM1/eQUcZf9FGQtlkWytAyNW85uscY2b28qObvFG8u8bbEtLcBcpiAbRZxRTGPW9n0to5nKbJOcgmxUkuxA97HkYcCq1nwdcBLdH/0bFrM/0kq32Dm77Ts2educPWt/+snZ8x1/4uLiUjCPi5IWEofxm35yU52CbFTTWo3kQi0XF5fRLIuds9u+Y5O3N9Wc3fYfxdSIveTslfR17dK8JDlnuk3MYQqyEcW50zRmSQ4CPprkvsxj+kngp0nuNAVZkrlOQfYyuinI/m9VnZ3k5prb9GPQpiAD7sakKciSzHkKsurOOH0rydqqWj+PKchOpDvTc1C1L0RoHx0/n272hycNGWdNVb1+sKHFWzcwVZqkERqznA3jlbc31ZwNo8nbveRsi21pdrsCT6abC3RQgP9a5DjXJNm/qs4GqKofJ/lN4N3Ag+fQl58l2aa6+X4f/ouOdB+hDV1sV9XtwJuSfKT9vJb55ZUd6OYNDlBJ7l1V1yTZlrn9MXoh8JYkrwH+G/hqkivpLpZ54RzijCrhfi/JnzP1hVpXznSgpHkbp5wNY5S3N+GcDaPJ273kbIttaXb/RvcR4NmTNyT54iLHeR6Tvmyiqm4FnpfkX+bQl8dW1S3t+MEkvQVwxBziTPRhA/CMJIfQfbw51+PXTLPpdrpvARs2zo+A5yfZDrgfXY7bMJE052BUCfdZdB8/nt6OH7zS/plz7JOk4YxTzoYxzNubYM6G0eTtXnK2F0hK0iSjms2gxRrJLASSpOmNcBaakedsi21JmoOlmIVAkjR/iz3j113iWmxL0vCSXFFVq4fc91zgkW2M5hrgo8D7quotSb5ZVQ/rsauSJIbP233lbMdsS9IkYzgLgSRpBmM249edWGxL0l2N2ywEkqSZjdOMX3disS1JdzVusxBIkmY2TjN+3fn+HbMtSZIk9eNuS90BSZIkaVNlsS1JkiT1xGJbiy7JbUnOHliOGlHc/2o/1yQ5b4rta5L87hBxnp/kbaPo0xD39Z4kv9ND3FcNrE/5fEjSMMzZd7ovc7bmzAsktRRurqr9Rx20qn5tll3WAL8LfHDU9z2GXgX87VJ3QtImwZzdP3P2Jswz2xobSS5P8rdJvppkfZIDknwuyXeSvKjts22S05J8I8m5SQ4dOP7H00cHYB3wmHZm5hVJtkryry3ON5M8foo+HdL6s0uSVUk+luTrbXlU2+d1Sd6d5ItJvtu+gYok90hySpJvJTkvybNmefwPT3J6krPa496ttX8xyeuTnJnk20ke09q3SXJiknOSfDjJ15KsTbIO2Lo9zg+08JsleUeS85N8PsnWw70qkjQ1c7Y5W0OqKheXRV2A24CzB5ZntfbLgT9q628CzgG2A1YB17X2zYHt2/ouwKXcMavOj9vPNcB5U9zvQcC/Ddz+M+Bf2/oDgSuArYDnA28Dng58Gdip7fNB4NFtfTVwYVt/Hd0cnlu2Pl0PbAH8L+AdA/e3wxR9eg/wO23//wJWtfZnAe9u618E3tjWnwp8oa3/H+Bf2vqD6KYrWjv4XAw8H7cC+7fbJwK/t9TvAxcXl+WxmLPv1CdztsucF4eRaCnM9JHkye3nuXTzZd4E3JTkf5LsCPwE+NskjwVuB3anm8j+mnn049HA/wdQVRcl+R6wT9v2eGAt8BtVdWNreyKwb/KLL5HaPsl2bf2UqroFuCXJda1P5wJvSPJ6uj8YX56hLw+gS76ntvibAVcPbP94+3kWXSKe6P9bWv/Py/TfngVwWd0x9+hgDEmajTn7rszZGprFtsbNLe3n7QPrE7c3B55Dd9bk4VX18ySX053ZmI+Zvnr1u8D96BL5+tZ2N+CRVXXznYJ0iXawr7cBm1fVt5M8nO7Mxt8l+XxV/fUMfTm/qh45zfaJ+Ldxx+/tXL46dnL//EhS0iiYs6dmztYvOGZby80OdB9P/ryN17vvHI69ie4jzglfovtDQJJ96D5mvLht+x7w28B7k+zX2j4PvGTi4CQzXjCU5D7AT6vq/cAbgANm2P1iYFWSR7Zjtxi43+l8BXhm239f7vxVsj9PssUsx0tS38zZdzBnr1AW21oKExeCTCzr5nDsB4C1SdbTJd2L5nDsOcCt7eKXVwBvp7sI5Vzgw8Dz28eKAFTVxe0+PpLk/sBL232fk+QC4EWz3N+DgTOTnA28Gvib6Xasqp/RjQN8fZJv0Y2LnO1K/bfTJftzgFe2x/ejtu044JyBi20kab7M2ZOYszUXfl27tEwl2QzYoqr+p/1hOQ3Yp/0RkCSNEXP2yuWYbWn52gb4j/bRY+hmBTBpS9J4MmevUJ7ZliRJknrimG1JkiSpJxbb+v/brWMBAAAAgEH+1qPYVxQBADCRbQAAmMg2AABMZBsAACayDQAAkwAOiJe8pj4jYwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 864x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Load required libraries\n",
    "import matplotlib.pyplot as plt\n",
    "bins = [0,100,200,300,350,400,500,600,800,1000,1500,2000,3000,4000,5000,6000,10000,20000]\n",
    "\n",
    "\n",
    "fig, axes = plt.subplots(nrows=1, ncols=2,figsize=(12, 6))\n",
    "fig.subplots_adjust(hspace=.5)\n",
    "\n",
    "df_sub=df[ (df['lang']=='en') & (df['class']=='ham')]\n",
    "df1 = df_sub.groupby(pd.cut(df_sub['token_count'], bins=bins)).token_count.count()\n",
    "df1.index=[a.right for a in df1.index]\n",
    "res1=df1.plot(kind='bar',ax=axes[0])\n",
    "res1.set_xlabel('Email tokens length')\n",
    "res1.set_ylabel('Frequency')\n",
    "res1.set_title('Token length Vs Frequency for Enron Normal Emails')\n",
    "\n",
    "\n",
    "df_sub=df[ (df['lang']=='en') & (df['class']=='spam')]\n",
    "df1 = df_sub.groupby(pd.cut(df_sub['token_count'], bins=bins)).token_count.count()\n",
    "df1.index=[a.right for a in df1.index]\n",
    "res2=df1.plot(kind='bar',ax=axes[1])\n",
    "res2.set_xlabel('Email tokens length')\n",
    "res2.set_ylabel('Frequency')\n",
    "res2.set_title('Token length Vs Frequency for Enron Spam Emails')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import keras\n",
    "\n",
    "from keras.layers import Input, Dense\n",
    "from keras.models import Model,load_model\n",
    "from keras.layers import Input, Dense\n",
    "from keras.models import Model\n",
    "from keras import regularizers\n",
    "\n",
    "from keras.preprocessing.text import Tokenizer\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense, Dropout, Activation\n",
    "from keras.callbacks import ModelCheckpoint, TensorBoard"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\pjalp\\Anaconda3\\lib\\site-packages\\sklearn\\externals\\joblib\\__init__.py:15: DeprecationWarning: sklearn.externals.joblib is deprecated in 0.21 and will be removed in 0.23. Please import this functionality directly from joblib, which can be installed with: pip install joblib. If this warning is raised when loading pickled models, you may need to re-serialize those models with scikit-learn 0.21+.\n",
      "  warnings.warn(msg, category=DeprecationWarning)\n"
     ]
    }
   ],
   "source": [
    "import sklearn\n",
    "from sklearn import metrics\n",
    "from sklearn import svm\n",
    "from sklearn.externals import joblib\n",
    "from sklearn.preprocessing import LabelEncoder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# max number of features\n",
    "num_max = 4000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "def train_tf_idf_model(texts):\n",
    "    \"train tf idf model \"\n",
    "    tic = time.process_time()\n",
    "    \n",
    "    tok = Tokenizer(num_words=num_max)\n",
    "    tok.fit_on_texts(texts)\n",
    "    toc = time.process_time()\n",
    "\n",
    "    print (\" -----total Computation time = \" + str((toc - tic)) + \" seconds\")\n",
    "    return tok\n",
    "\n",
    "def prepare_model_input(tfidf_model,dataframe,mode='tfidf'):\n",
    "    \n",
    "    \"function to prepare data input features using tfidf model\"\n",
    "    tic = time.process_time()\n",
    "    le = LabelEncoder()\n",
    "    sample_texts = list(dataframe['tokenized_text'])\n",
    "    sample_texts = [' '.join(x.split()) for x in sample_texts]\n",
    "    \n",
    "    targets=list(dataframe['class'])\n",
    "    targets = [1. if x=='spam' else 0. for x in targets]\n",
    "    sample_target = le.fit_transform(targets)\n",
    "    \n",
    "    if mode=='tfidf':\n",
    "        sample_texts=tfidf_model.texts_to_matrix(sample_texts,mode='tfidf')\n",
    "    else:\n",
    "        sample_texts=tfidf_model.texts_to_matrix(sample_texts)\n",
    "    \n",
    "    toc = time.process_time()\n",
    "    \n",
    "    print('shape of Class: ', sample_target.shape)\n",
    "    print('shape of data: ', sample_texts.shape)\n",
    "    \n",
    "    print (\" -----total Computation time for preparing model data = \" + str((toc - tic)) + \" seconds\")\n",
    "    \n",
    "    return sample_texts,sample_target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " -----total Computation time = 1.0 seconds\n"
     ]
    }
   ],
   "source": [
    "texts=list(df_model['tokenized_text'])\n",
    "tfidf_model=train_tf_idf_model(texts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "shape of Class:  (6495,)\n",
      "shape of data:  (6495, 4000)\n",
      " -----total Computation time for preparing model data = 2.640625 seconds\n"
     ]
    }
   ],
   "source": [
    "# prepare model input data\n",
    "mat_texts,tags=prepare_model_input(tfidf_model,df_model,mode='tfidf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train data shape:  (3897, 4000) (3897,)\n",
      "validation data shape : (2598, 4000) (2598,)\n"
     ]
    }
   ],
   "source": [
    "#Splitting Training and Testing Data\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "X_train, X_val, y_train, y_val = train_test_split(mat_texts, tags, test_size=0.40)\n",
    "print ('train data shape: ', X_train.shape, y_train.shape)\n",
    "print ('validation data shape :' , X_val.shape, y_val.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Define and initialize the network\n",
    "\n",
    "model_save_path=\"checkpoints/spam_detector_enron_model.h5\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime\n",
    "def get_simple_model():\n",
    "    model = Sequential()\n",
    "    model.add(Dense(512, activation='relu', input_shape=(num_max,)))\n",
    "    model.add(Dropout(0.5))\n",
    "    model.add(Dense(256, activation='relu'))\n",
    "    model.add(Dropout(0.5))\n",
    "    model.add(Dense(1, activation='sigmoid'))\n",
    "    model.summary()\n",
    "    model.compile(loss='binary_crossentropy',\n",
    "              optimizer='adam',\n",
    "              metrics=['acc',keras.metrics.binary_accuracy])\n",
    "    print('compile done')\n",
    "    return model\n",
    "\n",
    "def check_model(model,x,y,epochs=2):\n",
    "    history=model.fit(x,y,batch_size=32,epochs=epochs,verbose=1,shuffle=True,validation_split=0.2,\n",
    "              callbacks=[checkpointer, tensorboard]).history\n",
    "    return history\n",
    "\n",
    "\n",
    "def check_model2(model,x_train,y_train,x_val,y_val,epochs=10):\n",
    "    history=model.fit(x_train,y_train,batch_size=64,\n",
    "                      epochs=epochs,verbose=1,\n",
    "                      shuffle=True,\n",
    "                      validation_data=(x_val, y_val)).history\n",
    "    return history\n",
    "\n",
    "# define checkpointer\n",
    "checkpointer = ModelCheckpoint(filepath=model_save_path,\n",
    "                               verbose=1,\n",
    "                               save_best_only=True)    \n",
    "\n",
    "\n",
    "# define tensorboard\n",
    "tensorboard = TensorBoard(log_dir = os.path.join(\"logs\",\"fit\",datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\")),\n",
    "                          histogram_freq=0,\n",
    "                          write_graph=True,\n",
    "                          write_images=True)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# define the predict function for the deep learning model for later use\n",
    "def predict(data):\n",
    "    result=model.predict(data)\n",
    "    prediction = [round(x[0]) for x in result]\n",
    "    return prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_1\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "dense_1 (Dense)              (None, 512)               2048512   \n",
      "_________________________________________________________________\n",
      "dropout_1 (Dropout)          (None, 512)               0         \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 256)               131328    \n",
      "_________________________________________________________________\n",
      "dropout_2 (Dropout)          (None, 256)               0         \n",
      "_________________________________________________________________\n",
      "dense_3 (Dense)              (None, 1)                 257       \n",
      "=================================================================\n",
      "Total params: 2,180,097\n",
      "Trainable params: 2,180,097\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "compile done\n",
      "Train on 3897 samples, validate on 2598 samples\n",
      "Epoch 1/10\n",
      "3897/3897 [==============================] - 3s 777us/step - loss: 0.1939 - acc: 0.9264 - binary_accuracy: 0.9264 - val_loss: 0.0963 - val_acc: 0.9842 - val_binary_accuracy: 0.9842\n",
      "Epoch 2/10\n",
      "3897/3897 [==============================] - 2s 561us/step - loss: 0.0210 - acc: 0.9946 - binary_accuracy: 0.9946 - val_loss: 0.0939 - val_acc: 0.9834 - val_binary_accuracy: 0.9834\n",
      "Epoch 3/10\n",
      "3897/3897 [==============================] - 2s 525us/step - loss: 0.0171 - acc: 0.9964 - binary_accuracy: 0.9964 - val_loss: 0.1362 - val_acc: 0.9861 - val_binary_accuracy: 0.9861\n",
      "Epoch 4/10\n",
      "3897/3897 [==============================] - 2s 527us/step - loss: 0.0116 - acc: 0.9979 - binary_accuracy: 0.9979 - val_loss: 0.1811 - val_acc: 0.9704 - val_binary_accuracy: 0.9704\n",
      "Epoch 5/10\n",
      "3897/3897 [==============================] - 2s 521us/step - loss: 0.0210 - acc: 0.9987 - binary_accuracy: 0.9987 - val_loss: 0.1488 - val_acc: 0.9815 - val_binary_accuracy: 0.9815\n",
      "Epoch 6/10\n",
      "3897/3897 [==============================] - 2s 543us/step - loss: 0.0285 - acc: 0.9985 - binary_accuracy: 0.9985 - val_loss: 0.1660 - val_acc: 0.9796 - val_binary_accuracy: 0.9796\n",
      "Epoch 7/10\n",
      "3897/3897 [==============================] - 2s 524us/step - loss: 0.0086 - acc: 0.9995 - binary_accuracy: 0.9995 - val_loss: 0.1380 - val_acc: 0.9792 - val_binary_accuracy: 0.9792\n",
      "Epoch 8/10\n",
      "3897/3897 [==============================] - 2s 525us/step - loss: 0.0017 - acc: 0.9997 - binary_accuracy: 0.9997 - val_loss: 0.1492 - val_acc: 0.9796 - val_binary_accuracy: 0.9796\n",
      "Epoch 9/10\n",
      "3897/3897 [==============================] - 2s 536us/step - loss: 0.0063 - acc: 0.9992 - binary_accuracy: 0.9992 - val_loss: 0.1633 - val_acc: 0.9792 - val_binary_accuracy: 0.9792\n",
      "Epoch 10/10\n",
      "3897/3897 [==============================] - 2s 549us/step - loss: 0.0015 - acc: 0.9997 - binary_accuracy: 0.9997 - val_loss: 0.1882 - val_acc: 0.9800 - val_binary_accuracy: 0.9800\n"
     ]
    }
   ],
   "source": [
    "# get the compiled model\n",
    "model = get_simple_model()\n",
    "\n",
    "# load history\n",
    "# history=check_model(m,mat_texts,tags,epochs=10)\n",
    "history=check_model2(model,X_train,y_train,X_val,y_val,epochs=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot the loss on train and validation data\n",
    "plt.plot(history['loss'])\n",
    "plt.plot(history['val_loss'])\n",
    "plt.title('Email Spam Filter Model loss')\n",
    "plt.ylabel('loss')\n",
    "plt.xlabel('epoch')\n",
    "plt.legend(['train', 'test'], loc='upper right');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "##RANDOM FOREST MODEL\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',\n",
       "                       max_depth=None, max_features='auto', max_leaf_nodes=None,\n",
       "                       min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "                       min_samples_leaf=1, min_samples_split=2,\n",
       "                       min_weight_fraction_leaf=0.0, n_estimators=1000,\n",
       "                       n_jobs=None, oob_score=False, random_state=5, verbose=0,\n",
       "                       warm_start=False)"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spam_model_rf = RandomForestClassifier(n_estimators=1000,random_state=5)\n",
    "\n",
    "# Train the Classifier to take the training features and learn how they relate\n",
    "# to the training y (the species)\n",
    "spam_model_rf.fit(X_train,y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "##EVALUATE MODEL PERFORMANCE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "shape of Class:  (1000,)\n",
      "shape of data:  (1000, 4000)\n",
      " -----total Computation time for preparing model data = 0.21875 seconds\n"
     ]
    }
   ],
   "source": [
    "sample_texts,sample_target=prepare_model_input(tfidf_model,df_unseen_test,mode='')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_dict={}\n",
    "model_dict['random_forest']=spam_model_rf\n",
    "model_dict['neural_networks']=model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def getResults(model_dict,sample_texts,sample_target):\n",
    "    '''\n",
    "    Get results from different models\n",
    "    '''\n",
    "    results=[]\n",
    "    \n",
    "    results_cm={}\n",
    "    \n",
    "    for name,model in model_dict.items():\n",
    "#         print(name)\n",
    "        tic1 = time.process_time()\n",
    "        if name in 'neural_networks':\n",
    "            predicted_sample = predict(sample_texts)\n",
    "            cm=sklearn.metrics.confusion_matrix(sample_target, predicted_sample)\n",
    "        else:    \n",
    "            predicted_sample = model.predict(sample_texts)\n",
    "            cm=sklearn.metrics.confusion_matrix(sample_target, predicted_sample.round())\n",
    "            \n",
    "        toc1 = time.process_time()\n",
    "#         print(predicted_sample)\n",
    "\n",
    "        \n",
    "        results_cm[name]=cm\n",
    "        \n",
    "        total=len(predicted_sample)\n",
    "        TP = cm[0][0]\n",
    "        FP = cm[0][1]\n",
    "        FN = cm[1][0]\n",
    "        TN = cm[1][1]\n",
    "        \n",
    "        time_taken=round(toc1 - tic1,4)\n",
    "        res=sklearn.metrics.precision_recall_fscore_support(sample_target, predicted_sample)\n",
    "        accuracy=sklearn.metrics.accuracy_score(sample_target, predicted_sample)\n",
    "        results.append([name,np.mean(res[0]),np.mean(res[1]),np.mean(res[2]),accuracy,TP,FP,FN,TN,str(time_taken)] )\n",
    "        \n",
    "    \n",
    "    df_cols=['model','precision','recall','f1_score','Accuracy','TP','FP','FN','TN','execution_time']\n",
    "    result_df=pd.DataFrame(results,columns=df_cols)\n",
    "    \n",
    "    return result_df,results_cm\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "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>model</th>\n",
       "      <th>precision</th>\n",
       "      <th>recall</th>\n",
       "      <th>f1_score</th>\n",
       "      <th>Accuracy</th>\n",
       "      <th>TP</th>\n",
       "      <th>FP</th>\n",
       "      <th>FN</th>\n",
       "      <th>TN</th>\n",
       "      <th>execution_time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>random_forest</td>\n",
       "      <td>0.918022</td>\n",
       "      <td>0.880573</td>\n",
       "      <td>0.892643</td>\n",
       "      <td>0.901</td>\n",
       "      <td>311</td>\n",
       "      <td>88</td>\n",
       "      <td>11</td>\n",
       "      <td>590</td>\n",
       "      <td>0.5625</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>neural_networks</td>\n",
       "      <td>0.979100</td>\n",
       "      <td>0.971188</td>\n",
       "      <td>0.974779</td>\n",
       "      <td>0.976</td>\n",
       "      <td>378</td>\n",
       "      <td>21</td>\n",
       "      <td>3</td>\n",
       "      <td>598</td>\n",
       "      <td>1.1094</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             model  precision    recall  f1_score  Accuracy   TP  FP  FN   TN  \\\n",
       "0    random_forest   0.918022  0.880573  0.892643     0.901  311  88  11  590   \n",
       "1  neural_networks   0.979100  0.971188  0.974779     0.976  378  21   3  598   \n",
       "\n",
       "  execution_time  \n",
       "0         0.5625  \n",
       "1         1.1094  "
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result_df,results_cm= getResults(model_dict,sample_texts,sample_target)\n",
    "result_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RANDOM FOREST:\n",
      "HAM Misclassification Rate:  0.12979351032448377\n",
      "SPAM Misclassification Rate:  0.034161490683229816\n"
     ]
    }
   ],
   "source": [
    "#NN SMR AND HMR COMPUTATION\n",
    "result_df.iloc[0][5]\n",
    "HMR = float(result_df.iloc[0][6] / (result_df.iloc[0][8] + result_df.iloc[0][6]))\n",
    "SMR = float(result_df.iloc[0][7] / (result_df.iloc[0][5] + result_df.iloc[0][7]))\n",
    "\n",
    "print(\"RANDOM FOREST:\")\n",
    "print(\"HAM Misclassification Rate: \",HMR)\n",
    "print(\"SPAM Misclassification Rate: \", SMR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NEURAL NETWORK:\n",
      "HAM Misclassification Rate:  0.033925686591276254\n",
      "SPAM Misclassification Rate:  0.007874015748031496\n"
     ]
    }
   ],
   "source": [
    "#NN SMR AND HMR COMPUTATION\n",
    "result_df.iloc[0][5]\n",
    "HMR = float(result_df.iloc[1][6] / (result_df.iloc[1][8] + result_df.iloc[1][6]))\n",
    "SMR = float(result_df.iloc[1][7] / (result_df.iloc[1][5] + result_df.iloc[1][7]))\n",
    "\n",
    "print(\"NEURAL NETWORK:\")\n",
    "print(\"HAM Misclassification Rate: \",HMR)\n",
    "print(\"SPAM Misclassification Rate: \", SMR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_heatmap(cm,title):\n",
    "    df_cm2 = pd.DataFrame(cm, index = ['normal', 'spam'])\n",
    "    df_cm2.columns=['normal','spam']\n",
    "\n",
    "    ax = plt.axes()\n",
    "    sns.heatmap(df_cm2, annot=True, fmt=\"d\", linewidths=.5,ax=ax)\n",
    "    ax.set_title(title)\n",
    "    plt.show()\n",
    "\n",
    "    \n",
    "    return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_heatmap(results_cm['neural_networks'],'Neural Networks')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWAAAAEPCAYAAAB8wx7DAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAa20lEQVR4nO3dfbxWZZ3v8c8XRDQVQQ3iaQZM2iU+P5CmFmn5nDjjweg0xKs87TkOZ0Z95ZjWnNSKso6mM+UTlomZGXPMI9poOiiMNCphPgDCFgIEBEFUfMoI9v6dP9baesvAvdeG+97Xvhff9+u1Xvda17rWWr8bNr99ca1rXUsRgZmZdb0eqQMwM9tROQGbmSXiBGxmlogTsJlZIk7AZmaJOAGbmSXiBGydImm0pJWp4zArAyfgEpC0TNLbkt6U9KKkWyTtnjqu7SUpJL2Vf683Ja3v4uv7l43VlRNweXwmInYHDgEOBS5JHE+tHBwRu+dL384eLGmnegRlVgtOwCUTES8CvyFLxABIOk3Sk5Jel7RC0mUV+4blLc0JkpZLWifp6xX7d81b1K9KehY4svJ6kj4iaYak9ZLmSzqjYt8tkq6TdF/egv2tpA9IuiY/30JJh27L95T0ZUmLJb0iaZqkQRX7QtJESYuARXnZhyU9mNdvkXR2Rf1TJT0r6Q1JL0i6UNJuwH3AoIoW+KD/EojZ9ogILw2+AMuAT+XrQ4C5wD9X7B8NHEj2C/cgYA1wZr5vGBDATcCuwMHABuAj+f4rgEeAvYChwDxgZb6vF7AY+BqwM3A88AbQlO+/BVgHHA7sAjwELAW+APQEvg08XOV7BbDfFsqPz897GNAb+CHwH5sd92Ae867AbsAK4IvATvlx64CRef3VwHH5ej/gsIo/t5Wp/369lHdJHoCXGvwlZgn4zTz5BTAd6Ful/jXA1fl6ewIeUrF/NjAuX18CnFyxr7kiAR8HvAj0qNj/C+CyfP0W4KaKfX8PLKjYPhBYXyXOAF4H1ufLv+TlPwG+X1Fvd2AjMKziuOMr9n8WeGSzc98IXJqvLwf+FuizWR0nYC91XdwFUR5nRsQeZEnjw8A+7TskfVTSw5JekvQa8D8r9+derFj/I1lSAxhE1nps93zF+iBgRUS0bbZ/cMX2mor1t7ew3dHNwsMiom++/EPFdd+JIyLeBF7e7LqVMf8l8NG8m2R9fjPv88AH8v1nAacCz0uaKenoDmIyqwkn4JKJiJlkLc8rK4pvB6YBQyNiT+AGQAVPuZqs66HdX1SsrwKGSuqx2f4XOhl2Z60iS6oA5P21e2923cpp/lYAMysSed/IbuqdCxARv4uIMUB/4P8BU7dwDrOacwIup2uAT0tqvxG3B/BKRPxJ0ijgv3fiXFOBSyT1kzSErBuh3ePAW8BFknpJGg18Brhju79BdbcDX5R0iKTewHeAxyNi2Vbq3wt8SNL4PM5eko7MbyDuLOnzkvaMiI1kXR6t+XFrgL0l7Vnn72M7KCfgEoqIl4Bbgf+dF/0d8E1JbwDf4N0WXhGXk/13fynwAPCziuv8GTgDOIXsptZ1wBciYuH2fodqImI62Xe7k6yF/kFgXJX6bwAn5nVWkXW3fI/sBh7AeGCZpNfJumf+Jj9uIVmf9pK868KjIKymFOH/ZZmZpeAWcO3sQjZ64GlgPlnLEWBsvt0GHFFRf2/gYbLRCz/qujAtsQvIfh7mkbWudyEbs/0Y8BQwBxiVLDrrUm4B147Ixpu+STY+dhZwHvAaWfK9EbiQ7B8Yed1DgQPy5X91cbzW9QaT/VzsTzYCZCrwb2R98leTPfhxKnAR2WgWKzk/plk7QZZ8IUvAvfKyBVup/xbZP8b96h+adSM7kT0cshF4H1mfdAB98v175mW2A6iagCUdVm1/RPy+tuE0vJ7AE2RJ9VqyUQJm7V4gGx64nKwF/EC+rCB7fPxKsm7Bj6UK0LpWRy3gq6rsC7JHQu1drWT9eX2Bu8i6FuYljci6k37AGGA42ZN9/0o24mIUWd/wncDZZE/6fSpRjNaF6tIHLKmZ7JFVbrzxxsOP+s49Nb9Gd9f/vHG0/XED6266C4B97/gOqyfdzNtzF7+nXr//dgK7Hrgfqy69MUWYSRy0LPt5OGLgcYkj6VonnD6aj33yo3zrK98D4LSxJ3HAYSM55a8/zeimU96pN+O5+xn9oZNThZnMnNWPQPEHhLZq47olhZNar3323e7rbY/CoyAkHSDpbElfaF+2VjciJkfEERFxRHNzc20i7eZ67tWHHn12A0C9d2aPYw5hwx88lay968UX1nLA4SPpvWs2/PjIYw9n2aLneWnNOg4/+pB3ylYs9c/NdmlrLb4kVugmnKRLye7K7k921/YUshtIt9YtsgbTq/9eDL3qfOjRA/Xowfpfz+KNh35Hn5OOYtBlf8tOe+3JsJu/wZ8WLGXpFy4F4MOzfkyP3d+Heu1EnxOPYun4b7Bh8YoOrmSNav6TzzL93hn8/IGf0LqplZZ5i/jVbdNYOO85LvzWefTs2ZM/b/gzk/7x+6lDbWzvmZqkeyvUBSFpLtk0hU9GxMGSBgA/jojPFLhGPDOsSDXbUeyoXRBWXc26IFYvKN4FMfAjSbsgig5Dezsi2iRtktQHWAvsW8e4zMy2STRQC7hoAp4jqS/ZpN1PkI13nV23qMzMtlVbyRJwRPxdvnqDpPvJJq5+pn5hmZltoxK2gJF0ENnbE3bKt/eLiF/VKS4zs23TujF1BIUVHQVxM9m7xNonlYHsQQwnYDPrXsrWBQEcFRH71zUSM7MaaKSbcEUfxHhUkhOwmXV/bW3Fl8SKtoCnkCXhF8leWS4gIuKgukVmZrYtGqgFXDQB30z22pa5vNsHbGbW/ZTtJhywPCKm1TUSM7Na6AZdC0UVTcALJd0O3EPWBQGAh6GZWbdTwi6IXckS74kVZR6GZmbdT5lawJJ6As9ExNVdEI+Z2XaJSD/NZFEdDkOL7Nuc0QWxmJltv2grviRWtAviPyX9CPgl2cskAb8Tzsy6odZNqSMorGgCbn9J4DcryvxOODPrfrrBmy6KKjob2ifrHYiZWU10g66FoopOxrMncCnw8bxoJvDNiHitXoGZmW2TBhoFUXQuiJuBN8hemX028Drw03oFZWa2zUp4E+6DEXFWxfblkp6qR0BmZtulgVrAhd8JJ+nYiJgFIOkY4O36hWVmtm2ihHNBnAtMyfuCAV4FJtQnJDOz7VDCFvAC4PvAB4G+wGvAmYDfC2dm3Us36NstqmgCvhtYD/weeKF+4ZiZbacStoCHRMTJdY3EzKwWStgC/k9JB0bE3LpGY2a2vRroUeSi44CPBZ6Q1CLpGUlzJbn/18y6nxq+E07SsjzfPSVpTl62l6QHJS3KP/tV1L9E0uI8V57U0fmLtoBPKVjPzCyt2vcBfzIi1lVsXwxMj4grJF2cb381f3HxOGAkMAj4d0kfiirzYxadC+L5bY/dzKwL1b8PeAwwOl+fAswAvpqX3xERG4ClkhYDo4BHt3aiol0QZmaNobavpQ/gAUlPSGrOywZExGqA/LN/Xj4YWFFx7Mq8bKuKdkGYmTWGTrSA86TaXFE0OSImV2wfExGrJPUHHpS0sNrpthRNtes7AZtZuXRiFESebCdX2b8q/1wr6S6yLoU1kgZGxGpJA4G1efWVwNCKw4cAq6pd310QZlYuNeqCkLSbpD3a18leSjwPmMa7UzFMIHtQjbx8nKTekoYDI4DZ1a7hFrCZlUvtRkEMAO6SBFmuvD0i7pf0O2CqpHOA5cBYgIiYL2kq8CywCZhYbQRE+0nNzMojqna7duI0sQQ4eAvlLwMnbOWYScCkotdwAjazcinhXBBmZo3BCdjMLJEGmgvCCdjMyqVGfcBdwQnYzMrFXRBmZok4AZuZJVLCCdnNzBpCbKr67EO34gRsZuXiFrCZWSJtHgVhZpaGb8KZmSXiBGxmlogfxDAzS8SjIMzMEvEoCDOzRDwKwswsjfBNODOzRNwCNjNLxH3AZmaJeBSEmVki7oIwM0vEXRBmZom4BWxmloaHoZmZpbLJCdjMLA33AZuZJeI+YDOzNMIJ2MwskQZKwD1SB2BmVlNtbcWXAiT1lPSkpHvz7b0kPShpUf7Zr6LuJZIWS2qRdFJH53YCNrNy2dRWfCnmPGBBxfbFwPSIGAFMz7eRtD8wDhgJnAxcJ6lntRM7AZtZqURE4aUjkoYApwE/rigeA0zJ16cAZ1aU3xERGyJiKbAYGFXt/E7AZlYubVF4kdQsaU7F0rzZ2a4BLgIqm8sDImI1QP7ZPy8fDKyoqLcyL9sq34Qzs3LpxE24iJgMTN7SPkmnA2sj4glJowucTlu6RLUDnIDNrFRqOAztGOAMSacCuwB9JN0GrJE0MCJWSxoIrM3rrwSGVhw/BFhV7QLugjCzculEF0Q1EXFJRAyJiGFkN9ceioi/AaYBE/JqE4C78/VpwDhJvSUNB0YAs6tdwy1gMyuV2FT3ccBXAFMlnQMsB8YCRMR8SVOBZ4FNwMSIqDo7vBOwmZVLHR7EiIgZwIx8/WXghK3UmwRMKnpeJ2AzK5fGmYvHCdjMysVzQZiZpeIWsJlZGl1wE65mnIDNrFQaaD52J2AzKxknYDOzNNwCNjNLxQnYzCwNt4DNzBJp25Q6guKcgM2sXGJLs0J2T07AZlYq7oIwM0sk2twCNjNLwi1gM7NE2lrdAjYzS8JdEGZmiRR423y34QRsZqXiFrCZWSJOwGZmibgLwswskbbWHqlDKMwJ2MxKxeOAzcwSafNcEGZmaYQTsJlZGh4FYWaWiEdBmJkl0upREGZmaTRSH3Dj/KowMysgovhSjaRdJM2W9LSk+ZIuz8v3kvSgpEX5Z7+KYy6RtFhSi6STOorVCdjMSqUtVHjpwAbg+Ig4GDgEOFnSUcDFwPSIGAFMz7eRtD8wDhgJnAxcJ6lntQs4AZtZqUSo8FL9PBER8Wa+2StfAhgDTMnLpwBn5utjgDsiYkNELAUWA6OqXaNL+oAPWnZPV1zGGsyc1Y+kDsFKqLWGw9DyFuwTwH7AtRHxuKQBEbEaICJWS+qfVx8MPFZx+Mq8bKvcAjazUulMC1hSs6Q5FUvze88VrRFxCDAEGCXpgCqX3lLmr9rT3CUt4J12rvpLwHYwm/78AgAb1y1JHIl1J7322bcm5+nMo8gRMRmYXKDeekkzyPp210gamLd+BwJr82orgaEVhw0BVlU7r1vAZlYq0YmlGknvl9Q3X98V+BSwEJgGTMirTQDuztenAeMk9ZY0HBgBzK52DY8DNrNSqeFkPAOBKXk/cA9gakTcK+lRYKqkc4DlwFiAiJgvaSrwLLAJmBgRrdUu4ARsZqVSqwcxIuIZ4NAtlL8MnLCVYyYBk4pewwnYzEqldYv3wronJ2AzK5U2T8ZjZpZGm1vAZmZphBOwmVkaDfRKOCdgMysXt4DNzBLZlDqATnACNrNScQvYzCyRBnonpxOwmZWLh6GZmSXSQM9hOAGbWblsklvAZmZJuAVsZpaIH8QwM0vEoyDMzBLxKAgzs0TcB2xmlsimxmkAOwGbWbm4BWxmlohvwpmZJeJhaGZmiTgBm5klUqO30ncJJ2AzKxVPyG5mlohHQZiZJeJREGZmifgmnJlZIk7AZmaJtDZQF0SP1AGYmdVSWyeWaiQNlfSwpAWS5ks6Ly/fS9KDkhbln/0qjrlE0mJJLZJO6ihWJ2AzK5XoxNKBTcBXIuIjwFHAREn7AxcD0yNiBDA93ybfNw4YCZwMXCepZ7ULOAGbWam0EYWXaiJidUT8Pl9/A1gADAbGAFPyalOAM/P1McAdEbEhIpYCi4FR1a7hBGxmpVKrLohKkoYBhwKPAwMiYjVkSRron1cbDKyoOGxlXrZVTsBmViqd6YKQ1CxpTsXSvPn5JO0O3AmcHxGvV7n0lm7/VW1mexSEmZVKZyZkj4jJwOSt7ZfUiyz5/jwifpUXr5E0MCJWSxoIrM3LVwJDKw4fAqyqdn23gM2sVGrVByxJwE+ABRHxg4pd04AJ+foE4O6K8nGSeksaDowAZle7hlvAZlYqNZwL4hhgPDBX0lN52deAK4Cpks4BlgNjASJivqSpwLNkIygmRkRrtQs4AZtZqdTqSbiImMWW+3UBTtjKMZOASUWv4QRsZqXSUddCd+IEbGalUvX//N2ME7CZlYpbwGZmiTRO+nUCNrOS8XSUZmaJRAO1gZ2AzaxU3AI2M0uk1S1gM7M0PArCzCwRd0GYmSXim3BmZom4BWxmlohbwGZmiWwKJ2AzsyQaJ/06AZtZyXgYmplZIu4DNjNLxKMgzMwSaW2gFOwEbGal0jjp1wnYzEomPAzNzCwNj4IwM0vEXRBmZol4GJqZWSKt0ThtYCdgMyuVxkm/TsBmVjLugjAzS6SRRkH0SB2AmVktRUThpSOSbpa0VtK8irK9JD0oaVH+2a9i3yWSFktqkXRSR+d3AjazUmkjCi8F3AKcvFnZxcD0iBgBTM+3kbQ/MA4YmR9znaSe1U7uBGxmpdIabYWXjkTEfwCvbFY8BpiSr08BzqwovyMiNkTEUmAxMKra+Z2AzaxUohPLNhoQEasB8s/+eflgYEVFvZV52VY5AZtZqXSmC0JSs6Q5FUvzdlxaWyirmuc9CsLMSqUzoyAiYjIwuZOXWCNpYESsljQQWJuXrwSGVtQbAqyqdiK3gM2sVGo5CmIrpgET8vUJwN0V5eMk9ZY0HBgBzK52IreAzaxUajkhu6RfAKOBfSStBC4FrgCmSjoHWA6MBYiI+ZKmAs8Cm4CJEdFa7fxOwGZWKrWcDzgiPreVXSdspf4kYFLR8zsBm1mpNNKTcE7AZlYqfiOGmVkibgGbmSXi2dDMzBLxhOxmZom0uQ/YzCwNd0GYmSXiFrCZWSJuAZuZJeIWsJlZIm3Vp1/oVpyAzaxU/CCGmVkifhTZzCwRt4DNzBJxC9jMLBE/imxmlohbwGZmibgP2MwsEbeAzcwS8ZNwZmaJuAVsZpaIR0GYmSXiLggzs0QaaTrKHqkDKKubJl/FqpVP89ST098pO+us03n6qYf4859WcPhhByWMzrrSiWdN4K/Gn8tZEyZy9pf+AYCFi5bw+eYL+Kvx5zLxokt586233ql/062/5JSzv8Tp4/4Hv338iVRhN6y2iMJLak7AdXLrrVM57fTPv6ds/vyFjD37yzzyyGOJorJUbv7hFdw55Vqm3vwvAFx6xTWcf+4Xuetn13PCxz/GT39+JwB/WPo8902fyd233cANP/g237ryR7S2Ns70it1BRBReUnMCrpNHZj3OK6+uf0/ZwoWLee65PySKyLqTZctXcsQhBwJw9JGH8eDMWQA89MhjnHLCJ9h5550ZMugD/MWQQcxd8FzKUBtOW7QVXlIr1AcsqSdwGjCs8piI+EF9wjIrD0k0X/B1JDF2zCmMHXMq++07jIdnPcbxxx3NAw8/wotr1gGw9qWXOeiAD79z7ID++7D2pXWpQm9I3aFlW1TRm3D3AH8C5gLpf22YNZCfXX8V/d+/Ny+/up4vn/81hv/lUL71tQv47tXXc8NPb2f0sUfRq1f2T3FLN5CEujrkhtY46RdU5LeFpGciovBdI0nNQHO+OTkiJm9jfI1uGHAvcABkfy75n8UM4EJgTrLILImmpqbLgDdbWlqubC/bfffd/2nw4MFntLS0jGpqaroEoKWl5bt5/d8Al7W0tDyaJGCrq6J9wPdJOrHoSSNickQckS87avLdkuaOq1iZNDU17dbU1LRH+zpwIjCvqampf17Wo0+fPucDN+SHTAPGNTU19W5qahoOjABmJwjdukDRBPwYcJektyW9LukNSa/XM7AS+AXwKNAErATOGT9+fN98/Wjg18Bv0oVnXWQAMKupqelpskT665aWlvuBzzU1NT0HLGxtbd0I/BSgpaVlPjAVeBa4H5jY0tLiYRAlVbQLYglwJjA3GqmHu5uRNCcijkgdh3Uv/rnYcRVtAS8C5jn5bjd3x9iW+OdiB1W0BXwLsC9wH7ChvdzD0MzMtl3RYWhL82XnfDEzs+1UqAVs6UmaAVwYER66ZlYSRZ+Eez9wETAS2KW9PCKOr1NcpSJpp4jYlDoOM+teit6E+zmwEBgOXA4sA35Xp5i6JUnDJC2QdJOk+ZIekLSrpEMkPSbpGUl3SeqX158h6TuSZgLnSbpF0vWSHpa0RNInJN2cn/OWiutcL2lOfo3LU31f2zaSdpP0a0lPS5on6bOSlkn6nqTZ+bJfXvczkh6X9KSkf5c0IC+/TNKU/GdsmaS/lvR9SXMl3S+pV9pvabVSNAHvHRE/ATZGxMyI+BJwVB3j6q5GANdGxEhgPXAWcCvw1fxJwbnApRX1+0bEJyLiqny7H3A8cAHZ491Xk/2v4kBJh+R1vp4PSToI+IQkz1vZWE4GVkXEwRFxANlYXoDXI2IU8CPgmrxsFnBURBwK3EH2v8x2HySbf2UMcBvwcEQcCLydl1sJFE3AG/PP1ZJOk3QoMKROMXVnSyPiqXz9CbJ/JH0jYmZeNgX4eEX9X252/D35UL65wJqImBsRbcB8sseWAc6W9HvgSbLkvH/tv4bV0VzgU3mL97iIeC0v/0XF59H5+hDgN5LmAv9I9vfd7r6I2JifryfvJvK5vPuzYg2u6CiIb0vaE/gK8EOgD1krbkezoWK9FejbQf23NttuP75ts3O1ATtJGk42R8SREfFq3jWxC9YwIuI5SYcDpwLflfRA+67KavnnD4EfRMQ0SaOByyrqbMjP1yZpY8UY/Db8JpvSKNQCjoh7I+K1iJgXEZ+MiMMjYlq9g2sArwGvSjou3x4PzKxSvyN9yJL2a3l/4CnbGZ91MUmDgD9GxG3AlcBh+a7PVny2T6yzJ/BCvj6hy4K0bqPoKIh9gX8m+69TG9kP0AURsaSOsTWKCcANkt4HLAG+uK0nioinJT1J1iWxBPhtbUK0LnQg8H8ktZF13Z0L/F+gt6THyRo9n8vrXgb8q6QXyOZbGd714VpKRZ+Eewy4lnf7scYBfx8RH61jbGalIGkZcEREeGZ1e4+iN+EUET+LiE35chuNNe+xmVm3U7QFfAXZsKs7yBLvZ4HeZK1iIuKVOsZoZlZKRRPw0orN9gPa35MSEbFvrQMzMyu7ol0QXwUOjojhZBNHPw2cFRHDnXzNzLZN0QT8TxHxuqRjgU8DtwDX1y0qM7MdQNEE3P5KlNOAGyLibjwtpZnZdimagF+QdCNwNvBvknp34lgzM9uCojfh3kc2ycjciFgkaSBwYEQ80MGhZma2FZ6Q3cwsEXcjmJkl4gRsZpaIE7CZWSJOwGZmiTgBm5kl8v8BVPH9TPjyRZoAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_heatmap(results_cm['random_forest'],'Random Forest')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}