Heart Ensemble Ant colony opt.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "79e36db9",
   "metadata": {},
   "source": [
    "\n",
    "# Prediction Of Heart Disease Using Ensemble<br>Learning & Ant Colony Optimization"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ca8238b",
   "metadata": {},
   "source": [
    "### 1. Importing Libraries\n",
    "Importing all the necessary libraries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "2faca2b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import seaborn as sns\n",
    "import re\n",
    "import random\n",
    "import math\n",
    "import time\n",
    "from datetime import timedelta\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn import tree\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.ensemble import AdaBoostClassifier, RandomForestClassifier\n",
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "from sklearn.ensemble import BaggingClassifier, ExtraTreesClassifier\n",
    "from sklearn.metrics import accuracy_score\n",
    "from scipy import spatial\n",
    "from scipy.spatial.distance import cosine\n",
    "from sklearn import svm\n",
    "from sklearn.metrics import precision_score\n",
    "from sklearn.metrics import recall_score\n",
    "from sklearn.metrics import f1_score\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7223df8",
   "metadata": {},
   "source": [
    "### 2. Loading Dataset\n",
    "Loading the required Dataset as Dataframe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "36d4328b",
   "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>age</th>\n",
       "      <th>sex</th>\n",
       "      <th>cp</th>\n",
       "      <th>trestbps</th>\n",
       "      <th>chol</th>\n",
       "      <th>fbs</th>\n",
       "      <th>restecg</th>\n",
       "      <th>thalach</th>\n",
       "      <th>exang</th>\n",
       "      <th>oldpeak</th>\n",
       "      <th>slope</th>\n",
       "      <th>ca</th>\n",
       "      <th>thal</th>\n",
       "      <th>target</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>52</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>125</td>\n",
       "      <td>212</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>168</td>\n",
       "      <td>0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>53</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>140</td>\n",
       "      <td>203</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>155</td>\n",
       "      <td>1</td>\n",
       "      <td>3.1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>70</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>145</td>\n",
       "      <td>174</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>125</td>\n",
       "      <td>1</td>\n",
       "      <td>2.6</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>61</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>148</td>\n",
       "      <td>203</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>161</td>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>62</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>138</td>\n",
       "      <td>294</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>106</td>\n",
       "      <td>0</td>\n",
       "      <td>1.9</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1020</th>\n",
       "      <td>59</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>140</td>\n",
       "      <td>221</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>164</td>\n",
       "      <td>1</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1021</th>\n",
       "      <td>60</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>125</td>\n",
       "      <td>258</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>141</td>\n",
       "      <td>1</td>\n",
       "      <td>2.8</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1022</th>\n",
       "      <td>47</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>110</td>\n",
       "      <td>275</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>118</td>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1023</th>\n",
       "      <td>50</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>110</td>\n",
       "      <td>254</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>159</td>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1024</th>\n",
       "      <td>54</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>120</td>\n",
       "      <td>188</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>113</td>\n",
       "      <td>0</td>\n",
       "      <td>1.4</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1025 rows × 14 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "      age  sex  cp  trestbps  chol  fbs  restecg  thalach  exang  oldpeak  \\\n",
       "0      52    1   0       125   212    0        1      168      0      1.0   \n",
       "1      53    1   0       140   203    1        0      155      1      3.1   \n",
       "2      70    1   0       145   174    0        1      125      1      2.6   \n",
       "3      61    1   0       148   203    0        1      161      0      0.0   \n",
       "4      62    0   0       138   294    1        1      106      0      1.9   \n",
       "...   ...  ...  ..       ...   ...  ...      ...      ...    ...      ...   \n",
       "1020   59    1   1       140   221    0        1      164      1      0.0   \n",
       "1021   60    1   0       125   258    0        0      141      1      2.8   \n",
       "1022   47    1   0       110   275    0        0      118      1      1.0   \n",
       "1023   50    0   0       110   254    0        0      159      0      0.0   \n",
       "1024   54    1   0       120   188    0        1      113      0      1.4   \n",
       "\n",
       "      slope  ca  thal  target  \n",
       "0         2   2     3       0  \n",
       "1         0   0     3       0  \n",
       "2         0   0     3       0  \n",
       "3         2   1     3       0  \n",
       "4         1   3     2       0  \n",
       "...     ...  ..   ...     ...  \n",
       "1020      2   0     2       1  \n",
       "1021      1   1     3       0  \n",
       "1022      1   1     2       0  \n",
       "1023      2   0     2       1  \n",
       "1024      1   1     3       0  \n",
       "\n",
       "[1025 rows x 14 columns]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data1 = pd.read_csv(\"heart project.csv\")\n",
    "data1\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aae8b66d",
   "metadata": {},
   "source": [
    "### 3. Data Cleaning and Preprocessing\n",
    "Replacing the column names of the dataset with their actual names.<br>\n",
    "Converting the numeric features to categorical features."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "be2dd379",
   "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>age</th>\n",
       "      <th>sex</th>\n",
       "      <th>chest pain type</th>\n",
       "      <th>resting blood pressure</th>\n",
       "      <th>cholesterol</th>\n",
       "      <th>fasting blood sugar</th>\n",
       "      <th>rest ecg</th>\n",
       "      <th>max heart rate achieved</th>\n",
       "      <th>exercise induced angina</th>\n",
       "      <th>oldpeak</th>\n",
       "      <th>st slope</th>\n",
       "      <th>no. of vessels colored</th>\n",
       "      <th>thalassemia</th>\n",
       "      <th>target</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>52</td>\n",
       "      <td>male</td>\n",
       "      <td>typical angina</td>\n",
       "      <td>125</td>\n",
       "      <td>212</td>\n",
       "      <td>Fasting Blood Sugar &lt;= 120</td>\n",
       "      <td>ST-T wave abnormality</td>\n",
       "      <td>168</td>\n",
       "      <td>no exercise induced angina</td>\n",
       "      <td>1.0</td>\n",
       "      <td>flat</td>\n",
       "      <td>2</td>\n",
       "      <td>reversible defect thalassemia</td>\n",
       "      <td>healthy</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>53</td>\n",
       "      <td>male</td>\n",
       "      <td>typical angina</td>\n",
       "      <td>140</td>\n",
       "      <td>203</td>\n",
       "      <td>Fasting Blood Sugar &gt; 120</td>\n",
       "      <td>normal</td>\n",
       "      <td>155</td>\n",
       "      <td>exercise induced angina</td>\n",
       "      <td>3.1</td>\n",
       "      <td>normal</td>\n",
       "      <td>0</td>\n",
       "      <td>reversible defect thalassemia</td>\n",
       "      <td>healthy</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>70</td>\n",
       "      <td>male</td>\n",
       "      <td>typical angina</td>\n",
       "      <td>145</td>\n",
       "      <td>174</td>\n",
       "      <td>Fasting Blood Sugar &lt;= 120</td>\n",
       "      <td>ST-T wave abnormality</td>\n",
       "      <td>125</td>\n",
       "      <td>exercise induced angina</td>\n",
       "      <td>2.6</td>\n",
       "      <td>normal</td>\n",
       "      <td>0</td>\n",
       "      <td>reversible defect thalassemia</td>\n",
       "      <td>healthy</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>61</td>\n",
       "      <td>male</td>\n",
       "      <td>typical angina</td>\n",
       "      <td>148</td>\n",
       "      <td>203</td>\n",
       "      <td>Fasting Blood Sugar &lt;= 120</td>\n",
       "      <td>ST-T wave abnormality</td>\n",
       "      <td>161</td>\n",
       "      <td>no exercise induced angina</td>\n",
       "      <td>0.0</td>\n",
       "      <td>flat</td>\n",
       "      <td>1</td>\n",
       "      <td>reversible defect thalassemia</td>\n",
       "      <td>healthy</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>62</td>\n",
       "      <td>female</td>\n",
       "      <td>typical angina</td>\n",
       "      <td>138</td>\n",
       "      <td>294</td>\n",
       "      <td>Fasting Blood Sugar &gt; 120</td>\n",
       "      <td>ST-T wave abnormality</td>\n",
       "      <td>106</td>\n",
       "      <td>no exercise induced angina</td>\n",
       "      <td>1.9</td>\n",
       "      <td>upsloping</td>\n",
       "      <td>3</td>\n",
       "      <td>fixed defect thalassemia</td>\n",
       "      <td>healthy</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1020</th>\n",
       "      <td>59</td>\n",
       "      <td>male</td>\n",
       "      <td>atypical angina</td>\n",
       "      <td>140</td>\n",
       "      <td>221</td>\n",
       "      <td>Fasting Blood Sugar &lt;= 120</td>\n",
       "      <td>ST-T wave abnormality</td>\n",
       "      <td>164</td>\n",
       "      <td>exercise induced angina</td>\n",
       "      <td>0.0</td>\n",
       "      <td>flat</td>\n",
       "      <td>0</td>\n",
       "      <td>fixed defect thalassemia</td>\n",
       "      <td>heart disease</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1021</th>\n",
       "      <td>60</td>\n",
       "      <td>male</td>\n",
       "      <td>typical angina</td>\n",
       "      <td>125</td>\n",
       "      <td>258</td>\n",
       "      <td>Fasting Blood Sugar &lt;= 120</td>\n",
       "      <td>normal</td>\n",
       "      <td>141</td>\n",
       "      <td>exercise induced angina</td>\n",
       "      <td>2.8</td>\n",
       "      <td>upsloping</td>\n",
       "      <td>1</td>\n",
       "      <td>reversible defect thalassemia</td>\n",
       "      <td>healthy</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1022</th>\n",
       "      <td>47</td>\n",
       "      <td>male</td>\n",
       "      <td>typical angina</td>\n",
       "      <td>110</td>\n",
       "      <td>275</td>\n",
       "      <td>Fasting Blood Sugar &lt;= 120</td>\n",
       "      <td>normal</td>\n",
       "      <td>118</td>\n",
       "      <td>exercise induced angina</td>\n",
       "      <td>1.0</td>\n",
       "      <td>upsloping</td>\n",
       "      <td>1</td>\n",
       "      <td>fixed defect thalassemia</td>\n",
       "      <td>healthy</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1023</th>\n",
       "      <td>50</td>\n",
       "      <td>female</td>\n",
       "      <td>typical angina</td>\n",
       "      <td>110</td>\n",
       "      <td>254</td>\n",
       "      <td>Fasting Blood Sugar &lt;= 120</td>\n",
       "      <td>normal</td>\n",
       "      <td>159</td>\n",
       "      <td>no exercise induced angina</td>\n",
       "      <td>0.0</td>\n",
       "      <td>flat</td>\n",
       "      <td>0</td>\n",
       "      <td>fixed defect thalassemia</td>\n",
       "      <td>heart disease</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1024</th>\n",
       "      <td>54</td>\n",
       "      <td>male</td>\n",
       "      <td>typical angina</td>\n",
       "      <td>120</td>\n",
       "      <td>188</td>\n",
       "      <td>Fasting Blood Sugar &lt;= 120</td>\n",
       "      <td>ST-T wave abnormality</td>\n",
       "      <td>113</td>\n",
       "      <td>no exercise induced angina</td>\n",
       "      <td>1.4</td>\n",
       "      <td>upsloping</td>\n",
       "      <td>1</td>\n",
       "      <td>reversible defect thalassemia</td>\n",
       "      <td>healthy</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1025 rows × 14 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "      age     sex  chest pain type  resting blood pressure  cholesterol  \\\n",
       "0      52    male   typical angina                     125          212   \n",
       "1      53    male   typical angina                     140          203   \n",
       "2      70    male   typical angina                     145          174   \n",
       "3      61    male   typical angina                     148          203   \n",
       "4      62  female   typical angina                     138          294   \n",
       "...   ...     ...              ...                     ...          ...   \n",
       "1020   59    male  atypical angina                     140          221   \n",
       "1021   60    male   typical angina                     125          258   \n",
       "1022   47    male   typical angina                     110          275   \n",
       "1023   50  female   typical angina                     110          254   \n",
       "1024   54    male   typical angina                     120          188   \n",
       "\n",
       "             fasting blood sugar               rest ecg  \\\n",
       "0     Fasting Blood Sugar <= 120  ST-T wave abnormality   \n",
       "1      Fasting Blood Sugar > 120                 normal   \n",
       "2     Fasting Blood Sugar <= 120  ST-T wave abnormality   \n",
       "3     Fasting Blood Sugar <= 120  ST-T wave abnormality   \n",
       "4      Fasting Blood Sugar > 120  ST-T wave abnormality   \n",
       "...                          ...                    ...   \n",
       "1020  Fasting Blood Sugar <= 120  ST-T wave abnormality   \n",
       "1021  Fasting Blood Sugar <= 120                 normal   \n",
       "1022  Fasting Blood Sugar <= 120                 normal   \n",
       "1023  Fasting Blood Sugar <= 120                 normal   \n",
       "1024  Fasting Blood Sugar <= 120  ST-T wave abnormality   \n",
       "\n",
       "      max heart rate achieved     exercise induced angina  oldpeak   st slope  \\\n",
       "0                         168  no exercise induced angina      1.0       flat   \n",
       "1                         155     exercise induced angina      3.1     normal   \n",
       "2                         125     exercise induced angina      2.6     normal   \n",
       "3                         161  no exercise induced angina      0.0       flat   \n",
       "4                         106  no exercise induced angina      1.9  upsloping   \n",
       "...                       ...                         ...      ...        ...   \n",
       "1020                      164     exercise induced angina      0.0       flat   \n",
       "1021                      141     exercise induced angina      2.8  upsloping   \n",
       "1022                      118     exercise induced angina      1.0  upsloping   \n",
       "1023                      159  no exercise induced angina      0.0       flat   \n",
       "1024                      113  no exercise induced angina      1.4  upsloping   \n",
       "\n",
       "      no. of vessels colored                    thalassemia         target  \n",
       "0                          2  reversible defect thalassemia        healthy  \n",
       "1                          0  reversible defect thalassemia        healthy  \n",
       "2                          0  reversible defect thalassemia        healthy  \n",
       "3                          1  reversible defect thalassemia        healthy  \n",
       "4                          3       fixed defect thalassemia        healthy  \n",
       "...                      ...                            ...            ...  \n",
       "1020                       0       fixed defect thalassemia  heart disease  \n",
       "1021                       1  reversible defect thalassemia        healthy  \n",
       "1022                       1       fixed defect thalassemia        healthy  \n",
       "1023                       0       fixed defect thalassemia  heart disease  \n",
       "1024                       1  reversible defect thalassemia        healthy  \n",
       "\n",
       "[1025 rows x 14 columns]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data1.columns = ['age','sex','chest pain type','resting blood pressure',\n",
    "                 'cholesterol','fasting blood sugar','rest ecg',\n",
    "                 'max heart rate achieved','exercise induced angina','oldpeak',\n",
    "                 'st slope','no. of vessels colored','thalassemia','target']\n",
    "data1['chest pain type'][data1['chest pain type'] == 0] = 'typical angina'\n",
    "data1['chest pain type'][data1['chest pain type'] == 1] = 'atypical angina'\n",
    "data1['chest pain type'][data1['chest pain type'] == 2] = 'non-anginal pain'\n",
    "data1['chest pain type'][data1['chest pain type'] == 3] = 'asymptomatic'\n",
    "\n",
    "data1['rest ecg'][data1['rest ecg'] == 0] = 'normal'\n",
    "data1['rest ecg'][data1['rest ecg'] == 1] = 'ST-T wave abnormality'\n",
    "data1['rest ecg'][data1['rest ecg'] == 2] = 'left ventricular hypertrophy'\n",
    "\n",
    "data1['st slope'][data1['st slope'] == 0] = 'normal'\n",
    "data1['st slope'][data1['st slope'] == 1] = 'upsloping'\n",
    "data1['st slope'][data1['st slope'] == 2] = 'flat'\n",
    "data1['st slope'][data1['st slope'] == 3] = 'downsloping'\n",
    "\n",
    "data1['thalassemia'][data1['thalassemia'] == 0] = 'no thalassemia'\n",
    "data1['thalassemia'][data1['thalassemia'] == 1] = 'normal thalassemia'\n",
    "data1['thalassemia'][data1['thalassemia'] == 2] = 'fixed defect thalassemia'\n",
    "data1['thalassemia'][data1['thalassemia'] == 3] = 'reversible defect thalassemia'\n",
    "\n",
    "data1['fasting blood sugar'][data1['fasting blood sugar'] == 0] = 'Fasting Blood Sugar <= 120'\n",
    "data1['fasting blood sugar'][data1['fasting blood sugar'] == 1] = 'Fasting Blood Sugar > 120'\n",
    "\n",
    "data1['exercise induced angina'][data1['exercise induced angina'] == 0] = 'no exercise induced angina'\n",
    "data1['exercise induced angina'][data1['exercise induced angina'] == 1] = 'exercise induced angina'\n",
    "\n",
    "data1['target'][data1['target'] == 0] = 'healthy'\n",
    "data1['target'][data1['target'] == 1] = 'heart disease'\n",
    "\n",
    "data1['sex'][data1['sex'] == 0] = 'female'\n",
    "data1['sex'][data1['sex'] == 1] = 'male'\n",
    "\n",
    "data1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ba56d1a",
   "metadata": {},
   "source": [
    "Checking missing entries in the dataset columnwise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "6a3771a5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "age                        0\n",
       "sex                        0\n",
       "chest pain type            0\n",
       "resting blood pressure     0\n",
       "cholesterol                0\n",
       "fasting blood sugar        0\n",
       "rest ecg                   0\n",
       "max heart rate achieved    0\n",
       "exercise induced angina    0\n",
       "oldpeak                    0\n",
       "st slope                   0\n",
       "no. of vessels colored     0\n",
       "thalassemia                0\n",
       "target                     0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data1.isna().sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee500430",
   "metadata": {},
   "source": [
    "#### This concludes that the dataset has no null values"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c0250d3",
   "metadata": {},
   "source": [
    "Describing numeric features of the dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "39cb4401",
   "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>age</th>\n",
       "      <th>resting blood pressure</th>\n",
       "      <th>cholesterol</th>\n",
       "      <th>max heart rate achieved</th>\n",
       "      <th>oldpeak</th>\n",
       "      <th>no. of vessels colored</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>1025.000000</td>\n",
       "      <td>1025.000000</td>\n",
       "      <td>1025.00000</td>\n",
       "      <td>1025.000000</td>\n",
       "      <td>1025.000000</td>\n",
       "      <td>1025.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>54.434146</td>\n",
       "      <td>131.611707</td>\n",
       "      <td>246.00000</td>\n",
       "      <td>149.114146</td>\n",
       "      <td>1.071512</td>\n",
       "      <td>0.754146</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>9.072290</td>\n",
       "      <td>17.516718</td>\n",
       "      <td>51.59251</td>\n",
       "      <td>23.005724</td>\n",
       "      <td>1.175053</td>\n",
       "      <td>1.030798</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>29.000000</td>\n",
       "      <td>94.000000</td>\n",
       "      <td>126.00000</td>\n",
       "      <td>71.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>48.000000</td>\n",
       "      <td>120.000000</td>\n",
       "      <td>211.00000</td>\n",
       "      <td>132.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>56.000000</td>\n",
       "      <td>130.000000</td>\n",
       "      <td>240.00000</td>\n",
       "      <td>152.000000</td>\n",
       "      <td>0.800000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>61.000000</td>\n",
       "      <td>140.000000</td>\n",
       "      <td>275.00000</td>\n",
       "      <td>166.000000</td>\n",
       "      <td>1.800000</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>77.000000</td>\n",
       "      <td>200.000000</td>\n",
       "      <td>564.00000</td>\n",
       "      <td>202.000000</td>\n",
       "      <td>6.200000</td>\n",
       "      <td>4.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               age  resting blood pressure  cholesterol  \\\n",
       "count  1025.000000             1025.000000   1025.00000   \n",
       "mean     54.434146              131.611707    246.00000   \n",
       "std       9.072290               17.516718     51.59251   \n",
       "min      29.000000               94.000000    126.00000   \n",
       "25%      48.000000              120.000000    211.00000   \n",
       "50%      56.000000              130.000000    240.00000   \n",
       "75%      61.000000              140.000000    275.00000   \n",
       "max      77.000000              200.000000    564.00000   \n",
       "\n",
       "       max heart rate achieved      oldpeak  no. of vessels colored  \n",
       "count              1025.000000  1025.000000             1025.000000  \n",
       "mean                149.114146     1.071512                0.754146  \n",
       "std                  23.005724     1.175053                1.030798  \n",
       "min                  71.000000     0.000000                0.000000  \n",
       "25%                 132.000000     0.000000                0.000000  \n",
       "50%                 152.000000     0.800000                0.000000  \n",
       "75%                 166.000000     1.800000                1.000000  \n",
       "max                 202.000000     6.200000                4.000000  "
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data1.describe(include =[np.number])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18c4a345",
   "metadata": {},
   "source": [
    "Describing categorical features of the dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "9d5263e7",
   "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>sex</th>\n",
       "      <th>chest pain type</th>\n",
       "      <th>fasting blood sugar</th>\n",
       "      <th>rest ecg</th>\n",
       "      <th>exercise induced angina</th>\n",
       "      <th>st slope</th>\n",
       "      <th>thalassemia</th>\n",
       "      <th>target</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>1025</td>\n",
       "      <td>1025</td>\n",
       "      <td>1025</td>\n",
       "      <td>1025</td>\n",
       "      <td>1025</td>\n",
       "      <td>1025</td>\n",
       "      <td>1025</td>\n",
       "      <td>1025</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>unique</th>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>top</th>\n",
       "      <td>male</td>\n",
       "      <td>typical angina</td>\n",
       "      <td>Fasting Blood Sugar &lt;= 120</td>\n",
       "      <td>ST-T wave abnormality</td>\n",
       "      <td>no exercise induced angina</td>\n",
       "      <td>upsloping</td>\n",
       "      <td>fixed defect thalassemia</td>\n",
       "      <td>heart disease</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>freq</th>\n",
       "      <td>713</td>\n",
       "      <td>497</td>\n",
       "      <td>872</td>\n",
       "      <td>513</td>\n",
       "      <td>680</td>\n",
       "      <td>482</td>\n",
       "      <td>544</td>\n",
       "      <td>526</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         sex chest pain type         fasting blood sugar  \\\n",
       "count   1025            1025                        1025   \n",
       "unique     2               4                           2   \n",
       "top     male  typical angina  Fasting Blood Sugar <= 120   \n",
       "freq     713             497                         872   \n",
       "\n",
       "                     rest ecg     exercise induced angina   st slope  \\\n",
       "count                    1025                        1025       1025   \n",
       "unique                      3                           2          3   \n",
       "top     ST-T wave abnormality  no exercise induced angina  upsloping   \n",
       "freq                      513                         680        482   \n",
       "\n",
       "                     thalassemia         target  \n",
       "count                       1025           1025  \n",
       "unique                         4              2  \n",
       "top     fixed defect thalassemia  heart disease  \n",
       "freq                         544            526  "
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data1.describe(include =[np.object])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "baafa154",
   "metadata": {},
   "source": [
    "### 5. ACO Feature Selection and Model Building\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c07664c7",
   "metadata": {},
   "source": [
    "Applying AdaBoost Model and calculating Accuracy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "40b782ed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy for AdaBoost:  78.53658536585367\n",
      "Precision value for AdaBoost:  0.7706422018348624\n",
      "Recall value for AdaBoost:  0.8155339805825242\n",
      "F1 score for AdaBoost:  0.7924528301886793\n"
     ]
    }
   ],
   "source": [
    "data = pd.read_csv(\"heart project.csv\")\n",
    "data_columns = data.drop(['target'],axis=1)\n",
    "label = data['target'].values\n",
    "from sklearn import preprocessing\n",
    "normalized_data = preprocessing.normalize(data_columns)\n",
    "for i in range(0,303):\n",
    "    data_columns.loc[i,('age','sex','cp','trestbps','chol','fbs','restecg','thalach','exang','oldpeak','slope',\n",
    "                        'ca','thal')]=normalized_data[i]\n",
    "    \n",
    "X_train, X_test, y_train, y_test = train_test_split(data_columns,label,test_size=0.20,random_state=42)\n",
    "clf = AdaBoostClassifier(n_estimators=10)\n",
    "clf.fit(X_train,y_train)               \n",
    "y_pred = clf.predict(X_test)\n",
    "\n",
    "acc= accuracy_score(y_test,y_pred)*100\n",
    "print(\"Accuracy for AdaBoost: \",acc)\n",
    "precision= precision_score(y_test, y_pred, average='binary')\n",
    "print('Precision value for AdaBoost: ',precision)\n",
    "recall= recall_score(y_test, y_pred, average='binary')\n",
    "print('Recall value for AdaBoost: ', recall)\n",
    "f1= f1_score(y_test, y_pred, average='binary')\n",
    "print('F1 score for AdaBoost: ', f1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b4ad676",
   "metadata": {},
   "source": [
    "Applying AdaBoost Model with ACO and calculating Accuracy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "d4bab444",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset Information(Samples, Attributes): (1025, 14)\n",
      "\n",
      "Attribute Selection based on Ant Colony Optimization:\n",
      "Designed to select attributes from a given dataset through ACO adopting the cosine similarity between attribute pairs as weight. The performance of the subsets (accuracy) through a modeling will be evaluated and at the end the set with the highest value will be presented. The pheromone update and the probability rule were developed according to the Ant-System algorithm\n",
      "--------------------\n",
      "Parameters of ACO:\n",
      "Number of Ants:\t\t\t\t\t13\n",
      "Rate of evaporation:\t\t\t\t\t0.2\n",
      "Alpha Heuristic(importance of pheromone):\t\t1\n",
      "Beta Heuristic(importance of heuristic information):\t1\n",
      "Number of iteration:\t\t\t\t\t100\n",
      "Number of Attributes to be selected:\t\t\t50\n",
      "--------------------\n",
      "Solution(sub-set) of attributes that presented the highest accuracy over 100 iterations:\n",
      " \n",
      "Accuracy for AdaBoost:  82.4390243902439\n",
      "Precision value for AdaBoost:  0.8018018018018018\n",
      "Recall value for AdaBoost:  0.8640776699029126\n",
      "F1 score for AdaBoost:  0.8317757009345795\n",
      "\n",
      "--------------------\n",
      "Code execution time:  0:00:49.890000\n"
     ]
    }
   ],
   "source": [
    "\n",
    "class Accuracy:\n",
    "\n",
    "    def __init__(self, iteration):\n",
    "        self.solution = []\n",
    "        self.accuracy = None\n",
    "\n",
    "    def setSolution(self, solution, accuracy):\n",
    "        self.solution = solution\n",
    "        self.accuracy = accuracy\n",
    "    \n",
    "    def obtainAccuracy_final(self):\n",
    "        return self.accuracy\n",
    "\n",
    "    def obtainSolution_final(self):\n",
    "        return self.solution\n",
    "\n",
    "class Edge:\n",
    "\n",
    "    def __init__(self, origin, destination, cost):\n",
    "        self.origin = origin\n",
    "        self.destination = destination\n",
    "        self.cost = cost\n",
    "        self.pheromone = None\n",
    "\n",
    "    def obtainOrigin(self):\n",
    "        return self.origin\n",
    "\n",
    "    def obtainDestination(self):\n",
    "        return self.destination\n",
    "\n",
    "    def obtainCost(self):\n",
    "        return self.cost\n",
    "\n",
    "    def obtainPheromone(self):\n",
    "        return self.pheromone\n",
    "\n",
    "    def setPheromone(self, pheromone):\n",
    "        self.pheromone = pheromone\n",
    "\n",
    "class Graph:\n",
    "\n",
    "    def __init__(self, num_vertices):\n",
    "        self.num_vertices = num_vertices\n",
    "        self.edges = {}\n",
    "        self.neighbors = {} \n",
    "        self.vertices = {}  \n",
    "\n",
    "    def addEdge(self, origin, destination, cost):\n",
    "        edge = Edge(origin=origin, destination=destination, cost=cost)\n",
    "        self.edges[(origin, destination)] = edge\n",
    "        if origin not in self.neighbors:\n",
    "            self.neighbors[origin] = [destination]\n",
    "        else:\n",
    "            self.neighbors[origin].append(destination)\n",
    "\n",
    "    def obtainCostEdge(self, origin, destination):\n",
    "        return self.edges[(origin, destination)].obtainCost()\n",
    "\n",
    "    def obtainPheromoneEdge(self, origin, destination):\n",
    "        return self.edges[(origin, destination)].obtainPheromone()\n",
    "\n",
    "    def setPheromoneEdge(self, origin, destination, pheromone):\n",
    "        self.edges[(origin, destination)].setPheromone(pheromone)\n",
    "\n",
    "    def obtainCostPath(self, path):\n",
    "        cost = 0\n",
    "        for i in range(self.num_vertices - 1):\n",
    "            cost += self.obtainCostEdge(path[i], path[i + 1])\n",
    "\n",
    "        cost += self.obtainCostEdge(path[-1], path[0])\n",
    "        return cost\n",
    "\n",
    "\n",
    "class GraphComplete(Graph):\n",
    "\n",
    "    def generate(self, matrix):\n",
    "        for i in range(self.num_vertices):\n",
    "            for j in range(self.num_vertices):\n",
    "                if i != j:\n",
    "                    weight = matrix[i][j] \n",
    "                    self.addEdge(i, j, weight)\n",
    "\n",
    "\n",
    "class Ant:\n",
    "\n",
    "    def __init__(self, city):\n",
    "        self.city = city\n",
    "        self.solution = []\n",
    "        self.cost = None\n",
    "        self.accuracy = None\n",
    "\n",
    "    def obtainCity(self):\n",
    "        return self.city\n",
    "\n",
    "    def setCity(self, city):\n",
    "        self.city = city\n",
    "\n",
    "    def obtainSolution(self):\n",
    "        return self.solution\n",
    "\n",
    "    def setSolution(self, solution, accuracy):\n",
    "\n",
    "        if not self.accuracy:\n",
    "            self.solution = solution[:]\n",
    "            self.accuracy = accuracy\n",
    "        else:\n",
    "            if accuracy < self.accuracy:\n",
    "                self.solution = solution[:]\n",
    "                self.accuracy = accuracy\n",
    "    \n",
    "    def obtainCostSolution(self):\n",
    "        return self.cost\n",
    "    \n",
    "    def obtainAccuracy(self):\n",
    "        return self.accuracy\n",
    "\n",
    "class ACO:\n",
    "\n",
    "    def __init__(self, graph, num_ants, alpha=1.0, beta=5.0, iterations=10,\n",
    "                 evaporation=0.2, num_FS=50):\n",
    "        self.graph = graph\n",
    "        self.num_ants = num_ants\n",
    "        self.alpha = alpha\n",
    "        self.beta = beta\n",
    "        self.iterations = iterations\n",
    "        self.evaporation = evaporation \n",
    "        self.num_FS = num_FS  \n",
    "        self.ants = [] \n",
    "        self.accuracies = []  \n",
    "\n",
    "        list_cities = [city for city in range(self.graph.num_vertices)]\n",
    "        for k in range(self.num_ants):\n",
    "            city_ant = random.choice(list_cities)\n",
    "            list_cities.remove(city_ant)\n",
    "            self.ants.append(Ant(city=city_ant))\n",
    "            if not list_cities:\n",
    "                list_cities = [city for city in range(self.graph.num_vertices)]\n",
    "\n",
    "        cost_greedy = 0.0  \n",
    "        vertex_initial = random.randint(1, graph.num_vertices) \n",
    "        vertex_current = vertex_initial\n",
    "        visited = [vertex_current]  \n",
    "        while True:\n",
    "            neighbors = (self.graph.neighbors[vertex_current])[:]\n",
    "            (costs, selected) = ([], {})\n",
    "            for neighbor in neighbors:\n",
    "                if neighbor not in visited:\n",
    "                    cost = self.graph.obtainCostEdge(vertex_current, neighbor)\n",
    "                    selected[cost] = neighbor\n",
    "                    costs.append(cost)\n",
    "            if len(visited) == self.graph.num_vertices:\n",
    "                break\n",
    "            min_cost = min(costs)\n",
    "\n",
    "\n",
    "            cost_greedy += min_cost \n",
    "            vertex_current = selected[min_cost] \n",
    "            visited.append(vertex_current) \n",
    "        cost_greedy += self.graph.obtainCostEdge(visited[-1], vertex_initial)\n",
    "\n",
    "        for key_edge in self.graph.edges:\n",
    "            pheromone = 1.0 / (self.graph.num_vertices * cost_greedy)\n",
    "            self.graph.setPheromoneEdge(key_edge[0], key_edge[1], pheromone)\n",
    "            \n",
    "    def print(self):\n",
    "        \n",
    "        string = \"\\nAttribute Selection based on Ant Colony Optimization:\"\n",
    "        string += \"\\nDesigned to select attributes from a given dataset through ACO adopting the cosine similarity between attribute pairs as weight. The performance of the subsets (accuracy) through a modeling will be evaluated and at the end the set with the highest value will be presented. The pheromone update and the probability rule were developed according to the Ant-System algorithm\"\n",
    "        string += \"\\n--------------------\"\n",
    "        string += \"\\nParameters of ACO:\"\n",
    "        string += \"\\nNumber of Ants:\\t\\t\\t\\t\\t{}\".format(self.num_ants)\n",
    "        string += \"\\nRate of evaporation:\\t\\t\\t\\t\\t{}\".format(self.evaporation)\n",
    "        string += \"\\nAlpha Heuristic(importance of pheromone):\\t\\t{}\".format(self.alpha)\n",
    "        string += \"\\nBeta Heuristic(importance of heuristic information):\\t{}\".format(self.beta)\n",
    "        string += \"\\nNumber of iteration:\\t\\t\\t\\t\\t{}\".format(self.iterations)\n",
    "        string += \"\\nNumber of Attributes to be selected:\\t\\t\\t{}\".format(self.num_FS)\n",
    "        string += \"\\n--------------------\"\n",
    "        \n",
    "        print(string)\n",
    "\n",
    "\n",
    "    def run(self, data_bank, target):\n",
    "        \n",
    "        for it in range(self.iterations):\n",
    "            \n",
    "            cities_visited = []\n",
    "            \n",
    "            for k in range(self.num_ants):\n",
    "                cities = [self.ants[k].obtainCity()]\n",
    "                cities_visited.append(cities)\n",
    "\n",
    "            for k in range(self.num_ants):\n",
    "                \n",
    "                for i in range(1, self.graph.num_vertices):\n",
    "\n",
    "                    cities_not_visited = list(set(self.graph.neighbors[self.ants[k].obtainCity()])-set(cities_visited[k]))\n",
    "                    \n",
    "                    summation = 0.0\n",
    "                    for city in cities_not_visited:\n",
    "                        pheromone = self.graph.obtainPheromoneEdge(self.ants[k].obtainCity(),city)\n",
    "                        distance = self.graph.obtainCostEdge(self.ants[k].obtainCity(),city)      \n",
    "                        summation += (math.pow(pheromone,self.alpha) * math.pow(1.0 / distance,self.beta))\n",
    "\n",
    "                    probabilities = {}\n",
    "                    for city in cities_not_visited:\n",
    "                        pheromone = self.graph.obtainPheromoneEdge(self.ants[k].obtainCity(),city)\n",
    "                        distance = self.graph.obtainCostEdge(self.ants[k].obtainCity(),city)\n",
    "                        probability = (math.pow(pheromone,self.alpha) * \n",
    "                                       math.pow(1.0 / distance,self.beta)) / (summation if summation > 0 else 1)\n",
    "                        probabilities[city] = probability\n",
    "                    city_selected = max(probabilities, key=probabilities.get)\n",
    "                    cities_visited[k].append(city_selected)   \n",
    "            \n",
    "            cities_visited_PD = pd.DataFrame(cities_visited)\n",
    "            List_FS = cities_visited_PD.iloc[:, 0:self.num_FS].values\n",
    "\n",
    "            X_train, X_test, y_train, y_test = train_test_split(data_bank, target,test_size=0.20,random_state=42)\n",
    "            \n",
    "            for x in range(self.num_ants): \n",
    "                clf = AdaBoostClassifier(n_estimators=10)\n",
    "                clf.fit(X_train.iloc[:,List_FS[x]],y_train)\n",
    "                \n",
    "                y_pred = clf.predict(X_test.iloc[:,List_FS[x]]) \n",
    "                self.ants[x].setSolution(List_FS[x], accuracy_score(y_test, y_pred))\n",
    "                  \n",
    "\n",
    "            best_solution = []\n",
    "            best_acc = None\n",
    "            for k in range(self.num_ants):\n",
    "                if not best_acc:\n",
    "                    best_acc = self.ants[k].obtainAccuracy()\n",
    "                else:   \n",
    "                    aux_acc = self.ants[k].obtainAccuracy()\n",
    "                    if aux_acc > best_acc:\n",
    "                        best_solution = self.ants[k].obtainSolution()\n",
    "                        best_acc = aux_acc\n",
    "    \n",
    "            self.accuracies.append(Accuracy(iteration = it))\n",
    "            self.accuracies[it].setSolution(solution = best_solution,accuracy = best_acc)\n",
    "\n",
    "            for edge in self.graph.edges:\n",
    "                sum_pheromone = 0.0\n",
    "                for k in range(self.num_ants):\n",
    "                    edges_ant = []\n",
    "                    for j in range(self.graph.num_vertices - 1):\n",
    "                        edges_ant.append((cities_visited[k][j],cities_visited[k][j + 1]))\n",
    "                    edges_ant.append((cities_visited[k][-1], cities_visited[k][0]))\n",
    "\n",
    "                    if edge in edges_ant:\n",
    "                        sum_pheromone += (1.0 / self.graph.obtainCostPath(cities_visited[k]))\n",
    "                new_pheromone = (1.0 - self.evaporation) * self.graph.obtainPheromoneEdge(edge[0], edge[1]) + sum_pheromone\n",
    "                self.graph.setPheromoneEdge(edge[0], edge[1], new_pheromone)\n",
    "                \n",
    "        solution_final = []\n",
    "        acc_final = None\n",
    "        for k in range(self.iterations):\n",
    "            if not acc_final:\n",
    "                solution_final = self.accuracies[k].obtainSolution_final()[:]\n",
    "                acc_final = self.accuracies[k].obtainAccuracy_final()\n",
    "            else:\n",
    "                aux_acc = self.accuracies[k].obtainAccuracy_final()\n",
    "                if aux_acc > acc_final:\n",
    "                    solution_final = self.accuracies[k].obtainSolution_final()[:]\n",
    "                    acc_final = self.accuracies[k].obtainAccuracy_final()\n",
    "        acc_final=acc_final*100\n",
    "        \n",
    "        print('Solution(sub-set) of attributes that presented the highest accuracy over',self.iterations,'iterations:')\n",
    "        print('%s ' % (' -> '.join(str(i) for i in solution_final)))\n",
    "        print(\"Accuracy for AdaBoost: \",acc_final)\n",
    "        precision= precision_score(y_test, y_pred, average='binary')\n",
    "        print('Precision value for AdaBoost: ',precision)\n",
    "        recall= recall_score(y_test, y_pred, average='binary')\n",
    "        print('Recall value for AdaBoost: ', recall)\n",
    "        f1= f1_score(y_test, y_pred, average='binary')\n",
    "        print('F1 score for AdaBoost: ', f1)\n",
    "        print(\"\\n--------------------\")        \n",
    "        end_time = time.monotonic()\n",
    "        print('Code execution time: ', timedelta(seconds=end_time - start_time))\n",
    "\n",
    "\n",
    "data = pd.read_csv(\"heart project.csv\")\n",
    "data_columns = data.drop(['target'],axis=1)\n",
    "label = data['target'].values\n",
    "from itertools import chain\n",
    "from sklearn import preprocessing\n",
    "normalized_data = preprocessing.normalize(data_columns)\n",
    "for i in range(0,303):\n",
    "    data_columns.loc[i,('age','sex','cp','trestbps','chol','fbs','restecg','thalach','exang','oldpeak','slope',\n",
    "                        'ca','thal')]=normalized_data[i]\n",
    "\n",
    "\n",
    "print('Dataset Information(Samples, Attributes):', data.shape)\n",
    "\n",
    "start_time = time.monotonic()\n",
    "\n",
    "def cosine_distance(v1, v2):\n",
    "    (v1_abs, v2_abs) = ([], [])\n",
    "    for i in range(0, len(v1)):\n",
    "        v1_abs.append(v1[i] * 100.0 / (v1[i] + v2[i] or 1))\n",
    "        v2_abs.append(v2[i] * 100.0 / (v1[i] + v2[i] or 1))\n",
    "\n",
    "    return 1 / (1 - spatial.distance.cosine(list(chain.from_iterable(v1_abs)), list(chain.from_iterable(v2_abs))))\n",
    "\n",
    "matrix = np.zeros((data.shape[1], data.shape[1]))\n",
    "\n",
    "for k in range(len(data.columns)):\n",
    "    data_1 = data.iloc[:, [k]].values\n",
    "    for j in range(len(data.columns)):\n",
    "        data_2 = data.iloc[:, [j]].values\n",
    "        matrix[k, j] = cosine_distance(data_1, data_2)\n",
    "        j += 1\n",
    "    k += 1\n",
    "\n",
    "df_matrix_similarity = pd.DataFrame(matrix, columns=data.columns, index=data.columns)\n",
    "\n",
    "num_vertices = 13\n",
    "\n",
    "graph_complete = GraphComplete(num_vertices=num_vertices)\n",
    "graph_complete.generate(matrix)\n",
    "\n",
    "aco2 = ACO(graph=graph_complete, num_ants=graph_complete.num_vertices, alpha=1,\n",
    "           beta=1, iterations=100,evaporation=0.2, num_FS=50)\n",
    "\n",
    "aco2.print()\n",
    "\n",
    "aco2.run(data_bank = data, target = label)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "115c46ab",
   "metadata": {},
   "source": [
    "Applying Bagging Model and calculating Accuracy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "7b819332",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy for Bagging:  93.65853658536587\n",
      "Precision value for Bagging:  0.9591836734693877\n",
      "Recall value for Bagging:  0.912621359223301\n",
      "F1 score for Bagging:  0.9353233830845772\n"
     ]
    }
   ],
   "source": [
    "data = pd.read_csv(\"heart project.csv\")\n",
    "data_columns = data.drop(['target'],axis=1)\n",
    "label = data['target'].values\n",
    "from sklearn import preprocessing\n",
    "normalized_data = preprocessing.normalize(data_columns)\n",
    "for i in range(0,303):\n",
    "    data_columns.loc[i,('age','sex','cp','trestbps','chol','fbs','restecg','thalach','exang','oldpeak','slope',\n",
    "                        'ca','thal')]=normalized_data[i]\n",
    "    \n",
    "X_train, X_test, y_train, y_test = train_test_split(data_columns,label,test_size=0.20,random_state=42)\n",
    "clf = BaggingClassifier()\n",
    "clf.fit(X_train,y_train)               \n",
    "y_pred = clf.predict(X_test)\n",
    "\n",
    "acc= accuracy_score(y_test,y_pred)*100\n",
    "print(\"Accuracy for Bagging: \",acc)\n",
    "precision= precision_score(y_test, y_pred, average='binary')\n",
    "print('Precision value for Bagging: ',precision)\n",
    "recall= recall_score(y_test, y_pred, average='binary')\n",
    "print('Recall value for Bagging: ', recall)\n",
    "f1= f1_score(y_test, y_pred, average='binary')\n",
    "print('F1 score for Bagging: ', f1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e76908d",
   "metadata": {},
   "source": [
    "Applying Bagging Model with ACO and calculating Accuracy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "4eded158",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset Information(Samples, Attributes): (1025, 14)\n",
      "\n",
      "Attribute Selection based on Ant Colony Optimization:\n",
      "Designed to select attributes from a given dataset through ACO adopting the cosine similarity between attribute pairs as weight. The performance of the subsets (accuracy) through a modeling will be evaluated and at the end the set with the highest value will be presented. The pheromone update and the probability rule were developed according to the Ant-System algorithm\n",
      "--------------------\n",
      "Parameters of ACO:\n",
      "Number of Ants:\t\t\t\t\t13\n",
      "Rate of evaporation:\t\t\t\t\t0.2\n",
      "Alpha Heuristic(importance of pheromone):\t\t1\n",
      "Beta Heuristic(importance of heuristic information):\t1\n",
      "Number of iteration:\t\t\t\t\t100\n",
      "Number of Attributes to be selected:\t\t\t10\n",
      "--------------------\n",
      "Solution(sub-set) of attributes that presented the highest accuracy over 100 iterations:\n",
      "0 -> 3 -> 4 -> 7 -> 12 -> 10 -> 1 -> 6 -> 9 -> 2 \n",
      "Accuracy for Bagging:  100.0\n",
      "Precision value for Bagging:  1.0\n",
      "Recall value for Bagging:  0.970873786407767\n",
      "F1 score for Bagging:  0.9852216748768473\n",
      "\n",
      "--------------------\n",
      "Code execution time:  0:01:07.141000\n"
     ]
    }
   ],
   "source": [
    "class Accuracy:\n",
    "\n",
    "    def __init__(self, iteration):\n",
    "        self.solution = []\n",
    "        self.accuracy = None\n",
    "\n",
    "    def setSolution(self, solution, accuracy):\n",
    "        self.solution = solution\n",
    "        self.accuracy = accuracy\n",
    "    \n",
    "    def obtainAccuracy_final(self):\n",
    "        return self.accuracy\n",
    "\n",
    "    def obtainSolution_final(self):\n",
    "        return self.solution\n",
    "\n",
    "class Edge:\n",
    "\n",
    "    def __init__(self, origin, destination, cost):\n",
    "        self.origin = origin\n",
    "        self.destination = destination\n",
    "        self.cost = cost\n",
    "        self.pheromone = None\n",
    "\n",
    "    def obtainOrigin(self):\n",
    "        return self.origin\n",
    "\n",
    "    def obtainDestination(self):\n",
    "        return self.destination\n",
    "\n",
    "    def obtainCost(self):\n",
    "        return self.cost\n",
    "\n",
    "    def obtainPheromone(self):\n",
    "        return self.pheromone\n",
    "\n",
    "    def setPheromone(self, pheromone):\n",
    "        self.pheromone = pheromone\n",
    "\n",
    "class Graph:\n",
    "\n",
    "    def __init__(self, num_vertices):\n",
    "        self.num_vertices = num_vertices\n",
    "        self.edges = {}\n",
    "        self.neighbors = {} \n",
    "        self.vertices = {}  \n",
    "\n",
    "    def addEdge(self, origin, destination, cost):\n",
    "        edge = Edge(origin=origin, destination=destination, cost=cost)\n",
    "        self.edges[(origin, destination)] = edge\n",
    "        if origin not in self.neighbors:\n",
    "            self.neighbors[origin] = [destination]\n",
    "        else:\n",
    "            self.neighbors[origin].append(destination)\n",
    "\n",
    "    def obtainCostEdge(self, origin, destination):\n",
    "        return self.edges[(origin, destination)].obtainCost()\n",
    "\n",
    "    def obtainPheromoneEdge(self, origin, destination):\n",
    "        return self.edges[(origin, destination)].obtainPheromone()\n",
    "\n",
    "    def setPheromoneEdge(self, origin, destination, pheromone):\n",
    "        self.edges[(origin, destination)].setPheromone(pheromone)\n",
    "\n",
    "    def obtainCostPath(self, path):\n",
    "        cost = 0\n",
    "        for i in range(self.num_vertices - 1):\n",
    "            cost += self.obtainCostEdge(path[i], path[i + 1])\n",
    "\n",
    "        cost += self.obtainCostEdge(path[-1], path[0])\n",
    "        return cost\n",
    "\n",
    "\n",
    "class GraphComplete(Graph):\n",
    "\n",
    "    def generate(self, matrix):\n",
    "        for i in range(self.num_vertices):\n",
    "            for j in range(self.num_vertices):\n",
    "                if i != j:\n",
    "                    weight = matrix[i][j] \n",
    "                    self.addEdge(i, j, weight)\n",
    "\n",
    "\n",
    "class Ant:\n",
    "\n",
    "    def __init__(self, city):\n",
    "        self.city = city\n",
    "        self.solution = []\n",
    "        self.cost = None\n",
    "        self.accuracy = None\n",
    "\n",
    "    def obtainCity(self):\n",
    "        return self.city\n",
    "\n",
    "    def setCity(self, city):\n",
    "        self.city = city\n",
    "\n",
    "    def obtainSolution(self):\n",
    "        return self.solution\n",
    "\n",
    "    def setSolution(self, solution, accuracy):\n",
    "\n",
    "        if not self.accuracy:\n",
    "            self.solution = solution[:]\n",
    "            self.accuracy = accuracy\n",
    "        else:\n",
    "            if accuracy < self.accuracy:\n",
    "                self.solution = solution[:]\n",
    "                self.accuracy = accuracy\n",
    "    \n",
    "    def obtainCostSolution(self):\n",
    "        return self.cost\n",
    "    \n",
    "    def obtainAccuracy(self):\n",
    "        return self.accuracy\n",
    "\n",
    "class ACO:\n",
    "\n",
    "    def __init__(self, graph, num_ants, alpha=1.0, beta=5.0, iterations=10,\n",
    "                 evaporation=0.2, num_FS=10):\n",
    "        self.graph = graph\n",
    "        self.num_ants = num_ants\n",
    "        self.alpha = alpha\n",
    "        self.beta = beta\n",
    "        self.iterations = iterations\n",
    "        self.evaporation = evaporation \n",
    "        self.num_FS = num_FS  \n",
    "        self.ants = [] \n",
    "        self.accuracies = []  \n",
    "\n",
    "        list_cities = [city for city in range(self.graph.num_vertices)]\n",
    "        for k in range(self.num_ants):\n",
    "            city_ant = random.choice(list_cities)\n",
    "            list_cities.remove(city_ant)\n",
    "            self.ants.append(Ant(city=city_ant))\n",
    "            if not list_cities:\n",
    "                list_cities = [city for city in range(self.graph.num_vertices)]\n",
    "\n",
    "        cost_greedy = 0.0  \n",
    "        vertex_initial = random.randint(1, graph.num_vertices) \n",
    "        vertex_current = vertex_initial\n",
    "        visited = [vertex_current]  \n",
    "        while True:\n",
    "            neighbors = (self.graph.neighbors[vertex_current])[:]\n",
    "            (costs, selected) = ([], {})\n",
    "            for neighbor in neighbors:\n",
    "                if neighbor not in visited:\n",
    "                    cost = self.graph.obtainCostEdge(vertex_current, neighbor)\n",
    "                    selected[cost] = neighbor\n",
    "                    costs.append(cost)\n",
    "            if len(visited) == self.graph.num_vertices:\n",
    "                break\n",
    "            min_cost = min(costs)\n",
    "\n",
    "\n",
    "            cost_greedy += min_cost \n",
    "            vertex_current = selected[min_cost] \n",
    "            visited.append(vertex_current) \n",
    "        cost_greedy += self.graph.obtainCostEdge(visited[-1], vertex_initial)\n",
    "\n",
    "        for key_edge in self.graph.edges:\n",
    "            pheromone = 1.0 / (self.graph.num_vertices * cost_greedy)\n",
    "            self.graph.setPheromoneEdge(key_edge[0], key_edge[1], pheromone)\n",
    "            \n",
    "    def print(self):\n",
    "        \n",
    "        string = \"\\nAttribute Selection based on Ant Colony Optimization:\"\n",
    "        string += \"\\nDesigned to select attributes from a given dataset through ACO adopting the cosine similarity between attribute pairs as weight. The performance of the subsets (accuracy) through a modeling will be evaluated and at the end the set with the highest value will be presented. The pheromone update and the probability rule were developed according to the Ant-System algorithm\"\n",
    "        string += \"\\n--------------------\"\n",
    "        string += \"\\nParameters of ACO:\"\n",
    "        string += \"\\nNumber of Ants:\\t\\t\\t\\t\\t{}\".format(self.num_ants)\n",
    "        string += \"\\nRate of evaporation:\\t\\t\\t\\t\\t{}\".format(self.evaporation)\n",
    "        string += \"\\nAlpha Heuristic(importance of pheromone):\\t\\t{}\".format(self.alpha)\n",
    "        string += \"\\nBeta Heuristic(importance of heuristic information):\\t{}\".format(self.beta)\n",
    "        string += \"\\nNumber of iteration:\\t\\t\\t\\t\\t{}\".format(self.iterations)\n",
    "        string += \"\\nNumber of Attributes to be selected:\\t\\t\\t{}\".format(self.num_FS)\n",
    "        string += \"\\n--------------------\"\n",
    "        \n",
    "        print(string)\n",
    "\n",
    "\n",
    "    def run(self, data_bank, target):\n",
    "        \n",
    "        for it in range(self.iterations):\n",
    "            \n",
    "            cities_visited = []\n",
    "            \n",
    "            for k in range(self.num_ants):\n",
    "                cities = [self.ants[k].obtainCity()]\n",
    "                cities_visited.append(cities)\n",
    "\n",
    "            for k in range(self.num_ants):\n",
    "                \n",
    "                for i in range(1, self.graph.num_vertices):\n",
    "\n",
    "                    cities_not_visited = list(set(self.graph.neighbors[self.ants[k].obtainCity()])-set(cities_visited[k]))\n",
    "                    \n",
    "                    summation = 0.0\n",
    "                    for city in cities_not_visited:\n",
    "                        pheromone = self.graph.obtainPheromoneEdge(self.ants[k].obtainCity(),city)\n",
    "                        distance = self.graph.obtainCostEdge(self.ants[k].obtainCity(),city)      \n",
    "                        summation += (math.pow(pheromone,self.alpha) * math.pow(1.0 / distance,self.beta))\n",
    "\n",
    "                    probabilities = {}\n",
    "                    for city in cities_not_visited:\n",
    "                        pheromone = self.graph.obtainPheromoneEdge(self.ants[k].obtainCity(),city)\n",
    "                        distance = self.graph.obtainCostEdge(self.ants[k].obtainCity(),city)\n",
    "                        probability = (math.pow(pheromone,self.alpha) * \n",
    "                                       math.pow(1.0 / distance,self.beta)) / (summation if summation > 0 else 1)\n",
    "                        probabilities[city] = probability\n",
    "                    city_selected = max(probabilities, key=probabilities.get)\n",
    "                    cities_visited[k].append(city_selected)   \n",
    "            \n",
    "            cities_visited_PD = pd.DataFrame(cities_visited)\n",
    "            List_FS = cities_visited_PD.iloc[:, 0:self.num_FS].values\n",
    "\n",
    "            X_train, X_test, y_train, y_test = train_test_split(data_bank, target,test_size=0.20,random_state=42)\n",
    "            \n",
    "            for x in range(self.num_ants): \n",
    "                clf = BaggingClassifier()\n",
    "                clf.fit(X_train.iloc[:,List_FS[x]],y_train)\n",
    "                \n",
    "                y_pred = clf.predict(X_test.iloc[:,List_FS[x]]) \n",
    "                self.ants[x].setSolution(List_FS[x], accuracy_score(y_test,y_pred))\n",
    "                  \n",
    "\n",
    "            best_solution = []\n",
    "            best_acc = None\n",
    "            for k in range(self.num_ants):\n",
    "                if not best_acc:\n",
    "                    best_acc = self.ants[k].obtainAccuracy()\n",
    "                else:   \n",
    "                    aux_acc = self.ants[k].obtainAccuracy()\n",
    "                    if aux_acc > best_acc:\n",
    "                        best_solution = self.ants[k].obtainSolution()\n",
    "                        best_acc = aux_acc\n",
    "    \n",
    "            self.accuracies.append(Accuracy(iteration = it))\n",
    "            self.accuracies[it].setSolution(solution = best_solution,accuracy = best_acc)\n",
    "\n",
    "            for edge in self.graph.edges:\n",
    "                sum_pheromone = 0.0\n",
    "                for k in range(self.num_ants):\n",
    "                    edges_ant = []\n",
    "                    for j in range(self.graph.num_vertices - 1):\n",
    "                        edges_ant.append((cities_visited[k][j],cities_visited[k][j + 1]))\n",
    "                    edges_ant.append((cities_visited[k][-1], cities_visited[k][0]))\n",
    "\n",
    "                    if edge in edges_ant:\n",
    "                        sum_pheromone += (1.0 / self.graph.obtainCostPath(cities_visited[k]))\n",
    "                new_pheromone = (1.0 - self.evaporation) * self.graph.obtainPheromoneEdge(edge[0], edge[1]) + sum_pheromone\n",
    "                self.graph.setPheromoneEdge(edge[0], edge[1], new_pheromone)\n",
    "                \n",
    "        solution_final = []\n",
    "        acc_final = None\n",
    "        for k in range(self.iterations):\n",
    "            if not acc_final:\n",
    "                solution_final = self.accuracies[k].obtainSolution_final()[:]\n",
    "                acc_final = self.accuracies[k].obtainAccuracy_final()\n",
    "            else:\n",
    "                aux_acc = self.accuracies[k].obtainAccuracy_final()\n",
    "                if aux_acc > acc_final:\n",
    "                    solution_final = self.accuracies[k].obtainSolution_final()[:]\n",
    "                    acc_final = self.accuracies[k].obtainAccuracy_final()\n",
    "        acc_final=acc_final*100\n",
    "        \n",
    "        print('Solution(sub-set) of attributes that presented the highest accuracy over',self.iterations,'iterations:')\n",
    "        print('%s ' % (' -> '.join(str(i) for i in solution_final)))\n",
    "        print(\"Accuracy for Bagging: \",acc_final)\n",
    "        precision= precision_score(y_test, y_pred, average='binary')\n",
    "        print('Precision value for Bagging: ',precision)\n",
    "        recall= recall_score(y_test, y_pred, average='binary')\n",
    "        print('Recall value for Bagging: ', recall)\n",
    "        f1= f1_score(y_test, y_pred, average='binary')\n",
    "        print('F1 score for Bagging: ', f1)\n",
    "        print(\"\\n--------------------\")        \n",
    "        end_time = time.monotonic()\n",
    "        print('Code execution time: ', timedelta(seconds=end_time - start_time))\n",
    "\n",
    "\n",
    "data = pd.read_csv(\"heart project.csv\")\n",
    "data_columns = data.drop(['target'],axis=1)\n",
    "label = data['target'].values\n",
    "from sklearn import preprocessing\n",
    "normalized_data = preprocessing.normalize(data_columns)\n",
    "for i in range(0,303):\n",
    "    data_columns.loc[i,('age','sex','cp','trestbps','chol','fbs','restecg','thalach','exang','oldpeak','slope',\n",
    "                        'ca','thal')]=normalized_data[i]\n",
    "\n",
    "\n",
    "print('Dataset Information(Samples, Attributes):', data.shape)\n",
    "\n",
    "start_time = time.monotonic()\n",
    "\n",
    "def cosine_distance(v1, v2):\n",
    "    (v1_abs, v2_abs) = ([], [])\n",
    "    for i in range(0, len(v1)):\n",
    "        v1_abs.append(v1[i] * 100.0 / (v1[i] + v2[i] or 1))\n",
    "        v2_abs.append(v2[i] * 100.0 / (v1[i] + v2[i] or 1))\n",
    "\n",
    "    return 1 / (1 - spatial.distance.cosine(list(chain.from_iterable(v1_abs)), list(chain.from_iterable(v2_abs))))\n",
    "\n",
    "matrix = np.zeros((data.shape[1], data.shape[1]))\n",
    "\n",
    "for k in range(len(data.columns)):\n",
    "    data_1 = data.iloc[:, [k]].values\n",
    "    for j in range(len(data.columns)):\n",
    "        data_2 = data.iloc[:, [j]].values\n",
    "        matrix[k, j] = cosine_distance(data_1, data_2)\n",
    "        j += 1\n",
    "    k += 1\n",
    "\n",
    "df_matrix_similarity = pd.DataFrame(matrix, columns=data.columns, index=data.columns)\n",
    "\n",
    "num_vertices = 13\n",
    "\n",
    "graph_complete = GraphComplete(num_vertices=num_vertices)\n",
    "graph_complete.generate(matrix)\n",
    "\n",
    "aco2 = ACO(graph=graph_complete, num_ants=graph_complete.num_vertices, alpha=1,\n",
    "           beta=1, iterations=100,evaporation=0.2, num_FS=10)\n",
    "\n",
    "aco2.print()\n",
    "\n",
    "aco2.run(data_bank = data, target = label)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18cd8500",
   "metadata": {},
   "source": [
    "Applying Random Forest Model and calculating Accuracy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "9cb6a17c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy for Random Forest:  96.09756097560975\n",
      "Precision value for Random Forest:  0.9797979797979798\n",
      "Recall value for Random Forest:  0.941747572815534\n",
      "F1 score for Random Forest:  0.9603960396039605\n"
     ]
    }
   ],
   "source": [
    "data = pd.read_csv(\"heart project.csv\")\n",
    "data_columns = data.drop(['target'],axis=1)\n",
    "label = data['target'].values\n",
    "from sklearn import preprocessing\n",
    "normalized_data = preprocessing.normalize(data_columns)\n",
    "for i in range(0,303):\n",
    "    data_columns.loc[i,('age','sex','cp','trestbps','chol','fbs','restecg','thalach','exang','oldpeak','slope',\n",
    "                        'ca','thal')]=normalized_data[i]\n",
    "    \n",
    "X_train, X_test, y_train, y_test = train_test_split(data_columns,label,test_size=0.20,random_state=42)\n",
    "clf = RandomForestClassifier(n_estimators=10)\n",
    "clf.fit(X_train,y_train)               \n",
    "y_pred = clf.predict(X_test)\n",
    "\n",
    "acc= accuracy_score(y_test,y_pred)*100\n",
    "print(\"Accuracy for Random Forest: \",acc)\n",
    "precision= precision_score(y_test, y_pred, average='binary')\n",
    "print('Precision value for Random Forest: ',precision)\n",
    "recall= recall_score(y_test, y_pred, average='binary')\n",
    "print('Recall value for Random Forest: ', recall)\n",
    "f1= f1_score(y_test, y_pred, average='binary')\n",
    "print('F1 score for Random Forest: ', f1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "907fc37f",
   "metadata": {},
   "source": [
    "Applying Random Forest Model with ACO and calculating Accuracy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "dcb1e000",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset Information(Samples, Attributes): (1025, 14)\n",
      "\n",
      "Attribute Selection based on Ant Colony Optimization:\n",
      "Designed to select attributes from a given dataset through ACO adopting the cosine similarity between attribute pairs as weight. The performance of the subsets (accuracy) through a modeling will be evaluated and at the end the set with the highest value will be presented. The pheromone update and the probability rule were developed according to the Ant-System algorithm\n",
      "--------------------\n",
      "Parameters of ACO:\n",
      "Number of Ants:\t\t\t\t\t13\n",
      "Rate of evaporation:\t\t\t\t\t0.2\n",
      "Alpha Heuristic(importance of pheromone):\t\t1\n",
      "Beta Heuristic(importance of heuristic information):\t1\n",
      "Number of iteration:\t\t\t\t\t100\n",
      "Number of Attributes to be selected:\t\t\t10\n",
      "--------------------\n",
      "Solution(sub-set) of attributes that presented the highest accuracy over 100 iterations:\n",
      "6 -> 3 -> 4 -> 0 -> 7 -> 12 -> 10 -> 1 -> 2 -> 9 \n",
      "Accuracy for Random Forest:  100.0\n",
      "Precision value for Random Forest:  1.0\n",
      "Recall value for Random Forest:  1.0\n",
      "F1 score for Random Forest:  1.0\n",
      "\n",
      "--------------------\n",
      "Code execution time:  0:00:53.922000\n"
     ]
    }
   ],
   "source": [
    "class Accuracy:\n",
    "\n",
    "    def __init__(self, iteration):\n",
    "        self.solution = []\n",
    "        self.accuracy = None\n",
    "\n",
    "    def setSolution(self, solution, accuracy):\n",
    "        self.solution = solution\n",
    "        self.accuracy = accuracy\n",
    "    \n",
    "    def obtainAccuracy_final(self):\n",
    "        return self.accuracy\n",
    "\n",
    "    def obtainSolution_final(self):\n",
    "        return self.solution\n",
    "\n",
    "class Edge:\n",
    "\n",
    "    def __init__(self, origin, destination, cost):\n",
    "        self.origin = origin\n",
    "        self.destination = destination\n",
    "        self.cost = cost\n",
    "        self.pheromone = None\n",
    "\n",
    "    def obtainOrigin(self):\n",
    "        return self.origin\n",
    "\n",
    "    def obtainDestination(self):\n",
    "        return self.destination\n",
    "\n",
    "    def obtainCost(self):\n",
    "        return self.cost\n",
    "\n",
    "    def obtainPheromone(self):\n",
    "        return self.pheromone\n",
    "\n",
    "    def setPheromone(self, pheromone):\n",
    "        self.pheromone = pheromone\n",
    "\n",
    "class Graph:\n",
    "\n",
    "    def __init__(self, num_vertices):\n",
    "        self.num_vertices = num_vertices\n",
    "        self.edges = {}\n",
    "        self.neighbors = {} \n",
    "        self.vertices = {}  \n",
    "\n",
    "    def addEdge(self, origin, destination, cost):\n",
    "        edge = Edge(origin=origin, destination=destination, cost=cost)\n",
    "        self.edges[(origin, destination)] = edge\n",
    "        if origin not in self.neighbors:\n",
    "            self.neighbors[origin] = [destination]\n",
    "        else:\n",
    "            self.neighbors[origin].append(destination)\n",
    "\n",
    "    def obtainCostEdge(self, origin, destination):\n",
    "        return self.edges[(origin, destination)].obtainCost()\n",
    "\n",
    "    def obtainPheromoneEdge(self, origin, destination):\n",
    "        return self.edges[(origin, destination)].obtainPheromone()\n",
    "\n",
    "    def setPheromoneEdge(self, origin, destination, pheromone):\n",
    "        self.edges[(origin, destination)].setPheromone(pheromone)\n",
    "\n",
    "    def obtainCostPath(self, path):\n",
    "        cost = 0\n",
    "        for i in range(self.num_vertices - 1):\n",
    "            cost += self.obtainCostEdge(path[i], path[i + 1])\n",
    "\n",
    "        cost += self.obtainCostEdge(path[-1], path[0])\n",
    "        return cost\n",
    "\n",
    "\n",
    "class GraphComplete(Graph):\n",
    "\n",
    "    def generate(self, matrix):\n",
    "        for i in range(self.num_vertices):\n",
    "            for j in range(self.num_vertices):\n",
    "                if i != j:\n",
    "                    weight = matrix[i][j] \n",
    "                    self.addEdge(i, j, weight)\n",
    "\n",
    "\n",
    "class Ant:\n",
    "\n",
    "    def __init__(self, city):\n",
    "        self.city = city\n",
    "        self.solution = []\n",
    "        self.cost = None\n",
    "        self.accuracy = None\n",
    "\n",
    "    def obtainCity(self):\n",
    "        return self.city\n",
    "\n",
    "    def setCity(self, city):\n",
    "        self.city = city\n",
    "\n",
    "    def obtainSolution(self):\n",
    "        return self.solution\n",
    "\n",
    "    def setSolution(self, solution, accuracy):\n",
    "\n",
    "        if not self.accuracy:\n",
    "            self.solution = solution[:]\n",
    "            self.accuracy = accuracy\n",
    "        else:\n",
    "            if accuracy < self.accuracy:\n",
    "                self.solution = solution[:]\n",
    "                self.accuracy = accuracy\n",
    "    \n",
    "    def obtainCostSolution(self):\n",
    "        return self.cost\n",
    "    \n",
    "    def obtainAccuracy(self):\n",
    "        return self.accuracy\n",
    "\n",
    "class ACO:\n",
    "\n",
    "    def __init__(self, graph, num_ants, alpha=1.0, beta=5.0, iterations=10,\n",
    "                 evaporation=0.2, num_FS=10):\n",
    "        self.graph = graph\n",
    "        self.num_ants = num_ants\n",
    "        self.alpha = alpha\n",
    "        self.beta = beta\n",
    "        self.iterations = iterations\n",
    "        self.evaporation = evaporation \n",
    "        self.num_FS = num_FS  \n",
    "        self.ants = [] \n",
    "        self.accuracies = []  \n",
    "\n",
    "        list_cities = [city for city in range(self.graph.num_vertices)]\n",
    "        for k in range(self.num_ants):\n",
    "            city_ant = random.choice(list_cities)\n",
    "            list_cities.remove(city_ant)\n",
    "            self.ants.append(Ant(city=city_ant))\n",
    "            if not list_cities:\n",
    "                list_cities = [city for city in range(self.graph.num_vertices)]\n",
    "\n",
    "        cost_greedy = 0.0  \n",
    "        vertex_initial = random.randint(1, graph.num_vertices) \n",
    "        vertex_current = vertex_initial\n",
    "        visited = [vertex_current]  \n",
    "        while True:\n",
    "            neighbors = (self.graph.neighbors[vertex_current])[:]\n",
    "            (costs, selected) = ([], {})\n",
    "            for neighbor in neighbors:\n",
    "                if neighbor not in visited:\n",
    "                    cost = self.graph.obtainCostEdge(vertex_current, neighbor)\n",
    "                    selected[cost] = neighbor\n",
    "                    costs.append(cost)\n",
    "            if len(visited) == self.graph.num_vertices:\n",
    "                break\n",
    "            min_cost = min(costs)\n",
    "\n",
    "\n",
    "            cost_greedy += min_cost \n",
    "            vertex_current = selected[min_cost] \n",
    "            visited.append(vertex_current) \n",
    "        cost_greedy += self.graph.obtainCostEdge(visited[-1], vertex_initial)\n",
    "\n",
    "        for key_edge in self.graph.edges:\n",
    "            pheromone = 1.0 / (self.graph.num_vertices * cost_greedy)\n",
    "            self.graph.setPheromoneEdge(key_edge[0], key_edge[1], pheromone)\n",
    "            \n",
    "    def print(self):\n",
    "        \n",
    "        string = \"\\nAttribute Selection based on Ant Colony Optimization:\"\n",
    "        string += \"\\nDesigned to select attributes from a given dataset through ACO adopting the cosine similarity between attribute pairs as weight. The performance of the subsets (accuracy) through a modeling will be evaluated and at the end the set with the highest value will be presented. The pheromone update and the probability rule were developed according to the Ant-System algorithm\"\n",
    "        string += \"\\n--------------------\"\n",
    "        string += \"\\nParameters of ACO:\"\n",
    "        string += \"\\nNumber of Ants:\\t\\t\\t\\t\\t{}\".format(self.num_ants)\n",
    "        string += \"\\nRate of evaporation:\\t\\t\\t\\t\\t{}\".format(self.evaporation)\n",
    "        string += \"\\nAlpha Heuristic(importance of pheromone):\\t\\t{}\".format(self.alpha)\n",
    "        string += \"\\nBeta Heuristic(importance of heuristic information):\\t{}\".format(self.beta)\n",
    "        string += \"\\nNumber of iteration:\\t\\t\\t\\t\\t{}\".format(self.iterations)\n",
    "        string += \"\\nNumber of Attributes to be selected:\\t\\t\\t{}\".format(self.num_FS)\n",
    "        string += \"\\n--------------------\"\n",
    "        \n",
    "        print(string)\n",
    "\n",
    "\n",
    "    def run(self, data_bank, target):\n",
    "        \n",
    "        for it in range(self.iterations):\n",
    "            \n",
    "            cities_visited = []\n",
    "            \n",
    "            for k in range(self.num_ants):\n",
    "                cities = [self.ants[k].obtainCity()]\n",
    "                cities_visited.append(cities)\n",
    "\n",
    "            for k in range(self.num_ants):\n",
    "                \n",
    "                for i in range(1, self.graph.num_vertices):\n",
    "\n",
    "                    cities_not_visited = list(set(self.graph.neighbors[self.ants[k].obtainCity()])-set(cities_visited[k]))\n",
    "                    \n",
    "                    summation = 0.0\n",
    "                    for city in cities_not_visited:\n",
    "                        pheromone = self.graph.obtainPheromoneEdge(self.ants[k].obtainCity(),city)\n",
    "                        distance = self.graph.obtainCostEdge(self.ants[k].obtainCity(),city)      \n",
    "                        summation += (math.pow(pheromone,self.alpha) * math.pow(1.0 / distance,self.beta))\n",
    "\n",
    "                    probabilities = {}\n",
    "                    for city in cities_not_visited:\n",
    "                        pheromone = self.graph.obtainPheromoneEdge(self.ants[k].obtainCity(),city)\n",
    "                        distance = self.graph.obtainCostEdge(self.ants[k].obtainCity(),city)\n",
    "                        probability = (math.pow(pheromone,self.alpha) * \n",
    "                                       math.pow(1.0 / distance,self.beta)) / (summation if summation > 0 else 1)\n",
    "                        probabilities[city] = probability\n",
    "                    city_selected = max(probabilities, key=probabilities.get)\n",
    "                    cities_visited[k].append(city_selected)   \n",
    "            \n",
    "            cities_visited_PD = pd.DataFrame(cities_visited)\n",
    "            List_FS = cities_visited_PD.iloc[:, 0:self.num_FS].values\n",
    "\n",
    "            X_train, X_test, y_train, y_test = train_test_split(data_bank, target,test_size=0.20,random_state=42)\n",
    "            \n",
    "            for x in range(self.num_ants): \n",
    "                clf = RandomForestClassifier(n_estimators=10)\n",
    "                clf.fit(X_train.iloc[:,List_FS[x]],y_train)\n",
    "                \n",
    "                y_pred = clf.predict(X_test.iloc[:,List_FS[x]]) \n",
    "                self.ants[x].setSolution(List_FS[x], accuracy_score(y_test,y_pred))\n",
    "                  \n",
    "\n",
    "            best_solution = []\n",
    "            best_acc = None\n",
    "            for k in range(self.num_ants):\n",
    "                if not best_acc:\n",
    "                    best_acc = self.ants[k].obtainAccuracy()\n",
    "                else:   \n",
    "                    aux_acc = self.ants[k].obtainAccuracy()\n",
    "                    if aux_acc > best_acc:\n",
    "                        best_solution = self.ants[k].obtainSolution()\n",
    "                        best_acc = aux_acc\n",
    "    \n",
    "            self.accuracies.append(Accuracy(iteration = it))\n",
    "            self.accuracies[it].setSolution(solution = best_solution,accuracy = best_acc)\n",
    "\n",
    "            for edge in self.graph.edges:\n",
    "                sum_pheromone = 0.0\n",
    "                for k in range(self.num_ants):\n",
    "                    edges_ant = []\n",
    "                    for j in range(self.graph.num_vertices - 1):\n",
    "                        edges_ant.append((cities_visited[k][j],cities_visited[k][j + 1]))\n",
    "                    edges_ant.append((cities_visited[k][-1], cities_visited[k][0]))\n",
    "\n",
    "                    if edge in edges_ant:\n",
    "                        sum_pheromone += (1.0 / self.graph.obtainCostPath(cities_visited[k]))\n",
    "                new_pheromone = (1.0 - self.evaporation) * self.graph.obtainPheromoneEdge(edge[0], edge[1]) + sum_pheromone\n",
    "                self.graph.setPheromoneEdge(edge[0], edge[1], new_pheromone)\n",
    "                \n",
    "        solution_final = []\n",
    "        acc_final = None\n",
    "        for k in range(self.iterations):\n",
    "            if not acc_final:\n",
    "                solution_final = self.accuracies[k].obtainSolution_final()[:]\n",
    "                acc_final = self.accuracies[k].obtainAccuracy_final()\n",
    "            else:\n",
    "                aux_acc = self.accuracies[k].obtainAccuracy_final()\n",
    "                if aux_acc > acc_final:\n",
    "                    solution_final = self.accuracies[k].obtainSolution_final()[:]\n",
    "                    acc_final = self.accuracies[k].obtainAccuracy_final()\n",
    "        acc_final=acc_final*100\n",
    "        \n",
    "        print('Solution(sub-set) of attributes that presented the highest accuracy over',self.iterations,'iterations:')\n",
    "        print('%s ' % (' -> '.join(str(i) for i in solution_final)))\n",
    "        print(\"Accuracy for Random Forest: \",acc_final)\n",
    "        precision= precision_score(y_test, y_pred, average='binary')\n",
    "        print('Precision value for Random Forest: ',precision)\n",
    "        recall= recall_score(y_test, y_pred, average='binary')\n",
    "        print('Recall value for Random Forest: ', recall)\n",
    "        f1= f1_score(y_test, y_pred, average='binary')\n",
    "        print('F1 score for Random Forest: ', f1)\n",
    "        print(\"\\n--------------------\")        \n",
    "        end_time = time.monotonic()\n",
    "        print('Code execution time: ', timedelta(seconds=end_time - start_time))\n",
    "\n",
    "\n",
    "data = pd.read_csv(\"heart project.csv\")\n",
    "data_columns = data.drop(['target'],axis=1)\n",
    "label = data['target'].values\n",
    "from sklearn import preprocessing\n",
    "normalized_data = preprocessing.normalize(data_columns)\n",
    "for i in range(0,303):\n",
    "    data_columns.loc[i,('age','sex','cp','trestbps','chol','fbs','restecg','thalach','exang','oldpeak','slope',\n",
    "                        'ca','thal')]=normalized_data[i]\n",
    "\n",
    "\n",
    "print('Dataset Information(Samples, Attributes):', data.shape)\n",
    "\n",
    "start_time = time.monotonic()\n",
    "\n",
    "def cosine_distance(v1, v2):\n",
    "    (v1_abs, v2_abs) = ([], [])\n",
    "    for i in range(0, len(v1)):\n",
    "        v1_abs.append(v1[i] * 100.0 / (v1[i] + v2[i] or 1))\n",
    "        v2_abs.append(v2[i] * 100.0 / (v1[i] + v2[i] or 1))\n",
    "\n",
    "    return 1 / (1 - spatial.distance.cosine(list(chain.from_iterable(v1_abs)), list(chain.from_iterable(v2_abs))))\n",
    "\n",
    "matrix = np.zeros((data.shape[1], data.shape[1]))\n",
    "\n",
    "for k in range(len(data.columns)):\n",
    "    data_1 = data.iloc[:, [k]].values\n",
    "    for j in range(len(data.columns)):\n",
    "        data_2 = data.iloc[:, [j]].values\n",
    "        matrix[k, j] = cosine_distance(data_1, data_2)\n",
    "        j += 1\n",
    "    k += 1\n",
    "\n",
    "df_matrix_similarity = pd.DataFrame(matrix, columns=data.columns, index=data.columns)\n",
    "\n",
    "num_vertices = 13\n",
    "\n",
    "graph_complete = GraphComplete(num_vertices=num_vertices)\n",
    "graph_complete.generate(matrix)\n",
    "\n",
    "aco2 = ACO(graph=graph_complete, num_ants=graph_complete.num_vertices, alpha=1,\n",
    "           beta=1, iterations=100,evaporation=0.2, num_FS=10)\n",
    "\n",
    "aco2.print()\n",
    "\n",
    "aco2.run(data_bank = data, target = label)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b36b5a92",
   "metadata": {},
   "source": [
    "Applying Gradient Boosting Model and calculating Accuracy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "a80e1139",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy for Gradient Boosting:  89.26829268292683\n",
      "Precision value for Gradient Boosting:  0.8857142857142857\n",
      "Recall value for Gradient Boosting:  0.9029126213592233\n",
      "F1 score for Gradient nBoosting:  0.8942307692307693\n"
     ]
    }
   ],
   "source": [
    "data = pd.read_csv(\"heart project.csv\")\n",
    "data_columns = data.drop(['target'],axis=1)\n",
    "label = data['target'].values\n",
    "from sklearn import preprocessing\n",
    "normalized_data = preprocessing.normalize(data_columns)\n",
    "for i in range(0,303):\n",
    "    data_columns.loc[i,('age','sex','cp','trestbps','chol','fbs','restecg','thalach','exang','oldpeak','slope',\n",
    "                        'ca','thal')]=normalized_data[i]\n",
    "    \n",
    "X_train, X_test, y_train, y_test = train_test_split(data_columns,label,test_size=0.20,random_state=42)\n",
    "clf = GradientBoostingClassifier()\n",
    "clf.fit(X_train,y_train)               \n",
    "y_pred = clf.predict(X_test)\n",
    "\n",
    "acc= accuracy_score(y_test,y_pred)*100\n",
    "print(\"Accuracy for Gradient Boosting: \",acc)\n",
    "precision= precision_score(y_test, y_pred, average='binary')\n",
    "print('Precision value for Gradient Boosting: ',precision)\n",
    "recall= recall_score(y_test, y_pred, average='binary')\n",
    "print('Recall value for Gradient Boosting: ', recall)\n",
    "f1= f1_score(y_test, y_pred, average='binary')\n",
    "print('F1 score for Gradient nBoosting: ', f1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76f00f4b",
   "metadata": {},
   "source": [
    "Applying Gradient Boosting Model with ACO and calculating Accuracy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "f93da9e2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset Information(Samples, Attributes): (1025, 14)\n",
      "\n",
      "Attribute Selection based on Ant Colony Optimization:\n",
      "Designed to select attributes from a given dataset through ACO adopting the cosine similarity between attribute pairs as weight. The performance of the subsets (accuracy) through a modeling will be evaluated and at the end the set with the highest value will be presented. The pheromone update and the probability rule were developed according to the Ant-System algorithm\n",
      "--------------------\n",
      "Parameters of ACO:\n",
      "Number of Ants:\t\t\t\t\t13\n",
      "Rate of evaporation:\t\t\t\t\t0.2\n",
      "Alpha Heuristic(importance of pheromone):\t\t1\n",
      "Beta Heuristic(importance of heuristic information):\t1\n",
      "Number of iteration:\t\t\t\t\t100\n",
      "Number of Attributes to be selected:\t\t\t10\n",
      "--------------------\n",
      "Solution(sub-set) of attributes that presented the highest accuracy over 100 iterations:\n",
      " \n",
      "Accuracy for Gradient Boosting:  95.60975609756098\n",
      "Precision value for Gradient Boosting:  0.9326923076923077\n",
      "Recall value for Gradient Boosting:  0.941747572815534\n",
      "F1 score for Gradient nBoosting:  0.9371980676328503\n",
      "\n",
      "--------------------\n",
      "Code execution time:  0:04:18.047000\n"
     ]
    }
   ],
   "source": [
    "class Accuracy:\n",
    "\n",
    "    def __init__(self, iteration):\n",
    "        self.solution = []\n",
    "        self.accuracy = None\n",
    "\n",
    "    def setSolution(self, solution, accuracy):\n",
    "        self.solution = solution\n",
    "        self.accuracy = accuracy\n",
    "    \n",
    "    def obtainAccuracy_final(self):\n",
    "        return self.accuracy\n",
    "\n",
    "    def obtainSolution_final(self):\n",
    "        return self.solution\n",
    "\n",
    "class Edge:\n",
    "\n",
    "    def __init__(self, origin, destination, cost):\n",
    "        self.origin = origin\n",
    "        self.destination = destination\n",
    "        self.cost = cost\n",
    "        self.pheromone = None\n",
    "\n",
    "    def obtainOrigin(self):\n",
    "        return self.origin\n",
    "\n",
    "    def obtainDestination(self):\n",
    "        return self.destination\n",
    "\n",
    "    def obtainCost(self):\n",
    "        return self.cost\n",
    "\n",
    "    def obtainPheromone(self):\n",
    "        return self.pheromone\n",
    "\n",
    "    def setPheromone(self, pheromone):\n",
    "        self.pheromone = pheromone\n",
    "\n",
    "class Graph:\n",
    "\n",
    "    def __init__(self, num_vertices):\n",
    "        self.num_vertices = num_vertices\n",
    "        self.edges = {}\n",
    "        self.neighbors = {} \n",
    "        self.vertices = {}  \n",
    "\n",
    "    def addEdge(self, origin, destination, cost):\n",
    "        edge = Edge(origin=origin, destination=destination, cost=cost)\n",
    "        self.edges[(origin, destination)] = edge\n",
    "        if origin not in self.neighbors:\n",
    "            self.neighbors[origin] = [destination]\n",
    "        else:\n",
    "            self.neighbors[origin].append(destination)\n",
    "\n",
    "    def obtainCostEdge(self, origin, destination):\n",
    "        return self.edges[(origin, destination)].obtainCost()\n",
    "\n",
    "    def obtainPheromoneEdge(self, origin, destination):\n",
    "        return self.edges[(origin, destination)].obtainPheromone()\n",
    "\n",
    "    def setPheromoneEdge(self, origin, destination, pheromone):\n",
    "        self.edges[(origin, destination)].setPheromone(pheromone)\n",
    "\n",
    "    def obtainCostPath(self, path):\n",
    "        cost = 0\n",
    "        for i in range(self.num_vertices - 1):\n",
    "            cost += self.obtainCostEdge(path[i], path[i + 1])\n",
    "\n",
    "        cost += self.obtainCostEdge(path[-1], path[0])\n",
    "        return cost\n",
    "\n",
    "\n",
    "class GraphComplete(Graph):\n",
    "\n",
    "    def generate(self, matrix):\n",
    "        for i in range(self.num_vertices):\n",
    "            for j in range(self.num_vertices):\n",
    "                if i != j:\n",
    "                    weight = matrix[i][j] \n",
    "                    self.addEdge(i, j, weight)\n",
    "\n",
    "\n",
    "class Ant:\n",
    "\n",
    "    def __init__(self, city):\n",
    "        self.city = city\n",
    "        self.solution = []\n",
    "        self.cost = None\n",
    "        self.accuracy = None\n",
    "\n",
    "    def obtainCity(self):\n",
    "        return self.city\n",
    "\n",
    "    def setCity(self, city):\n",
    "        self.city = city\n",
    "\n",
    "    def obtainSolution(self):\n",
    "        return self.solution\n",
    "\n",
    "    def setSolution(self, solution, accuracy):\n",
    "\n",
    "        if not self.accuracy:\n",
    "            self.solution = solution[:]\n",
    "            self.accuracy = accuracy\n",
    "        else:\n",
    "            if accuracy < self.accuracy:\n",
    "                self.solution = solution[:]\n",
    "                self.accuracy = accuracy\n",
    "    \n",
    "    def obtainCostSolution(self):\n",
    "        return self.cost\n",
    "    \n",
    "    def obtainAccuracy(self):\n",
    "        return self.accuracy\n",
    "\n",
    "class ACO:\n",
    "\n",
    "    def __init__(self, graph, num_ants, alpha=1.0, beta=5.0, iterations=10,\n",
    "                 evaporation=0.2, num_FS=10):\n",
    "        self.graph = graph\n",
    "        self.num_ants = num_ants\n",
    "        self.alpha = alpha\n",
    "        self.beta = beta\n",
    "        self.iterations = iterations\n",
    "        self.evaporation = evaporation \n",
    "        self.num_FS = num_FS  \n",
    "        self.ants = [] \n",
    "        self.accuracies = []  \n",
    "\n",
    "        list_cities = [city for city in range(self.graph.num_vertices)]\n",
    "        for k in range(self.num_ants):\n",
    "            city_ant = random.choice(list_cities)\n",
    "            list_cities.remove(city_ant)\n",
    "            self.ants.append(Ant(city=city_ant))\n",
    "            if not list_cities:\n",
    "                list_cities = [city for city in range(self.graph.num_vertices)]\n",
    "\n",
    "        cost_greedy = 0.0  \n",
    "        vertex_initial = random.randint(1, graph.num_vertices) \n",
    "        vertex_current = vertex_initial\n",
    "        visited = [vertex_current]  \n",
    "        while True:\n",
    "            neighbors = (self.graph.neighbors[vertex_current])[:]\n",
    "            (costs, selected) = ([], {})\n",
    "            for neighbor in neighbors:\n",
    "                if neighbor not in visited:\n",
    "                    cost = self.graph.obtainCostEdge(vertex_current, neighbor)\n",
    "                    selected[cost] = neighbor\n",
    "                    costs.append(cost)\n",
    "            if len(visited) == self.graph.num_vertices:\n",
    "                break\n",
    "            min_cost = min(costs)\n",
    "\n",
    "\n",
    "            cost_greedy += min_cost \n",
    "            vertex_current = selected[min_cost] \n",
    "            visited.append(vertex_current) \n",
    "        cost_greedy += self.graph.obtainCostEdge(visited[-1], vertex_initial)\n",
    "\n",
    "        for key_edge in self.graph.edges:\n",
    "            pheromone = 1.0 / (self.graph.num_vertices * cost_greedy)\n",
    "            self.graph.setPheromoneEdge(key_edge[0], key_edge[1], pheromone)\n",
    "            \n",
    "    def print(self):\n",
    "        \n",
    "        string = \"\\nAttribute Selection based on Ant Colony Optimization:\"\n",
    "        string += \"\\nDesigned to select attributes from a given dataset through ACO adopting the cosine similarity between attribute pairs as weight. The performance of the subsets (accuracy) through a modeling will be evaluated and at the end the set with the highest value will be presented. The pheromone update and the probability rule were developed according to the Ant-System algorithm\"\n",
    "        string += \"\\n--------------------\"\n",
    "        string += \"\\nParameters of ACO:\"\n",
    "        string += \"\\nNumber of Ants:\\t\\t\\t\\t\\t{}\".format(self.num_ants)\n",
    "        string += \"\\nRate of evaporation:\\t\\t\\t\\t\\t{}\".format(self.evaporation)\n",
    "        string += \"\\nAlpha Heuristic(importance of pheromone):\\t\\t{}\".format(self.alpha)\n",
    "        string += \"\\nBeta Heuristic(importance of heuristic information):\\t{}\".format(self.beta)\n",
    "        string += \"\\nNumber of iteration:\\t\\t\\t\\t\\t{}\".format(self.iterations)\n",
    "        string += \"\\nNumber of Attributes to be selected:\\t\\t\\t{}\".format(self.num_FS)\n",
    "        string += \"\\n--------------------\"\n",
    "        \n",
    "        print(string)\n",
    "\n",
    "\n",
    "    def run(self, data_bank, target):\n",
    "        \n",
    "        for it in range(self.iterations):\n",
    "            \n",
    "            cities_visited = []\n",
    "            \n",
    "            for k in range(self.num_ants):\n",
    "                cities = [self.ants[k].obtainCity()]\n",
    "                cities_visited.append(cities)\n",
    "\n",
    "            for k in range(self.num_ants):\n",
    "                \n",
    "                for i in range(1, self.graph.num_vertices):\n",
    "\n",
    "                    cities_not_visited = list(set(self.graph.neighbors[self.ants[k].obtainCity()])-set(cities_visited[k]))\n",
    "                    \n",
    "                    summation = 0.0\n",
    "                    for city in cities_not_visited:\n",
    "                        pheromone = self.graph.obtainPheromoneEdge(self.ants[k].obtainCity(),city)\n",
    "                        distance = self.graph.obtainCostEdge(self.ants[k].obtainCity(),city)      \n",
    "                        summation += (math.pow(pheromone,self.alpha) * math.pow(1.0 / distance,self.beta))\n",
    "\n",
    "                    probabilities = {}\n",
    "                    for city in cities_not_visited:\n",
    "                        pheromone = self.graph.obtainPheromoneEdge(self.ants[k].obtainCity(),city)\n",
    "                        distance = self.graph.obtainCostEdge(self.ants[k].obtainCity(),city)\n",
    "                        probability = (math.pow(pheromone,self.alpha) * \n",
    "                                       math.pow(1.0 / distance,self.beta)) / (summation if summation > 0 else 1)\n",
    "                        probabilities[city] = probability\n",
    "                    city_selected = max(probabilities, key=probabilities.get)\n",
    "                    cities_visited[k].append(city_selected)   \n",
    "            \n",
    "            cities_visited_PD = pd.DataFrame(cities_visited)\n",
    "            List_FS = cities_visited_PD.iloc[:, 0:self.num_FS].values\n",
    "\n",
    "            X_train, X_test, y_train, y_test = train_test_split(data_bank, target,test_size=0.20,random_state=42)\n",
    "            \n",
    "            for x in range(self.num_ants): \n",
    "                clf = GradientBoostingClassifier()\n",
    "                clf.fit(X_train.iloc[:,List_FS[x]],y_train)\n",
    "                \n",
    "                y_pred = clf.predict(X_test.iloc[:,List_FS[x]]) \n",
    "                self.ants[x].setSolution(List_FS[x], accuracy_score(y_test,y_pred))\n",
    "                  \n",
    "\n",
    "            best_solution = []\n",
    "            best_acc = None\n",
    "            for k in range(self.num_ants):\n",
    "                if not best_acc:\n",
    "                    best_acc = self.ants[k].obtainAccuracy()\n",
    "                else:   \n",
    "                    aux_acc = self.ants[k].obtainAccuracy()\n",
    "                    if aux_acc > best_acc:\n",
    "                        best_solution = self.ants[k].obtainSolution()\n",
    "                        best_acc = aux_acc\n",
    "    \n",
    "            self.accuracies.append(Accuracy(iteration = it))\n",
    "            self.accuracies[it].setSolution(solution = best_solution,accuracy = best_acc)\n",
    "\n",
    "            for edge in self.graph.edges:\n",
    "                sum_pheromone = 0.0\n",
    "                for k in range(self.num_ants):\n",
    "                    edges_ant = []\n",
    "                    for j in range(self.graph.num_vertices - 1):\n",
    "                        edges_ant.append((cities_visited[k][j],cities_visited[k][j + 1]))\n",
    "                    edges_ant.append((cities_visited[k][-1], cities_visited[k][0]))\n",
    "\n",
    "                    if edge in edges_ant:\n",
    "                        sum_pheromone += (1.0 / self.graph.obtainCostPath(cities_visited[k]))\n",
    "                new_pheromone = (1.0 - self.evaporation) * self.graph.obtainPheromoneEdge(edge[0], edge[1]) + sum_pheromone\n",
    "                self.graph.setPheromoneEdge(edge[0], edge[1], new_pheromone)\n",
    "                \n",
    "        solution_final = []\n",
    "        acc_final = None\n",
    "        for k in range(self.iterations):\n",
    "            if not acc_final:\n",
    "                solution_final = self.accuracies[k].obtainSolution_final()[:]\n",
    "                acc_final = self.accuracies[k].obtainAccuracy_final()\n",
    "            else:\n",
    "                aux_acc = self.accuracies[k].obtainAccuracy_final()\n",
    "                if aux_acc > acc_final:\n",
    "                    solution_final = self.accuracies[k].obtainSolution_final()[:]\n",
    "                    acc_final = self.accuracies[k].obtainAccuracy_final()\n",
    "        acc_final=acc_final*100\n",
    "        \n",
    "        print('Solution(sub-set) of attributes that presented the highest accuracy over',self.iterations,'iterations:')\n",
    "        print('%s ' % (' -> '.join(str(i) for i in solution_final)))\n",
    "        print(\"Accuracy for Gradient Boosting: \",acc_final)\n",
    "        precision= precision_score(y_test, y_pred, average='binary')\n",
    "        print('Precision value for Gradient Boosting: ',precision)\n",
    "        recall= recall_score(y_test, y_pred, average='binary')\n",
    "        print('Recall value for Gradient Boosting: ', recall)\n",
    "        f1= f1_score(y_test, y_pred, average='binary')\n",
    "        print('F1 score for Gradient nBoosting: ', f1)\n",
    "        print(\"\\n--------------------\")        \n",
    "        end_time = time.monotonic()\n",
    "        print('Code execution time: ', timedelta(seconds=end_time - start_time))\n",
    "\n",
    "\n",
    "data = pd.read_csv(\"heart project.csv\")\n",
    "data_columns = data.drop(['target'],axis=1)\n",
    "label = data['target'].values\n",
    "from sklearn import preprocessing\n",
    "normalized_data = preprocessing.normalize(data_columns)\n",
    "for i in range(0,303):\n",
    "    data_columns.loc[i,('age','sex','cp','trestbps','chol','fbs','restecg','thalach','exang','oldpeak','slope',\n",
    "                        'ca','thal')]=normalized_data[i]\n",
    "\n",
    "\n",
    "print('Dataset Information(Samples, Attributes):', data.shape)\n",
    "\n",
    "start_time = time.monotonic()\n",
    "\n",
    "def cosine_distance(v1, v2):\n",
    "    (v1_abs, v2_abs) = ([], [])\n",
    "    for i in range(0, len(v1)):\n",
    "        v1_abs.append(v1[i] * 100.0 / (v1[i] + v2[i] or 1))\n",
    "        v2_abs.append(v2[i] * 100.0 / (v1[i] + v2[i] or 1))\n",
    "\n",
    "    return 1 / (1 - spatial.distance.cosine(list(chain.from_iterable(v1_abs)), list(chain.from_iterable(v2_abs))))\n",
    "\n",
    "matrix = np.zeros((data.shape[1], data.shape[1]))\n",
    "\n",
    "for k in range(len(data.columns)):\n",
    "    data_1 = data.iloc[:, [k]].values\n",
    "    for j in range(len(data.columns)):\n",
    "        data_2 = data.iloc[:, [j]].values\n",
    "        matrix[k, j] = cosine_distance(data_1, data_2)\n",
    "        j += 1\n",
    "    k += 1\n",
    "\n",
    "df_matrix_similarity = pd.DataFrame(matrix, columns=data.columns, index=data.columns)\n",
    "\n",
    "num_vertices = 13\n",
    "\n",
    "graph_complete = GraphComplete(num_vertices=num_vertices)\n",
    "graph_complete.generate(matrix)\n",
    "\n",
    "aco2 = ACO(graph=graph_complete, num_ants=graph_complete.num_vertices, alpha=1,\n",
    "           beta=1, iterations=100,evaporation=0.2, num_FS=10)\n",
    "\n",
    "aco2.print()\n",
    "\n",
    "aco2.run(data_bank = data, target = label)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "256168c9",
   "metadata": {},
   "source": [
    "Applying Extra Trees Model and calculating Accuracy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "907a0ff8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy for Extra Trees:  95.1219512195122\n",
      "Precision value for Extra Trees:  0.9603960396039604\n",
      "Recall value for Extra Trees:  0.941747572815534\n",
      "F1 score for Extra Trees:  0.9509803921568628\n"
     ]
    }
   ],
   "source": [
    "data = pd.read_csv(\"heart project.csv\")\n",
    "data_columns = data.drop(['target'],axis=1)\n",
    "label = data['target'].values\n",
    "from sklearn import preprocessing\n",
    "normalized_data = preprocessing.normalize(data_columns)\n",
    "for i in range(0,303):\n",
    "    data_columns.loc[i,('age','sex','cp','trestbps','chol','fbs','restecg','thalach','exang','oldpeak','slope',\n",
    "                        'ca','thal')]=normalized_data[i]\n",
    "    \n",
    "X_train, X_test, y_train, y_test = train_test_split(data_columns,label,test_size=0.20,random_state=42)\n",
    "clf = ExtraTreesClassifier()\n",
    "clf.fit(X_train,y_train)               \n",
    "y_pred = clf.predict(X_test)\n",
    "\n",
    "acc= accuracy_score(y_test,y_pred)*100\n",
    "print(\"Accuracy for Extra Trees: \",acc)\n",
    "precision= precision_score(y_test, y_pred, average='binary')\n",
    "print('Precision value for Extra Trees: ',precision)\n",
    "recall= recall_score(y_test, y_pred, average='binary')\n",
    "print('Recall value for Extra Trees: ', recall)\n",
    "f1= f1_score(y_test, y_pred, average='binary')\n",
    "print('F1 score for Extra Trees: ', f1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "311ffdce",
   "metadata": {},
   "source": [
    "Applying Extra Trees Model with ACO and calculating Accuracy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "209ca589",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset Information(Samples, Attributes): (1025, 14)\n",
      "\n",
      "Attribute Selection based on Ant Colony Optimization:\n",
      "Designed to select attributes from a given dataset through ACO adopting the cosine similarity between attribute pairs as weight. The performance of the subsets (accuracy) through a modeling will be evaluated and at the end the set with the highest value will be presented. The pheromone update and the probability rule were developed according to the Ant-System algorithm\n",
      "--------------------\n",
      "Parameters of ACO:\n",
      "Number of Ants:\t\t\t\t\t13\n",
      "Rate of evaporation:\t\t\t\t\t0.2\n",
      "Alpha Heuristic(importance of pheromone):\t\t1\n",
      "Beta Heuristic(importance of heuristic information):\t1\n",
      "Number of iteration:\t\t\t\t\t100\n",
      "Number of Attributes to be selected:\t\t\t10\n",
      "--------------------\n",
      "Solution(sub-set) of attributes that presented the highest accuracy over 100 iterations:\n",
      " \n",
      "Accuracy for Extra Trees:  100.0\n",
      "Precision value for Extra Trees:  1.0\n",
      "Recall value for Extra Trees:  0.970873786407767\n",
      "F1 score for Extra Trees:  0.9852216748768473\n",
      "\n",
      "--------------------\n",
      "Code execution time:  0:05:03.047000\n"
     ]
    }
   ],
   "source": [
    "class Accuracy:\n",
    "\n",
    "    def __init__(self, iteration):\n",
    "        self.solution = []\n",
    "        self.accuracy = None\n",
    "\n",
    "    def setSolution(self, solution, accuracy):\n",
    "        self.solution = solution\n",
    "        self.accuracy = accuracy\n",
    "    \n",
    "    def obtainAccuracy_final(self):\n",
    "        return self.accuracy\n",
    "\n",
    "    def obtainSolution_final(self):\n",
    "        return self.solution\n",
    "\n",
    "class Edge:\n",
    "\n",
    "    def __init__(self, origin, destination, cost):\n",
    "        self.origin = origin\n",
    "        self.destination = destination\n",
    "        self.cost = cost\n",
    "        self.pheromone = None\n",
    "\n",
    "    def obtainOrigin(self):\n",
    "        return self.origin\n",
    "\n",
    "    def obtainDestination(self):\n",
    "        return self.destination\n",
    "\n",
    "    def obtainCost(self):\n",
    "        return self.cost\n",
    "\n",
    "    def obtainPheromone(self):\n",
    "        return self.pheromone\n",
    "\n",
    "    def setPheromone(self, pheromone):\n",
    "        self.pheromone = pheromone\n",
    "\n",
    "class Graph:\n",
    "\n",
    "    def __init__(self, num_vertices):\n",
    "        self.num_vertices = num_vertices\n",
    "        self.edges = {}\n",
    "        self.neighbors = {} \n",
    "        self.vertices = {}  \n",
    "\n",
    "    def addEdge(self, origin, destination, cost):\n",
    "        edge = Edge(origin=origin, destination=destination, cost=cost)\n",
    "        self.edges[(origin, destination)] = edge\n",
    "        if origin not in self.neighbors:\n",
    "            self.neighbors[origin] = [destination]\n",
    "        else:\n",
    "            self.neighbors[origin].append(destination)\n",
    "\n",
    "    def obtainCostEdge(self, origin, destination):\n",
    "        return self.edges[(origin, destination)].obtainCost()\n",
    "\n",
    "    def obtainPheromoneEdge(self, origin, destination):\n",
    "        return self.edges[(origin, destination)].obtainPheromone()\n",
    "\n",
    "    def setPheromoneEdge(self, origin, destination, pheromone):\n",
    "        self.edges[(origin, destination)].setPheromone(pheromone)\n",
    "\n",
    "    def obtainCostPath(self, path):\n",
    "        cost = 0\n",
    "        for i in range(self.num_vertices - 1):\n",
    "            cost += self.obtainCostEdge(path[i], path[i + 1])\n",
    "\n",
    "        cost += self.obtainCostEdge(path[-1], path[0])\n",
    "        return cost\n",
    "\n",
    "\n",
    "class GraphComplete(Graph):\n",
    "\n",
    "    def generate(self, matrix):\n",
    "        for i in range(self.num_vertices):\n",
    "            for j in range(self.num_vertices):\n",
    "                if i != j:\n",
    "                    weight = matrix[i][j] \n",
    "                    self.addEdge(i, j, weight)\n",
    "\n",
    "\n",
    "class Ant:\n",
    "\n",
    "    def __init__(self, city):\n",
    "        self.city = city\n",
    "        self.solution = []\n",
    "        self.cost = None\n",
    "        self.accuracy = None\n",
    "\n",
    "    def obtainCity(self):\n",
    "        return self.city\n",
    "\n",
    "    def setCity(self, city):\n",
    "        self.city = city\n",
    "\n",
    "    def obtainSolution(self):\n",
    "        return self.solution\n",
    "\n",
    "    def setSolution(self, solution, accuracy):\n",
    "\n",
    "        if not self.accuracy:\n",
    "            self.solution = solution[:]\n",
    "            self.accuracy = accuracy\n",
    "        else:\n",
    "            if accuracy < self.accuracy:\n",
    "                self.solution = solution[:]\n",
    "                self.accuracy = accuracy\n",
    "    \n",
    "    def obtainCostSolution(self):\n",
    "        return self.cost\n",
    "    \n",
    "    def obtainAccuracy(self):\n",
    "        return self.accuracy\n",
    "\n",
    "class ACO:\n",
    "\n",
    "    def __init__(self, graph, num_ants, alpha=1.0, beta=5.0, iterations=10,\n",
    "                 evaporation=0.2, num_FS=10):\n",
    "        self.graph = graph\n",
    "        self.num_ants = num_ants\n",
    "        self.alpha = alpha\n",
    "        self.beta = beta\n",
    "        self.iterations = iterations\n",
    "        self.evaporation = evaporation \n",
    "        self.num_FS = num_FS  \n",
    "        self.ants = [] \n",
    "        self.accuracies = []  \n",
    "\n",
    "        list_cities = [city for city in range(self.graph.num_vertices)]\n",
    "        for k in range(self.num_ants):\n",
    "            city_ant = random.choice(list_cities)\n",
    "            list_cities.remove(city_ant)\n",
    "            self.ants.append(Ant(city=city_ant))\n",
    "            if not list_cities:\n",
    "                list_cities = [city for city in range(self.graph.num_vertices)]\n",
    "\n",
    "        cost_greedy = 0.0  \n",
    "        vertex_initial = random.randint(1, graph.num_vertices) \n",
    "        vertex_current = vertex_initial\n",
    "        visited = [vertex_current]  \n",
    "        while True:\n",
    "            neighbors = (self.graph.neighbors[vertex_current])[:]\n",
    "            (costs, selected) = ([], {})\n",
    "            for neighbor in neighbors:\n",
    "                if neighbor not in visited:\n",
    "                    cost = self.graph.obtainCostEdge(vertex_current, neighbor)\n",
    "                    selected[cost] = neighbor\n",
    "                    costs.append(cost)\n",
    "            if len(visited) == self.graph.num_vertices:\n",
    "                break\n",
    "            min_cost = min(costs)\n",
    "\n",
    "\n",
    "            cost_greedy += min_cost \n",
    "            vertex_current = selected[min_cost] \n",
    "            visited.append(vertex_current) \n",
    "        cost_greedy += self.graph.obtainCostEdge(visited[-1], vertex_initial)\n",
    "\n",
    "        for key_edge in self.graph.edges:\n",
    "            pheromone = 1.0 / (self.graph.num_vertices * cost_greedy)\n",
    "            self.graph.setPheromoneEdge(key_edge[0], key_edge[1], pheromone)\n",
    "            \n",
    "    def print(self):\n",
    "        \n",
    "        string = \"\\nAttribute Selection based on Ant Colony Optimization:\"\n",
    "        string += \"\\nDesigned to select attributes from a given dataset through ACO adopting the cosine similarity between attribute pairs as weight. The performance of the subsets (accuracy) through a modeling will be evaluated and at the end the set with the highest value will be presented. The pheromone update and the probability rule were developed according to the Ant-System algorithm\"\n",
    "        string += \"\\n--------------------\"\n",
    "        string += \"\\nParameters of ACO:\"\n",
    "        string += \"\\nNumber of Ants:\\t\\t\\t\\t\\t{}\".format(self.num_ants)\n",
    "        string += \"\\nRate of evaporation:\\t\\t\\t\\t\\t{}\".format(self.evaporation)\n",
    "        string += \"\\nAlpha Heuristic(importance of pheromone):\\t\\t{}\".format(self.alpha)\n",
    "        string += \"\\nBeta Heuristic(importance of heuristic information):\\t{}\".format(self.beta)\n",
    "        string += \"\\nNumber of iteration:\\t\\t\\t\\t\\t{}\".format(self.iterations)\n",
    "        string += \"\\nNumber of Attributes to be selected:\\t\\t\\t{}\".format(self.num_FS)\n",
    "        string += \"\\n--------------------\"\n",
    "        \n",
    "        print(string)\n",
    "\n",
    "\n",
    "    def run(self, data_bank, target):\n",
    "        \n",
    "        for it in range(self.iterations):\n",
    "            \n",
    "            cities_visited = []\n",
    "            \n",
    "            for k in range(self.num_ants):\n",
    "                cities = [self.ants[k].obtainCity()]\n",
    "                cities_visited.append(cities)\n",
    "\n",
    "            for k in range(self.num_ants):\n",
    "                \n",
    "                for i in range(1, self.graph.num_vertices):\n",
    "\n",
    "                    cities_not_visited = list(set(self.graph.neighbors[self.ants[k].obtainCity()])-set(cities_visited[k]))\n",
    "                    \n",
    "                    summation = 0.0\n",
    "                    for city in cities_not_visited:\n",
    "                        pheromone = self.graph.obtainPheromoneEdge(self.ants[k].obtainCity(),city)\n",
    "                        distance = self.graph.obtainCostEdge(self.ants[k].obtainCity(),city)      \n",
    "                        summation += (math.pow(pheromone,self.alpha) * math.pow(1.0 / distance,self.beta))\n",
    "\n",
    "                    probabilities = {}\n",
    "                    for city in cities_not_visited:\n",
    "                        pheromone = self.graph.obtainPheromoneEdge(self.ants[k].obtainCity(),city)\n",
    "                        distance = self.graph.obtainCostEdge(self.ants[k].obtainCity(),city)\n",
    "                        probability = (math.pow(pheromone,self.alpha) * \n",
    "                                       math.pow(1.0 / distance,self.beta)) / (summation if summation > 0 else 1)\n",
    "                        probabilities[city] = probability\n",
    "                    city_selected = max(probabilities, key=probabilities.get)\n",
    "                    cities_visited[k].append(city_selected)   \n",
    "            \n",
    "            cities_visited_PD = pd.DataFrame(cities_visited)\n",
    "            List_FS = cities_visited_PD.iloc[:, 0:self.num_FS].values\n",
    "\n",
    "            X_train, X_test, y_train, y_test = train_test_split(data_bank, target,test_size=0.20,random_state=42)\n",
    "            \n",
    "            for x in range(self.num_ants): \n",
    "                clf = ExtraTreesClassifier()\n",
    "                clf.fit(X_train.iloc[:,List_FS[x]],y_train)\n",
    "                \n",
    "                y_pred = clf.predict(X_test.iloc[:,List_FS[x]]) \n",
    "                self.ants[x].setSolution(List_FS[x], accuracy_score(y_test,y_pred))\n",
    "                  \n",
    "\n",
    "            best_solution = []\n",
    "            best_acc = None\n",
    "            for k in range(self.num_ants):\n",
    "                if not best_acc:\n",
    "                    best_acc = self.ants[k].obtainAccuracy()\n",
    "                else:   \n",
    "                    aux_acc = self.ants[k].obtainAccuracy()\n",
    "                    if aux_acc > best_acc:\n",
    "                        best_solution = self.ants[k].obtainSolution()\n",
    "                        best_acc = aux_acc\n",
    "    \n",
    "            self.accuracies.append(Accuracy(iteration = it))\n",
    "            self.accuracies[it].setSolution(solution = best_solution,accuracy = best_acc)\n",
    "\n",
    "            for edge in self.graph.edges:\n",
    "                sum_pheromone = 0.0\n",
    "                for k in range(self.num_ants):\n",
    "                    edges_ant = []\n",
    "                    for j in range(self.graph.num_vertices - 1):\n",
    "                        edges_ant.append((cities_visited[k][j],cities_visited[k][j + 1]))\n",
    "                    edges_ant.append((cities_visited[k][-1], cities_visited[k][0]))\n",
    "\n",
    "                    if edge in edges_ant:\n",
    "                        sum_pheromone += (1.0 / self.graph.obtainCostPath(cities_visited[k]))\n",
    "                new_pheromone = (1.0 - self.evaporation) * self.graph.obtainPheromoneEdge(edge[0], edge[1]) + sum_pheromone\n",
    "                self.graph.setPheromoneEdge(edge[0], edge[1], new_pheromone)\n",
    "                \n",
    "        solution_final = []\n",
    "        acc_final = None\n",
    "        for k in range(self.iterations):\n",
    "            if not acc_final:\n",
    "                solution_final = self.accuracies[k].obtainSolution_final()[:]\n",
    "                acc_final = self.accuracies[k].obtainAccuracy_final()\n",
    "            else:\n",
    "                aux_acc = self.accuracies[k].obtainAccuracy_final()\n",
    "                if aux_acc > acc_final:\n",
    "                    solution_final = self.accuracies[k].obtainSolution_final()[:]\n",
    "                    acc_final = self.accuracies[k].obtainAccuracy_final()\n",
    "        acc_final=acc_final*100\n",
    "        \n",
    "        print('Solution(sub-set) of attributes that presented the highest accuracy over',self.iterations,'iterations:')\n",
    "        print('%s ' % (' -> '.join(str(i) for i in solution_final)))\n",
    "        print(\"Accuracy for Extra Trees: \",acc_final)\n",
    "        precision= precision_score(y_test, y_pred, average='binary')\n",
    "        print('Precision value for Extra Trees: ',precision)\n",
    "        recall= recall_score(y_test, y_pred, average='binary')\n",
    "        print('Recall value for Extra Trees: ', recall)\n",
    "        f1= f1_score(y_test, y_pred, average='binary')\n",
    "        print('F1 score for Extra Trees: ', f1)\n",
    "        print(\"\\n--------------------\")        \n",
    "        end_time = time.monotonic()\n",
    "        print('Code execution time: ', timedelta(seconds=end_time - start_time))\n",
    "\n",
    "\n",
    "data = pd.read_csv(\"heart project.csv\")\n",
    "data_columns = data.drop(['target'],axis=1)\n",
    "label = data['target'].values\n",
    "from sklearn import preprocessing\n",
    "normalized_data = preprocessing.normalize(data_columns)\n",
    "for i in range(0,303):\n",
    "    data_columns.loc[i,('age','sex','cp','trestbps','chol','fbs','restecg','thalach','exang','oldpeak','slope',\n",
    "                        'ca','thal')]=normalized_data[i]\n",
    "\n",
    "\n",
    "print('Dataset Information(Samples, Attributes):', data.shape)\n",
    "\n",
    "start_time = time.monotonic()\n",
    "\n",
    "def cosine_distance(v1, v2):\n",
    "    (v1_abs, v2_abs) = ([], [])\n",
    "    for i in range(0, len(v1)):\n",
    "        v1_abs.append(v1[i] * 100.0 / (v1[i] + v2[i] or 1))\n",
    "        v2_abs.append(v2[i] * 100.0 / (v1[i] + v2[i] or 1))\n",
    "\n",
    "    return 1 / (1 - spatial.distance.cosine(list(chain.from_iterable(v1_abs)), list(chain.from_iterable(v2_abs))))\n",
    "\n",
    "matrix = np.zeros((data.shape[1], data.shape[1]))\n",
    "\n",
    "for k in range(len(data.columns)):\n",
    "    data_1 = data.iloc[:, [k]].values\n",
    "    for j in range(len(data.columns)):\n",
    "        data_2 = data.iloc[:, [j]].values\n",
    "        matrix[k, j] = cosine_distance(data_1, data_2)\n",
    "        j += 1\n",
    "    k += 1\n",
    "\n",
    "df_matrix_similarity = pd.DataFrame(matrix, columns=data.columns, index=data.columns)\n",
    "\n",
    "num_vertices = 13\n",
    "\n",
    "graph_complete = GraphComplete(num_vertices=num_vertices)\n",
    "graph_complete.generate(matrix)\n",
    "\n",
    "aco2 = ACO(graph=graph_complete, num_ants=graph_complete.num_vertices, alpha=1,\n",
    "           beta=1, iterations=100,evaporation=0.2, num_FS=10)\n",
    "\n",
    "aco2.print()\n",
    "\n",
    "aco2.run(data_bank = data, target = label)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9ddb5df",
   "metadata": {},
   "source": [
    "Comparison of Accuracy, Precision, Recall and F1 score for all the above models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "316cad6a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "sns.set()\n",
    "n= 5\n",
    "x = [0.7853658536585367 , 0.946341463414634 , 0.9219512195121952 , 0.8926829268292683 ,  0.901639344262295 ]\n",
    "y = [0.7706422018348624, 0.9509803921568627, 0.9306930693069307, 0.8857142857142857, 0.90625 ]\n",
    "z = [ 0.8155339805825242 , 0.941747572815534 ,  0.912621359223301 , 0.9029126213592233 , 0.90625]\n",
    "w = [ 0.7924528301886793 , 0.9463414634146341 , 0.9215686274509804,  0.8942307692307693 , 0.90625]\n",
    "index = np.arange(n)\n",
    "bar_width = 0.15\n",
    "opacity = 0.9\n",
    "\n",
    "r1 = plt.bar(index, x, bar_width,\n",
    "alpha=opacity, color='b', label='Accuracy')\n",
    " \n",
    "r2 = plt.bar(index + bar_width,y, bar_width,\n",
    "alpha=opacity, color='r', label='Precision')\n",
    "\n",
    "r3 = plt.bar(index + (2*bar_width),z, bar_width,\n",
    "alpha=opacity, color='y', label='Recall')\n",
    "\n",
    "r4 = plt.bar(index + (3*bar_width),w, bar_width,\n",
    "alpha=opacity, color='g', label='F1 Score')\n",
    "plt.xticks(index + (bar_width),('AdaBoost','Bagging','Random\\nForest','Gradient\\nBoosting','Extra\\nTrees'))\n",
    "\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "a1d811df",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiYAAAHBCAYAAABdZ3DhAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAABiP0lEQVR4nO3deXxM18MG8OfOJDPZI0mREHsbkQhCiIhSVK1F/exLaay176pqrVqjiKX2pVRR+1oNSumrtqooYgmyIIk9ss0kM+f9IzI1JsiExE08388nbebec+49c8/M9eQu50pCCAEiIiIiGVC87QYQERERZWIwISIiItlgMCEiIiLZYDAhIiIi2WAwISIiItlgMCEiIiLZYDAhIiIi2WAwISIiItlgMCEiIiLZsHjbDTCXEAJ6ff4arFahkPJdmwsi9oM8sB/kgf0gD+9KPygUEiRJylbZfBdM9HqBBw+S3nYzss3CQgEnJ1skJCQjPV3/tpvzzmI/yAP7QR7YD/LwLvWDs7MtlMrsBROeyiEiIiLZYDAhIiIi2WAwISIiItlgMCEiIiLZYDAhIiIi2WAwISIiItlgMCEiIiLZYDAhIiIi2WAwISIiItlgMCEiIiLZeK1gsmjRInTt2vWlZR4+fIjhw4ejevXqqF69OsaNG4fk5OTXWS0REREVUDkOJqtXr0ZISMgryw0aNAjR0dGG8n/++ScmTZqU09USERFRAWb2Q/zi4uIwduxYnDlzBmXKlHlp2bNnz+LkyZPYu3cvypUrBwCYPHkyevbsiWHDhqFo0aI5azUREREVSGYfMblw4QIcHR2xc+dOVK5c+aVlT58+jcKFCxtCCQDUqFEDkiThzJkz5reWiIiICjSzj5jUr18f9evXz1bZuLg4uLm5GU1TqVQoVKgQ7ty5Y+6qDSws8s81u0qlwuj/9GqSJEHK3tOxs6oNQJhMzdz+lpZKKBSmCxcCEMK03rvsbfTDi+q9zjqz413rf+6XzMf9Ut4xO5iYIyUlBSqVymS6Wq2GRqPJ0TIVCglOTrav27Q85+Bg/babkG9o03TQ6XP2ZVRBD+j1Wc7TpaTCWgkgi52xpFRAkcVn9V32VvpBpcjxjlgHCfoc1lUoFFApLXNUNz/jfin7uF/KO7kaTKysrKDVak2mazQa2NjY5GiZer1AQkL+uatHqVTAwcEaCQkp0Omy/mDSfxQKCZZqSyzbfh6x95PMqutd1gUdPiqD68tWIjUuzmS+JElZ/qNnVbQoyvYMwpOUZOhzuOMpaN5GPzh4VUCJ9q0RdWkHNCn3zVqnXaEyeK/MR1j59ybEJ5lXt4itC76o2g6PE9Pemf7nfsk83C+9PgcH62wfocvVYOLq6ooDBw4YTdNqtXj06NFrXfianp7/vkg6nT5ftjuvKZUKWAK4cz8JMfGJZtUt4pwRdlPj4pAcfctoniT9twN4fh+Q+VqnE9xJP/U2+kFdpAgAQJNyH6mJ8WatU23lDACIT7yPWwlmniZ+2pZ3sf+5X8oe7pfyVq6eYKxevTpiY2MRGRlpmHbixAkAQNWqVXNz1URERJQPvdFgotPpcPfuXaSmpgIAKleujKpVq2Lo0KEICwvDX3/9hQkTJqBVq1a8VZiIiIhMvNFgcufOHdSuXRt79+4FkHGIasGCBXB3d0e3bt0wZMgQ1KlTBxMnTnyTqyV6qxQKCUqlIkc/Wd+ZQkT0evLzfum1rjGZPn260Wt3d3dcvnzZaJqLi0u2Roglyo8UCgm2DpY5vxtEkpCU8O5cdElEuS+/75dy9eJXooJOkjJuUV19dhPiE++ZVbeI3Xvo7tsOkvQ6Y3cQERnL7/slBhOiNyA+8R5uJcS+7WYQERnk1/0Sh/0jIiIi2eAREyIAkAClUoK5WV2plMDLV4koV7yj+yUGE3rnWTjYQ7JUwtZCwPxzqhLSIYB8vRsgIrl5l/dLDCb0zrOwtgYgEB2+HZrkB2bVtXPKGAqdiOhNepf3SwwmRE9pUh4gNcnModCtnXOpNURE7+Z+iRe/EhERkWzwiAkRkYwpFNLTMSXMJ4Tg4H2U7zCYEBHJlEIhwdbO6vVG8ExMZTihfIXBhIhIpjJH8Fy6/Txi7yeZVdfVxRa9W/lwZGHKdxhMiIhkLvZ+EmLiE992M4jyBC9+JSIiItngERMiIjLCC27pbWIwISIiA4VCgqODCoA+p0vA4wQtwwnlGIMJEREZZBwp0SM6fIfZI46qbZxRwrMlLCwU0OnMDyY82kIAgwkRUYElIeuHwCkUkuH/SqXxvIzygCbZ/BFHLSxtoZcUUFnn7D4ghSQhKSGN4eQdx2BCRFQAOdiqoJIELC0lwNL0ehFdSipss5onPb2+JAeXmCgt1NALPVad3YT4xHtm1S1i9x66+7bj7c3EYEJEVBBZqy0g9DpcX74SKbFxRvMkKeOUjRACz4/d5uBdASXbt36tdccn3sethNjXWga9uxhMiIgKsNS4OKTE3DKa9rJgYlW0SB62jsgUxzEhIiIi2WAwISIiItlgMCEiIiLZYDAhIiIi2WAwISIiItlgMCEiIiLZYDAhIiIi2WAwISIiItlgMCEiIiLZYDAhIiIi2WAwISIiItlgMCEiIiLZYDAhIiIi2WAwISIiItlgMCEiIiLZYDAhIiIi2WAwISIiItlgMCEiIiLZYDAhIiIi2WAwISIiItmweNsNeNcpFBIkScpRXSEE9HrxhltERET09jCYvEUKhQRHBxUAfU6XgMcJWoYTIiIqMBhM3qKMIyV6RIfvgCb5gVl11TbOKOHZ8ukyGEyIiKhgYDCRAU3yA6Qmxb/tZhAREb11vPiViIiIZIPBhIiIiGSDwYSIiIhkg8GEiIiIZIPBhIiIiGSDwYSIiIhkg8GEiIiIZIPBhIiIiGSDA6zlc0qlhJzkSz5nh4iI5IjBJJ+ysLSFXlJAZZ2zAekVkoSkhDSGEyIikhUGk2fkpyf9Ki3U0As9Vp3dhPjEe2bVLWL3Hrr7tuNzdoiISHYYTJ5SKCTY2llBL3L2D7VCkpCUmJrnRyDiE+/jVkJsnq6TiIgotzCYPCVJEvRCYOn284i9n2RWXVcXW/Ru5cMjEERERK+JweQ5sfeTEBOf+LabQURE9E7i7cJEREQkG2YHE71ej5CQEHz44YeoXLkygoKCEBkZ+cLyd+/exbBhw+Dv7w9/f38MHjwYsbG8JoKIiIhMmR1MFi1ahA0bNmDKlCnYuHEjJElCr169oNVqsyw/dOhQ3LlzB6tWrcKqVasQGxuLfv36vXbDiYiIqOAxK5hotVqsXLkSAwcORN26deHp6Yk5c+YgLi4OoaGhJuUTEhJw6tQp9OrVC15eXvDy8kLv3r1x4cIFPHz48I29CSIiIioYzAom4eHhSEpKQs2aNQ3THBwc4OXlhVOnTpmUV6vVsLGxwfbt25GYmIjExETs2LEDpUuXhqOj4+u3XkYkZIzCqlQqjH4UioxxURQK03kZo7YSERFRJrPuysm8NsTNzc1oepEiRXDnzh2T8mq1Gt999x0mT54MPz8/SJKEwoULY926dVAocn7drYXFm79mNzNASE9/zOFoq4JKErBUSYB4rrYE6FJSYZvlvKcDukmS+SuVnvm/uYPCSRIkKSNISZK8rn9+nX54tvzLNsnz8/57zX7IxH6QB/aDPLAf8pZZwSQlJQUAoFKpjKar1Wo8fvzYpLwQApcvX4avry969uwJnU6HOXPmoH///vj5559hZ2dndoMVCglOTrZm18uOFE06FArJ8CHMLltrSwi9DjeWr0JqXFy26zl4VYB7u8+ertO8D4D0tLyEjMHdzKoLQIIER0cbs+rllZz2g2HnIb14BN8sp0v/HdViP/yH/SAP7Ad5YD/kHbOCiZWVFYCMa00yfwcAjUYDa2trk/J79uzB+vXr8fvvvxtCyOLFi1GvXj1s2bIF3bp1M7vBer1AQkKy2fVeRaGQYKm2hF5v/tDymeVTYmOREnPLZL4kSRBZjCirLlLYUF+v15u1TvG0vADMHq1WABAQePw4WXbPynkT/SCEyHJ7v6gf8HQa++E/7Ad5YD/IA/vh9Tk4WEOpzF7AMiuYZJ7CiY+PR8mSJQ3T4+Pj4enpaVL+zJkzKFOmjNGREUdHR5QpUwY3b940Z9VG0tPN66TsUCoVsERmp5jn2fLPfwaeDavPz/vvtcj5SkUWC35lXQEhAJ1OQKd789vydbAf5IH9IA/sB3lgP+Qts44PeXp6ws7ODidOnDBMS0hIwMWLF+Hn52dS3s3NDZGRkdBoNIZpKSkpiImJQalSpV6j2URERFQQmRVMVCoVunTpguDgYBw8eBDh4eEYOnQoXF1d0bBhQ+h0Oty9exepqakAgFatWgEAhgwZgvDwcEN5lUqF1q1bv/E3Q0RERPmb2ZfcDho0CG3atME333yDjh07QqlUYsWKFVCpVLhz5w5q166NvXv3Asi4W2f9+vUQQqBbt2744osvYGlpiZ9//hkODg5v/M0QERFR/mb2Q/yUSiVGjhyJkSNHmsxzd3fH5cuXjaaVK1cOixcvznkLiYiI6J0hr5vFiYiI6J3GYEJERESywWBCREREssFgQkRERLLBYEJERESywWBCREREssFgQkRERLLBYEJERESywWBCREREssFgQkRERLLBYEJERESywWBCREREssFgQkRERLLBYEJERESywWBCREREssFgQkRERLLBYEJERESywWBCREREssFgQkRERLLBYEJERESywWBCREREssFgQkRERLLBYEJERESywWBCREREssFgQkRERLLBYEJERESywWBCREREssFgQkRERLLBYEJERESywWBCREREssFgQkRERLLBYEJERESywWBCREREssFgQkRERLLBYEJERESywWBCREREssFgQkRERLLBYEJERESywWBCREREssFgQkRERLLBYEJERESywWBCREREssFgQkRERLLBYEJERESywWBCREREssFgQkRERLLBYEJERESywWBCREREssFgQkRERLLBYEJERESywWBCREREssFgQkRERLLBYEJERESywWBCREREssFgQkRERLLBYEJERESywWBCREREssFgQkRERLJhdjDR6/UICQnBhx9+iMqVKyMoKAiRkZEvLJ+WlobZs2fjww8/RJUqVdClSxdcunTptRpNREREBZPZwWTRokXYsGEDpkyZgo0bN0KSJPTq1QtarTbL8hMnTsTmzZvx7bffYsuWLShUqBB69eqFJ0+evHbjiYiIqGAxK5hotVqsXLkSAwcORN26deHp6Yk5c+YgLi4OoaGhJuWjo6OxefNmTJs2DR999BHKlSuHqVOnQqVS4d9//31jb4KIiIgKBrOCSXh4OJKSklCzZk3DNAcHB3h5eeHUqVMm5Y8dOwYHBwfUqVPHqPyhQ4cQEBDwGs0mIiKigsjCnMKxsbEAADc3N6PpRYoUwZ07d0zK37x5EyVKlMBvv/2GpUuXIi4uDl5eXvjqq69Qrly5nDfa4s1fs6tQSAAA6emPOZ4tL72k8vPz/nst5Xyl0itW+oKGSBKgVEqQJHld/8x+kAf2gzywH+SB/ZC3zAomKSkpAACVSmU0Xa1W4/HjxyblExMTERUVhUWLFmHUqFFwcHDADz/8gE6dOmHv3r1wcXExu8EKhQQnJ1uz62VHiiYdCoVk+BCa0yYAkCQJ0gs+BFlOfzotY53mfQCkp+UlAAozP3gZXy4Jjo42ZtXLK+wHeWA/yAP7QR7YD3nHrGBiZWUFIONak8zfAUCj0cDa2tqkvKWlJZ48eYI5c+YYjpDMmTMHdevWxbZt29CzZ0+zG6zXCyQkJJtd71UUCgmWakvo9QJ6vTC7TQAghIAQpnUlScpyOp5Oy1in3qx1iqflBQB9Vst+WV0AAgKPHyeb/V5zG/tBHtgP8sB+kAf2w+tzcLCGUpm9gGVWMMk8hRMfH4+SJUsapsfHx8PT09OkvKurKywsLIxO21hZWaFEiRKIiYkxZ9VG0tPN66TsUCoVsERmp5jn2fLPfwaeDavPz/vvtcj5SkUWC35lXQEhAJ1OQKd789vydbAf5IH9IA/sB3lgP+Qts44PeXp6ws7ODidOnDBMS0hIwMWLF+Hn52dS3s/PD+np6Th//rxhWmpqKqKjo1GqVKnXaDYREREVRGYdMVGpVOjSpQuCg4Ph7OyM4sWLY9asWXB1dUXDhg2h0+nw4MED2Nvbw8rKCn5+fqhVqxZGjx6NyZMno1ChQggJCYFSqUTLli1z6z0RERFRPmX2JbeDBg1CmzZt8M0336Bjx45QKpVYsWIFVCoV7ty5g9q1a2Pv3r2G8vPnz0eNGjUwYMAAtGnTBomJifjxxx/h7Oz8Rt8IERER5X9mHTEBAKVSiZEjR2LkyJEm89zd3XH58mWjaXZ2dpg4cSImTpyY40YSERHRu0FeN4sTERHRO43BhIiIiGSDwYSIiIhkg8GEiIiIZIPBhIiIiGSDwYSIiIhkg8GEiIiIZIPBhIiIiGSDwYSIiIhkg8GEiIiIZIPBhIiIiGSDwYSIiIhkg8GEiIiIZIPBhIiIiGSDwYSIiIhkg8GEiIiIZIPBhIiIiGSDwYSIiIhkg8GEiIiIZIPBhIiIiGSDwYSIiIhkg8GEiIiIZIPBhIiIiGSDwYSIiIhkg8GEiIiIZIPBhIiIiGSDwYSIiIhkg8GEiIiIZIPBhIiIiGSDwYSIiIhkg8GEiIiIZIPBhIiIiGSDwYSIiIhkg8GEiIiIZIPBhIiIiGSDwYSIiIhkg8GEiIiIZIPBhIiIiGSDwYSIiIhkg8GEiIiIZIPBhIiIiGSDwYSIiIhkg8GEiIiIZIPBhIiIiGSDwYSIiIhkg8GEiIiIZIPBhIiIiGSDwYSIiIhkg8GEiIiIZIPBhIiIiGSDwYSIiIhkg8GEiIiIZIPBhIiIiGSDwYSIiIhkg8GEiIiIZIPBhIiIiGSDwYSIiIhkg8GEiIiIZMPsYKLX6xESEoIPP/wQlStXRlBQECIjI7NVd9euXShfvjxiYmLMbigREREVfGYHk0WLFmHDhg2YMmUKNm7cCEmS0KtXL2i12pfWu3XrFiZNmpTjhhIREVHBZ1Yw0Wq1WLlyJQYOHIi6devC09MTc+bMQVxcHEJDQ19YT6/XY+TIkfD29n7tBhMREVHBZVYwCQ8PR1JSEmrWrGmY5uDgAC8vL5w6deqF9RYvXoy0tDT06dMn5y0lIiKiAs/CnMKxsbEAADc3N6PpRYoUwZ07d7KsExYWhpUrV2Lz5s2Ii4vLYTOJiIjoXWBWMElJSQEAqFQqo+lqtRqPHz82KZ+cnIwRI0ZgxIgRKF269BsLJhYWb/5mIoVCAgBIT3/M8Wx56SWVn5/332sp5yuVXrHSFzREkgClUoIkyevGLPaDPLAf5IH9IA/sh7xlVjCxsrICkHGtSebvAKDRaGBtbW1SfsqUKShdujQ6dOjwms38j0IhwcnJ9o0t71kpmnQoFJLhQ2hOmwBAkiRIL/gQZDn96bSMdZr3AZCelpcAKMz84GV8uSQ4OtqYVS+vsB/kgf0gD+wHeWA/5B2zgknmKZz4+HiULFnSMD0+Ph6enp4m5bds2QKVSgVfX18AgE6nAwA0b94cLVq0wOTJk81usF4vkJCQbHa9V1EoJFiqLaHXC+j1wuw2AYAQAkKY1pUkKcvpeDotY516s9YpnpYXAPRZLftldQEICDx+nGz2e81t7Ad5YD/IA/tBHtgPr8/BwRpKZfYCllnBxNPTE3Z2djhx4oQhmCQkJODixYvo0qWLSfnffvvN6PW5c+cwcuRILF26FOXKlTNn1UbS083rpOxQKhWwRGanmOfZ8s9/Bp4Nq8/P+++1yPlKRRYLfmVdASEAnU5Ap3vz2/J1sB/kgf0gD+wHeWA/5C2zgolKpUKXLl0QHBwMZ2dnFC9eHLNmzYKrqysaNmwInU6HBw8ewN7eHlZWVihVqpRR/cyLZ4sVKwYXF5c39y6IiIioQDD7ypZBgwahTZs2+Oabb9CxY0colUqsWLECKpUKd+7cQe3atbF3797caCsREREVcGYdMQEApVKJkSNHYuTIkSbz3N3dcfny5RfW9ff3f+l8IiIierfJ654sIiIieqcxmBAREZFsMJgQERGRbDCYEBERkWwwmBAREZFsMJgQERGRbDCYEBERkWwwmBAREZFsMJgQERGRbDCYEBERkWwwmBAREZFsMJgQERGRbDCYEBERkWwwmBAREZFsMJgQERGRbDCYEBERkWwwmBAREZFsMJgQERGRbDCYEBERkWwwmBAREZFsMJgQERGRbDCYEBERkWwwmBAREZFsMJgQERGRbDCYEBERkWwwmBAREZFsMJgQERGRbDCYEBERkWwwmBAREZFsMJgQERGRbDCYEBERkWwwmBAREZFsMJgQERGRbDCYEBERkWwwmBAREZFsWLztBhBR9gghoNfrodfrcn1dOp0ESamHvZUEJzulWXWtLYFUjQbCzg5wKmQ8UwIgSYAQgDCepbe2QmqqBnpYQShszWuvsIQmVQM7hTUKWdibVddOYQ1NqgZarQ56vXh1hdekVFpAoeDfhEQvwmBCJHNCCKSkJCIx8XGehJJMkiShrrcNdDprs+qpLJWIjLkFfZ3aUKWbtjczlzxPo7LEzchopFl6Afbmvc8kvSVSI2MQ4FAFOjvz6ioVStyKioHIqlG5xNraDg4OzpAkKc/WSZRfMJgQyVxCwgOkpCTCysoWVlY2UCiUefIPmiQBemUK0tL1ZtWzVlvA2V4NjV4JfVqa8TIN/xXPHzCB0toaKmcnaFMfQejSYA6FhRUs1PYQSSqk6dPNqmupsICLrTOEeW8zR4QQ0Go1SEx8CABwdHTJ/ZUS5TMMJkQyptfrkJKSBDu7QrCzc8zTdSsUEiRFOiSFeUcgFEpLqFQq6BRK6CXjui8LJhYKJVQqNUS6EnrJvJSgtLCApUoNhUYJSWdeXYUyY716Xd4cMVGp1ACAxMSHsLd34mkdoufwG0EkYzqdDoCAWm31tptCb1BmONHpzDu6Q/QuYDAhyhd4LUJBwmtLiF6Mp3KI8jGFQsq1f+QUCglqlQWUStPl63R6s689ISLKDgYTonxKoZBga2cFfS7eTVLc1TKLq0Eyjt9cj3qQ43CSlJyMtl8GwdrKGj8vXApLC8vXbCkRFRQMJkT5lCRJ0AuBpdvPI/Z+0ptfPgC9gMl4I64uNuj1mQ+USkWOg8nvx4+hkIMjHj5+jGMnT6Berdqv3V4iKhgYTIjyudj7SYiJT3zjy5UA6PSmA6G9Cb8ePojqlX1x98F97Dqwn8GEiAx48SsR5anIW9G4dO0qqvpURl3/Wgi7dAGRt2KMymzdvgufB/VB4+at8UXPLxF64HfDvEePHmP6zO/Rqk0nfNqqHb4aOwExMRn1N/y4DgO69TRa1uHQg+jQpIXh9YBuPbFmyXIM790fPdt1xvl/zuHJkycIDp6G1q2boW5df7Ro0QjBwdOg0aQa6t26FYMxY0agUaO6aNq0ASZMGIMHD+7j6tUrqF3bD//887fReidMGIOvvx75xrYb0buCwYSI8tSvhw/CSm2FGlWqolb1GrC0tMTuA/sN8zds+gXLVqxGuzafYcXShWjVojlmBM/B6TNnodPpMGrMOFy/GYnJE77GwpDZUCgUGD5qNNLTs3/r7YE9+9D9y14YM2UiPL0q4NtvJ+DixX/x7bczsGHDNgwcOBR79+7Cjh3bAACJiYno378XUlKSMW/eD5g3bxHu3LmDsWNH4YMPPODhUR6//rrHsPzExEQcPfoHmjb99M1tOKJ3BE/lEFGe0el0OHDsDwRU9YOVWg1ADf8qVRF69DD6BPWCGsDmzdvQutWnaN60MQCgeItmSNVooNfr8ffZc7gWcR2rVyxGyRLuAIARQwdh05YdSEh4nO12VKleDT6+VQAAlkpL1KjuDx+fKvjgAw8AgJtbMWzdugkREVcBAAcP/obExCeYPHkaHBwyBrr76qtx2L9/LzQaDZo1a4Fly37A0KGjoFarcehQKOzs7FCzZq03st2I3iU8YkJEeebE2TN48OghPgoINEz7KKA2EpOScOjoETx69BD37t+HVwVPo3rt27ZGjerVcP3GTdjZ2RpCCQA4Ozuh/5dfwtk5+8O7uxYrZvS69f/a4s6d21i4cB7GjBmB9u1b4d9/z0Ovz7i4NyLiKkqUKGkIJQBQtmw5fPnlQKjVajRs2ARarRbHjh0BAOzbtxuNGjWFhQX/9iMyF781RJRnfj1yCAAwae4sk3k7f92DT1q2ynjxgrFZLCyy85wg46t1dVmc4lGpVf+VFgIjRw5BxLVraNiwMerVa4A+ffpj5szvnlmvxUvX6+DggA8/rIv9+/ehQgVv/PtvGEaO/PoV7SSirDCYEFGeeJTwGCfO/o3GdeujTbNPjeLD1n27se/3g4iJicZ7Li64fPkKAgP8DfMnTp4KFxcXBNSsgSdPEnHr1m0UL55x1OPx48fo+kUHBAfPg4WlBVKSkyGEMASJ2Nt3Xtqu69cicPz//sSSJavh7V0RAJCeno5bt6JRrFhxAEDp0mWxa9d2JCYmws7ODgBw5Uo4hgzpj5Ur18HV1Q3NmrXEV18Nw6+/7oGnpxfKli33pjYd0TuFp3KIKE8cOHoEOr0O7T/9DGVKlDL66dSqDRQKBbZu3YxOHdtjy7ad+O3AIdy6fQfbd+7Gn8dPoHZgAKr6VkZ5jw8wbeZsXLp0GTduRmJG8Fw4OznBs4IXKnh7ISkxCTs2bUZ8XByO/X4ER0IPvrRdTs5OUCqVOHQoFLdv30J4+EWMG/cV7t+/j7Q0LQDgk0+awN7eAd9+Ow5Xr15BePglBAdPR7ly78PV1Q0A4OdXA05OzvjppzVo1owXvRLlFI+YEOVzri62ubLclw2wlhO/HjmEqhUroWRxd5OFuhUpijoBgQgN3Y9fNvyE1NQUrF7zE+4/eIAS7sUxbuxo+FapBAD4dtI3+GHxcoz6ejwAoEplH8yaMQMqlQrelSqhfbcu2L9rD7as34gKFb3RpVcQFgXPeWG7nF1cMG7cJCxfvgTbtv0CZ2cX1KpVG+3bd8LRo0cghICVlRXmzFmI+fO/R79+PaBSqRAYWAf9+w82LEehUKBRo6bYsOEnNGjQKEfbiIgYTIjyLSEEFJKE3q18cnEdeOGQ9DqdeaO+Lp8596WPIpw4aizURQpDk3wPHdr9Dx3a/S/Lcu+5uGDc2NFG05QW1obfP+vQDp91aGc0v06DeobfF6xZbrLMTxo1wccfNzaZPnDgMMPvpUqVRnBwyEveAXDv3l189FF92Nvbv7QcEb0YgwlRPqXXCyQlpubqQ/ziH6YgXaczmceH+Bk7deov3LhxAwcO7MeCBUvfdnOI8jUGE6J8TJ/VuZY3RAgJGm060tJNgwkZ2717J44f/xNffNEbXl4V33ZziPI1BhMiotc0adLUt90EogKDd+UQERGRbDCYEBERkWyYHUz0ej1CQkLw4YcfonLlyggKCkJkZOQLy1+9ehW9e/eGv78/AgICMGjQINy+ffu1Gk1EREQFk9nBZNGiRdiwYQOmTJmCjRs3QpIk9OrVC1qt1qTsw4cP8cUXX8DW1hbr1q3DsmXL8PDhQ/Ts2RMajeaNvAEiIiIqOMwKJlqtFitXrsTAgQNRt25deHp6Ys6cOYiLi0NoaKhJ+QMHDiAlJQXTp0/HBx98gIoVK2LWrFmIiIjA33///cbeBBERERUMZgWT8PBwJCUloWbNmoZpDg4O8PLywqlTp0zKBwQEYOHChVCr1SbzHj/O/iPKiYiI6N1g1u3CsbGxAAA3Nzej6UWKFMGdO6YPynJ3d4e7u7vRtCVLlkCtVqN69ermttXAwuLNX7OrUGQMUiU9/THHs+VfNtbV8/P+ey3lfKXSK1b6goZIEqBUSpAkeV3/zH4wpte/fJkKhZQrA6xJEiBJEtQqCyiVpsvP7gBrL2vZS1v9Wp1vZt3MalLGSLd5SamUXro/4/dBHtgPecusYJKSkgIAUKlURtPVanW2joD8+OOPWL9+PcaMGQMXFxdzVm2gUEhwcsqdZ4OkaNKhUEiGD6E5bQIyduQv+kciy+lPp2Ws07wPgPS0vARAYeYHL+PLJcHRMWfPPMlt7If/pKYqce+eIst/wCRJgp2VEtDn3gisNkWss5yuh4SrMQkvDScSAPHMHrXTwN6Iu3fX8FohKWBtbYX3S5dF97Yd4Vut2nO1c0Z6ru6i4Dm4GxePCbOmvbSeUqnAsmWLsWfPLmzfvifH688OvT7js+boaAMrK6uXluX3QR7YD3nHrGCS+QXSarVGXyaNRgNr66x3YEDGMz3mzZuHH374AX369EH37t1z1lpkjHSZkJCc4/ovolBIsFRbQq8XT0fTNK9NQMb7FFn8ySVJUpbTM/88y1inef+4iKflBQC9mX/mZYwVKvD4cbLZ7zW3sR+MabUa6PV66HQC6c+FAKVSAej1iFi+EqmxcWatOzskZGyT51tm5VoU5XoFQamUkJb+4vcsnvlvprbNWqBd81YAMvooIfEJVmz4CWOmT8aPi5ajROHCRrVz4vkWd/uyF/R6fZbP/HmWTqdH+/Zd0KpVW5Nt/abpdBmftcePk5GS8uKRdfl9kAf2w+tzcLDO2Gdlg1nBJPMUTnx8PEqWLGmYHh8fD09PzyzrpKWlYcyYMdi9ezdGjRqFHj16mLPKLOXGTkOpVMASmZ1inmfLP/8ZeDasPj/vv9ci5ysVWSz4lXUFhMjYOZr7ILbcxn4wptO9epmpsXFIibll3rqzQQKg04tX/oP+Ms/XtLaygnMhJ2TGB2cnZwzu0Rcd+vfE0eN/opOXV9YVzVnRc3VtbGyztUwhABsbG9jY5N1filkFzmfx+yAP7Ie8ZVYw8fT0hJ2dHU6cOGEIJgkJCbh48SK6dOmSZZ1Ro0YhNDQUs2fPRrNmzV6/xURUoGT+FWVpaYnPPmuO2oE1cerUaTx8+AgTxo1Blco+2PjLFuzavQ8PHj6Ce/FiaN+2NT5+5onBt2/fxg9Lv8Xp0yehUCrh41sF3fr2RCEnJyyaPTfjVM7MjGHjd23ehtA9+/Dg3j04uTijQaNGGNh3MABgxYol2LdvNzZv3gUAiIuLxZIlC3H69EkkJyehUiVf9O8/GOXKvQ8A+O67idDrdXB2fg/79u1GSkoyatSoiREjxsDF5b283IxEBYZZJ65UKhW6dOmC4OBgHDx4EOHh4Rg6dChcXV3RsGFD6HQ63L17F6mpqQCArVu3Yu/evRg6dChq1KiBu3fvGn4yyxDRu+veg/uYv2o5rK2s4F8t44L4HTt3Y0C/PpgxbTK8vSpgxaofsX3nHgzo1wfLlyxA689aYO78RdixM+M6kMSkJAwcPAQpKSmYOHMavpn2Le7GxWHOlOkm6zvz10ls37gJPQd+ibkrlqDjF92w+eefsX//PpOyyclJ+PLLHoiPj8P06bOxePEqWFtboX//XoYbAQDg0KEDePz4ERYsWIqpU4Nx7tw/WLp0US5tMaKCz+yH+A0aNAjp6en45ptvkJqaiurVq2PFihVQqVSIiYlBgwYNMG3aNLRu3Rq7d+8GAMycORMzZ840Wk5mGSJ6d6zfvhWbdu8EAOj0OqSlpaFkcXeMGzwCRQsXAQDU9K+BalWrAABSUlKxeesOjBk1DAE1awAAihdzQ1xcPDb8sgUtWzTD4cNHkZiUhG+/nYZkhQZaXRr6DB2Eowd/Nxn4Me7OHVhaqlDEtSjeK1IY7xUpjKJFiqBCmQombd2/fx8eP36EFSvWwcnJCQAwfvwUtG/fClu3bkK/foMAALa2thg1aiwsLCxQunQZNG7cFMeP/5kr24/oXWB2MFEqlRg5ciRGjhxpMs/d3R2XL182vF65cuXrtY6ICpRPP/4EnzVuDkBAUihgb2cHOxvju+zcixcz/B4ZFQWtVovps+ZgRvBcw3SdLiPUaDQaRNy4AXd3dzg4OiL5STwAoESpkugU1M1k/bXr18Ph3w5gSI++KFmmNHx8qyDwww/h6uoG/XPX80REXEOJEqUMoQTIuAOxQgVvRERcM0wrXrwELCz+25Xa2tohPT09R9uHiHIQTIiIcsrezg7FXd1geu/Mf1TPDMgont4VMH7saJQs4W5S1tLSEhZKi2zfXOzg6IDpC+fh6qVwhP39D86d+Rt7tm5Hz5590L17r+dKiyyHgNDrdbCwUBq14XlZ3mVBRNkir1FsiIieUaKkO5RKJeLi41G8eDHDz4mTp7Fp81YoFAqUKlUCMTExSEx8Yqh341oEerbrjLtx8UbLO3rod4Tu2Yfy3l5o27UTpswNxsdNGuPAgd9M1l227PuIiorEw4cPDNM0Gg3Cwy+hdOmyufemid5xPGJClM9ZuRbNleW+bByTvGJna4tPmzfBytVrYWNjg4reXjh//gKWLF+Fju3bAAA+rv8R1q3fhMmTxuOzzu2hSdNg5cLFKFmmNAoXLWK0PK1Gi3XLV8HaxgaeFb1w/+49XDgXBr9qpiNRN2zYGD/+uBLjxn2Ffv0GQaVSY/XqZUhJSUHLlrw+jii3MJgQ5VNCCAiFAuV6BuXaOl40OJMeUp6NcdC/by84OTpi9ZqfcP/Bfbz33nvo1qUjOnZoCyBj4MfgmTPww5LlGDt0OCxVlqjqXwNden5hsqwGTRohKTERW9dvwP2792BrZ4eAOrUxdIjpNXP29vZYsGApFi6ciyFD+gMAKlWqjB9+WIFixYrn7psmeocxmBDlU3q9QEJSWq48KwfIGO0y/mEK0nWmI5Nm91k5z/pp/pJXXguybdtuaJLvQa9LM0xTKpXo2qUjunbp+MJ6pUqWxOzvQxD7JB7aZ+oCQL/hQ4xet2j7P7Ro+z/Da5XSElZW1tDrBHr06IMePfoY5rm7l8C0abNfuN6xYyeaTHt+GURkHgYTonwsY8jo3LnQUggJGm060tJfPGQ6EdGbxotfiYiISDYYTIiIiEg2GEyIiIhINhhMiIiISDYYTIiIiEg2GEyIiIhINhhMiIiISDY4jglRPqZQSLk6wJpaZQGl0nT5ORlgjYgoOxhMiPIphUKCo4MKQO4FBFsb2yyHbxMCuHLzkdnhZNjkcTh36YLRNEsLCzgXckLtgEAMGDYy208Kfh0Xws7j29FjEbJ6GdyLuaN/v95wdXXLciRXIspbDCZE+VTGkRI9osN3QJP84JXlzV8BoNMLk4FlrWxcUKJCSyiVihwdNfmoZiD6dwsyLDYlNRWnw/7BD2tXASoVBvbr8fptJ6J8i8GEKJ/TJD9AalL8m1/wC4LJ61KpVHAu5GS02OKubrgWFYnQ0P0MJkTvOAYTIpIFlUoFpTLjevy0tDSsWrMOoQd/R1JSMsqULoXun3dGdb+qhvJXrlzDshWrceFSOKytrVCnTn20D+oKhUqJpMRE/LzqR/x98jQeP3wIOwd7VA+oic9794BKrX5bb5GIsoHBhIjeKp1Oh1PnzuK33w+i1WetAQAzgufiZmQkvh49AoULu+D48ZMYO34yJk8Yi5r+1REbG4chI75CYIA/Fs4LRqpGj+mzgvHwyUP0GzkUi2bPxf279zB07Gg4OhXC1UvhWPx9CIqVcEfTVi3e8jsmopdhMCGiPHXwzz/wx4njhtdarRZFChdGh8/aIKjfAETeuIBDvx/BDwvmoLzHBwCAtm0+Q8T1G9j4yxbU9K+O3Xt/hYO9PUaPHAoLCwsoLazx1ZhxOPrXHwAAH98qqFDRG6XKlgEAFClaFPt37UHUjZt5/n6JyDwMJkSUp2pVq45eHbtCLwQuXbuCH35chaoVK6Fz2w6wsLDAtWsRAIChI8YY1dPp0mFnawcAuH7jJj74oBwsLP7bhfn6VoXb++7Q6tLwSfOmOPPXSRw9dBhxt+8g6uZNxMfGwbVYsbx7o0SUIwwmRJSnrK2sUdzVDQKAu1sxFHZ2wajvJsFSrcZX4ydBr8+402fe9zNgY21tVFehyLgGRalUvnD8FiEEZk2cgsgbN1G7Xl34166FDt27YmnIwlx9X0T0ZnDkVyJ6q6p4+6BNsxbYsW83jh//P5QpUxoAcP/+AxQvXszw8+tvB7BvfygAoHSpkrh6LQI6nc6wnCOHD6Fnpy64cikcZ0+dxtCxo9EpqBtq1/8IRYu5Ie72nYwBWIhI1hhMiOit6962A9yLFcfMmd+haNGiqOlfHXPmLcSfx0/g9p1YbPxlK9Zv+AVubq4AgJYtmiEh4QnmhCxEZFQ0zoWFYdGi+ahSrSoKFy0CpVKJv44eQ3xsLCKuXMW8qTPx6OFDpKWlv+V3SkSvwlM5RPmc2sY5dxb8kgHW3jSVSoUR/Qdj6DejsWLFaowfOxorVq3F3HkLkfDkCYq5uWLYkAFo0qghAOA9FxfMnDYZS5evRp9+g2FnZ4eGDRujVZd2kCwU+HL4EGxetx6/7doLRycnVPX3Q9PPWuL08RMQPGpCJGsMJkT5VMY/sAqU8GyZi+vIenw1ITKel2Ou78d/C0BCVkutUrES/u//TkOTfA96XRr6f9kL/b/s9cJleXtVwLzvZwAAlBbWsLQuhNgn8dDq0lC7Xl3UrlfXpM7nvTMGb/Ou5IMN+3Yapi9ctBR6HQMLkRwwmBDlU3q9wOMEba4+xC/+YQrSn7mOIxMf4kdEuYXBhCgf0+sF3viY8U8JIUGjTUdaumkwISLKLbz4lYiIiGSDwYSIiIhkg8GEiIiIZIPBhIiIiGSDwYSIiIhkg8GEiIiIZIPBhIiIiGSD45gQ5WMKhZSrA6ypVRZQKk2XzwHWiCi3MJgQ5VMKhQRbB0voc+nZLxKA4tY2Wc8UEq5HPjIrnAybPA5hly5kOa9142YY9OVAo2nnwv7F8FFf48CvO7Os86zQgwexbccuRFy7CgGgeAl31G/8CT5u2jjb7SMieWAwIcqnJEmCXgisPrsJ8Yn3cmMN0OlNg0dRu/fwRdV2UCoVZh81+ahmLfTv1hOAMBqv1kptZVTun3NhGD/pO+izWP/z9v36G+YvWorBQ4ajhEdpaHVpOH/2HNYsXobHDx/hf507mNVGInq7GEyI8rn4xHu4lRCbC0vOOpi8DpVKDedCTng+mGRKT0/H/AU/YPvOXShbpjSuXot45TJ37NqLpk2aoGXL1oaH+BVzd8eDe/ewd/tOBhOifIbBhIhkIyUlBZevXMGs6d8iNi4eM4PnvrKOpJBw4cIFJCQkZJx/eqpF2/+hbsOPDa91Oh22/rwRR0IPIeHxIxQvUQLtu3VBDf+aAICbN2/ghx9CcP58GHS6dFSvXhMDBgyFq6srAGDAgN4oXtwd169HIDo6EkOGjETjxs2wZ89OrF//I+7cuQM3Nze0bPk/tGnTHgoF7y0gygl+c4hINuzt7bEgZA6qVK6U7Tod27XB1WvX0LJFY0z5Zjx2bNqMa5evwMbWFsXcixvKrVmyDL/t2ovOPbpj5qL58K3uh+BJ3yE6MhJ37txB375fwNJShZCQxZgzZyEePnyAgQN7Izk5ybCMvXt3oW3bjli0aAUCAgKxY8dWLFgwF92798TatRvRq9eX+Omn1Vi8eP4b3S5E7xIeMSGiPHPwzz/wx4njRtO8PcpjxtcTcrzMOh8GYtGC+di2cw+OH/8Tf588BQBwK14cfYcORHlvL6QkJ+PQvt/Q/cveCKhTGwDQ7vPO0Ov1SElOwdYjv8Da2gbjx38LlUoFAJgyZQbatPkU+/fvw2eftQEAfPCBBz755L8LatesWYGuXb9Aw4YZ04oXd0dSUhJmz56BHj36Qq1W5/h9Eb2rGEyIKM/UqlYdvTp+jmevMVE/DQKvo4KnJyr51sSdhDhERFzD2VNn8OuOXZg+bhLmrlyCe/F3kZ6ejg88yxvV69C9K1RKS+zYsBmenhUMoQQAnJycUbJkKUREXDVMc3cvafj94cOHiI+Pw/Lli7Fq1VLDdL1eD61Wgzt3bqN06TKv/d6I3jUMJkSUZ6ytrFHc1Q0vuvjVXHfv3sPPmzajS6cuKFayECRJQskypVGyTGn41ayB4X3649L5C3ArXiyjwguGfBFCZDlTr9fDwuK/3eSzR0CEyLgweNCgofDz8zepW7Soa87fGNE7jNeYEFG+pVJZYveeXxF68KDJPGubjDFYHJ0KwbVYMSgtLBBx5apRmbGDh2P7ps0oV+59XLp0AVqt1jDvwYP7iI6OfuFRDycnZzg5OePWrVtwdy9h+Ll8+RKWLVv0NOwQkbl4xISI8i1HR0d0aPc/LF+xEikaHSrXrAoLtQoxUdHY+vNGeFf2QYWK3gCAxi2aYdOan+Dg6Aj3kiVxJPQgYiKj4FezBtwKuWLr1s2YPHkcunfvibQ0LRYsmItChQqhQYNGWa5bkiR06vQ5li5diKJFiyIgoDauX7+G2bNnoFat2kanhYgo+xhMiPK5Inbv5dKSXzzAmpwEde+KEiVLY+++/di8eSM0Gg3eK/weAup8iFYd2hrKdez+OZRKC6xY8AOSEhNRsnRpjJ48Ae4lS8LVvgjmz1+CH36Yjz59usPSUoUaNWpi3LhvYW9v/8J1d+zYBWq1Gps3b8CCBXPh7OyCZs1aoFevL/PirRMVSAwmRPmUEAIKSUJ333a5snwJePFw90KCTmfe4Gvfj//2RZd4ZKnxJx+j8Scfv7oggMaffIJPW7YzDLCWFQtLS3QK6oZOQd2ynO/pWQHz5i164ToWLFia5fTWrduideu2Wc4jIvMxmBDlU3q9QFJCWq4+xC/+YQrSdTqTeXyIHxHlFgYTonxMrxfAG7m/xZQQEjTadKSlmwYTIqLcwrtyiIiISDYYTIiIiEg2GEyIiIhINhhMiPIFDtZVkHDwNaIXYzAhkjGlUglAgkaT+rabQm+QVqsBACiVvP+A6Hn8VhDJmEKhhLW1LRITHyE9PQ1WVjZQKJS5dovwsyQJEPo0iCwGWXsZvQ7QahVI1+ugF8Z1JcN/TZ+VI/Q6SFoN0tJ1EFncovzSdSIdQquBPl1nfnuFDlqtBiIP7n4WQkCr1SAx8SGsre2gUPBvQ6LnMZgQyZyDgzMsLdVITHyE1NSkPFuvJElISNRApzPvtIPWUgmhtYT2yWOILG41liQgqzMZCm0SLIUGadpECL15wUShsITSMgkJmifQmVlXqVBCStHm6ekVa2s7ODg459n6iPITBhMimZMkCTY2drC2toVer4fezH94c0KhkKC2tsSOzecQ+yDZrLreZVzQ5ePSiNi1BymxcUbzJCnj/QghTMKJo3cFlOzUDpEXt0CTfN+sddo6lUXhUg3w6+mfEZd416y6Re3eQ49qnaBJ1j0dFyZ3KZUWPFJC9BJmBxO9Xo8FCxbgl19+QUJCAqpVq4YJEyagVKlSWZZ/+PAhpkyZgj/++AMA0LhxY4wZMwY2T5/8SUTZI0kSlErl0+tOcpdSqYBarcKTVIGHieYFoZQ0wEqthpSYCDx8ZDxTwn+HTJ7LAIqUVFhZqaFAKiS9eUeGlFIa1FZqJOpT8Cj9iVl1bfW2UFupIdJ1Zg+zT0RvntmxfdGiRdiwYQOmTJmCjRs3QpIk9OrVy+hx4c8aNGgQoqOjsXr1aoSEhODPP//EpEmTXrvhREREVPCYFUy0Wi1WrlyJgQMHom7duvD09MScOXMQFxeH0NBQk/Jnz57FyZMnMW3aNHh7eyMgIACTJ0/Gjh07EBcXl8UaiIiI6F1mVjAJDw9HUlISatasaZjm4OAALy8vnDp1yqT86dOnUbhwYZQrV84wrUaNGpAkCWfOnHmNZhMREVFBJAkzLkX/7bffMHDgQJw7dw5WVlaG6YMHD0ZqaiqWLFliVH7KlCk4d+4cfvnlF6PpAQEB6NmzJ3r06GF2g4UQuXKBWsbdlxKeJGvNPs9saamEnZUF0p48yfI2x4ybI00pLFWwsLNFelqS2bc4KhQWUFha4YkmyeSWzFfWlRSwV9sCIuu7I94m9oM8sB/kgf0gD+yH16dQSNke5sCsi19TUlIAACqVymi6Wq3G48ePsyz/fNnM8hqNxpxVG2RcAJh7Yzg42qlzXFfl6JijepYquxyv09HKPsd1kftDYeQY+0Ee2A/ywH6QB/ZD3jDrVE7mUZLnL3TVaDSwtrbOsnxWF8VqNBrelUNEREQmzAombm5uAID4+Hij6fHx8XB1dTUp7+rqalJWq9Xi0aNHKFq0qLltJSIiogLOrGDi6ekJOzs7nDhxwjAtISEBFy9ehJ+fn0n56tWrIzY2FpGRkYZpmXWrVq2a0zYTERFRAWXWNSYqlQpdunRBcHAwnJ2dUbx4ccyaNQuurq5o2LAhdDodHjx4AHt7e1hZWaFy5cqoWrUqhg4diokTJyI5ORkTJkxAq1ateMSEiIiITJh1Vw4A6HQ6fP/999i6dStSU1NRvXp1jB8/Hu7u7oiJiUGDBg0wbdo0tG7dGgBw//59TJo0CUePHoVarTaM/KpW5/wiIiIiIiqYzA4mRERERLmFT5IiIiIi2WAwISIiItlgMCEiIiLZYDAhIiIi2WAwISIiItlgMCEiIiLZYDAhIiIi2TBr5Nd3UWJiIgIDA2Fra4vDhw9n+bTkgwcPYv369bhw4QI0Gg1Kly6N9u3bo127dlAojLPfsWPHsGrVKpw/fx4ajQbu7u5o1qwZunXrBltb27x6W/kO+8GUnLfJV199hW3bthlNs7CwgJOTEz788EOMGjUKTk5O5r9pM3Tt2hXFixfH9OnTc3U9b4Oc+z4/kPP2y+q786yNGzeiSpUqr1zO1atXcevWLXz00UdmrV8WBL3Uhg0bRL169YSPj4/YvXu3yfwZM2aISpUqiR9++EFcunRJ3LhxQ6xbt05UrlxZfP3110ZlFy1aJLy9vcWsWbPExYsXRVRUlNizZ49o0qSJaNKkiYiNjc2rt5XvsB9MyXmbjB49WrRv317Ex8cbfqKiosSOHTtEtWrVRO/evV/rvWdHly5dxOjRo3N9PW+DnPs+P5Dz9svqu/Psj1arzdZy6tWrJ0JCQsxat1wwmLxC27Ztxbhx40Tv3r1Fly5djOYdOXJEeHh4iIMHD5rU2759u/Dw8BCnT58WQghx4sQJ4eHhIfbs2WNS9smTJ+KTTz4RPXr0yLINHh4e4q+//noD7yb/Yj+YkvM2GT16tEmbMs2fP194eHiIJ0+evPI9vo6CHEzk3Pf5gZy338u+O+bIz8GE15i8REREBM6dO4fAwEA0btwYJ0+eREREhGH++vXrUaFCBdSvX9+kbvPmzbF69WpUqFABALB27VqUL18eTZs2NSlrZ2eHfv364ejRo0bLpwzsB1P5eZuo1WpIkgRJkgBkPKF8woQJqFu3Lry9vREYGIgJEyYgNTUVQMYTycuXL48jR46gefPmqFixIpo1a4bff//dsEytVoupU6ciICAAfn5+mD17NvR6vdF6IyIi0LdvX/j7+6NatWoYNGgQbt++bZjftWtXzJ07F+PGjYOvry9q1qyJRYsW4fr16+jcuTMqVaqEFi1aICws7I1sh5zKz30vBwVh+0VHR6Nq1aqYMmWKYdovv/wCb29vnDt3DvXr18etW7ewYMECdO3aFQBQvnx5zJkzB/Xq1UNgYCCuX7+O2NhYjBgxArVq1YK3tzfq1q2LOXPmmHx38hqDyUts3rwZNjY2qFOnDj7++GOoVCr8/PPPhvn//vsvfH19s6yrVCoREBAAGxsbAMDZs2dRtWrVF64rICAAAPD333+/wXdQMLAfTOXHbSKEwN9//401a9agYcOGhnPvo0ePRlhYGEJCQrB//36MGTMGW7duxcaNG43qz5o1C2PHjsXWrVtRokQJjBgxAklJSQCAKVOmYO/evZg+fTp+/vln3L59G6dPnzbUvXXrFtq3bw+VSoU1a9Zg1apVuH//Prp06YLExERDueXLl8PNzQ07d+5E165dMW/ePPTp0wdBQUH45ZdfoFarMXHixNfaDq8rP/a9nBSE7VeiRAl8/fXX+Omnn3DmzBlERkZi6tSpGDRoECpXrozNmzfD1dUVQUFBmD9/vqHexo0bERISgoULF6Js2bLo06cPHjx4gBUrVuDXX39Fz549sXjxYhw6dOiNttdcvPj1BdLT07Fr1y7Uq1cP1tbWAIC6detix44dGD58OKytrfHo0SM4ODhka3mPHj1CoUKFXjg/80LAhw8fAoDJF6NXr15QKpUAgGXLlsHPz8/ct5QvsR9M5Zdtcvr0aaOyGo0Gzs7OaNq0KYYMGWKYHhgYCD8/P3h6egIA3N3dsW7dOly+fNloPUOGDDHs6IcMGYKWLVviypUr+OCDD7B161bDURcAmDp1Kk6cOGGou379etjY2CA4ONhwoWNISAjq16+PnTt3olOnTgAADw8P9OvXDwAQFBSEkJAQNG3aFA0aNAAAtG7dGlOnTn3p9sxN+aXv5Sq/bL/nvzuZypcvjw0bNgAA2rRpg99//x3jxo2Dvb09KlWqhF69egEAnJ2doVQqYWNjY9S+li1bwsfHBwCQmpqKli1bolGjRihevDiAjKOGS5cuxeXLl/Hxxx9naxvkBgaTFzhy5Aju3r1rdIiuadOmCA0NxZ49e9CmTRs4Ozvj0aNH2VpeoUKFjP4ye15CQgKA/z7I27dvN8z75JNPMGXKFFSuXBkAULRoUTPfTf7FfjCVX7ZJxYoVERwcDCEErl27hu+++w6enp4YPHiw4S9OAOjUqRMOHTqEHTt2ICoqCleuXEF0dDRKly5t1I6yZcsafrezswMApKWl4caNG0hLSzPscIGM00WZh9sB4MqVK6hYsaLR3RcuLi4oU6aMUQAqU6aM4ffMf7hKlChhtFytVvvCbZXb8kvfy1V+2X6Z353nPX/30LfffosmTZrg9u3b2L9/v8ndQs8rVaqU4XcrKyt06dIFv/76K9asWYPIyEiEh4cjPj7+rZ/KYTB5ga1btwIABg0aZDJvw4YNaNOmDXx9ffHPP/9kWV+v16Nv375o1aoVmjZtimrVqhn9Bfe8zHmZt4E9+wECMj60z097F7AfTOWXbWJlZWWYXrp0aZQuXRpt27bFsGHDsHjxYkiSBCEE+vbti8uXL+PTTz9Fo0aNMGzYMIwbN85keVnd0imEeGG7LSwsjMplXtPyLJ1OB0tLS8PrZ3/P9KqdfV7KL30vV/ll+z373XmZqKgoPHnyBABw5syZLK91eX65mVJSUtC5c2ekpKSgSZMmaNmyJcaNG4fOnTu/cr25TT7fOBl58OABjhw5gtatW2P79u1GP23atMH58+dx4cIFtGvXDuHh4Vmej9u9ezeOHDkCFxcXAEC3bt1w7do1wxfjWYmJiZg/fz4CAgLwwQcf5Pr7yy/YD6by8zZ5//33MWLECBw+fNhwOPrixYs4cuQIQkJCMGLECLRo0QIlS5ZEVFTUS0PHs8qVKwe1Wo0zZ84YpqWnpyM8PNzw2sPDA2FhYUZHO+7du4fIyEiUK1futd5XXsnPfS8HBW37JScnY9SoUWjatCn69u2LiRMnIi4uLtv1jx49igsXLmDt2rUYNGgQmjZtCjs7O9y/fz/b371c8xbvCJKtlStXivLly4tr166ZzIuKihIVKlQQY8eOFUIIMX78eOHj4yMWL14srl69Kq5evSqWLFkiKlWqJCZMmGCyXG9vbzFjxgxx6dIlERMTI3777TfRrFkz8fHHH4s7d+7kxdvLN9gPpvLLNnnRLY96vV507txZVK1aVcTGxorY2Fjh5eUlpk2bJqKiokRYWJjo16+f8PDwEEOGDBFCCPHXX38JDw8PER0dbVhOdHS00e2WM2bMEDVq1BD79+8X165dE19//bWoUKGC4XbhqKgoUaVKFTFw4EBx6dIlce7cOdGpUydRp04d8fjxYyFE1rcXe3h4iC1bthheb9myRXh4eJi1Ld6U/NL3cpVftt+rxjFJSkoSQggxbtw4UatWLfHw4UOh0WhEs2bNxBdffCH0er0QQojmzZuLYcOGibt37wohTD/L586dEx4eHmLFihUiJiZGnDp1SnTs2FF4eHiIWbNmmdXmN43BJAvNmzcXX3zxxQvnDxo0SFSpUsUwDsOWLVtE+/btRfXq1YWvr69o3bq1+OWXX4ROpzOpe+LECdGnTx8REBAgKlWqJJo0aSLmzZuX62M65EfsB1P5ZZu8bCyG69evCx8fH9G3b18hhBA7d+4UDRs2FBUrVhT16tUTkyZNElOnThUNGjQQer0+W8EkPT1dzJ07VwQGBooqVaqIMWPGiP79+xsFjfPnz4tu3bqJSpUqCT8/PzF48GBx69Ytw3y5B5P80vdylV+23+jRo4WHh8cLf5YsWSJ+//134eHhIUJDQw31/vnnH+Hp6SnWrFkjhBBi48aNomrVquLTTz8VQph+loUQYtWqVaJu3brCx8dHfPzxx+L7778Xw4YNeyPjqLwOSYi3fcyGiIiIKAOvMSEiIiLZYDAhIiIi2WAwISIiItlgMCEiIiLZeOeCSWJiIipXroxatWplawTHrl274quvvsr28r/66iuUL1/e8FOhQgXUrl0b48ePf+kIgbkhOTkZP/30U56u01z169c32l4VK1ZEo0aNsHz58jxtR+aD4mJiYvJ0vflB165djfro2Z/vvvvurbXr4cOH+OWXX97a+nOLEAJbt25F165dUbNmTVSsWBEff/wxJk+ebNY4Fdk1f/58owfWlS9fPstxOXIqLS0Nq1evfmPLk4Pn9/NZ/VDOvXMjv+7ZswcuLi64d+8eQkND0axZsze+Dl9fX8ODk9LS0hAVFYVJkybh66+/RkhIyBtf34usXLkSW7dulcVIfi8TFBSEoKAgABnPbzh37hy++eYbWFtb51nbfX19cezYMTg7O+fJ+vKbJk2aYOzYsSbTM4dtfxtmzpyJmJgYtG3b9q214U3T6XTo378//v77b/Tt2xfjx4+Hra0trl69ikWLFuF///sftm/fjvfeey/X2nDs2DHY29u/seXt3r0b06ZNQ/fu3d/YMt+2sWPHYvjw4YbXtWvXxtdff/3KkVcpe965YLJlyxbUrl0bcXFx2LBhQ64EE0tLSxQuXNjwulixYujXrx9GjhyJxMREw3M+clt+uRPcxsbGaHuVKFECJ06cwJYtW/IsmKhUKqM2kDErKyvZbZ/88vk2x6pVq3D06FFs2rQJ3t7ehunFihVDjRo10LRpU6xcuRKjRo3KtTa86X4uiP1kb29vEt7s7e1l9x3Jr96pUzkRERE4d+4cAgMD0bhxY5w8eRIRERGG+VqtFlOnTkVAQAD8/Pwwe/Zsk4cZHTp0CB06dICvry98fHzQpk0b/N///d8r121tbW3yrI7Dhw+jXbt28PX1Re3atTF9+nRoNBrD/EePHmHSpEmoW7cuKlWqhI4dOxo9yj0lJQVjx45FYGAgfHx80KpVK/z2228AMg7PLliwALdu3cqXpyie/Us8ISHB8ORYb29vBAYGYsKECUhNTTWU+ffff9G5c2dUrlwZDRo0wM6dO+Hl5WV4VoVOp8OcOXNQu3ZtVK5cGQMHDsR3332Hrl27AjA9lVO/fn0sXboUAwcOhK+vL/z9/TF16lSkp6cb1nns2DG0bt0alSpVQrNmzbB58+Z8ua1fl06nw+rVq9GoUSP4+PigUaNG2LRpk2F+5rZdtmwZ/P398dlnn0Gn0yEuLg5Dhw6Fn58f/P390bdvX9y8edNQ7/79+xg0aBD8/f1RqVIldOjQASdPngSQcSh927ZtOHnyZIE5bC6EwE8//YQWLVoYhZJM1tbWWLduHYYMGYKYmBiUL18eixYtQmBgIOrXr4+EhARcvXoV/fr1g7+/PypWrIiGDRtizZo1RsvZuHEjGjZsiEqVKqFfv354/Pix0fznT+Vs2bIFTZo0QaVKldCkSROsWbPGsF/MbMe+ffvQtm1b+Pj4oEGDBti8eTOAjGfTjBkzxrDclz1XpiDZunUr6tevj++++w5+fn7o27cvgIx/g3r16mXY5w8fPhx379411BNCYNmyZWjQoAEqV66Mli1bYufOnUbLXrFiBT7++GNUrFgR9evXx8KFCwte+HtrQ7u9BdOnTxdVqlQRycnJIiEhQVSsWFF8++23hvnjxo0TgYGB4vDhw+LKlSti2LBhwsPDwzAa5Pnz54Wnp6dYsWKFiIqKEpcuXRK9e/cWAQEBQqPRCCGyHvHyzp07on379mLYsGGGaaGhocLT01MsWLBAREREiEOHDok6deqIAQMGCCEyRrL87LPPRPPmzcXx48fFtWvXxMSJE4W3t7cICwsTQggxbdo08b///U/8+++/IioqSsyePVt4eXmJ6OhokZiYKKZPny7q1Kkj4uPjRXp6eq5u25yqV6+eCAkJMZp27tw5UbNmTbFhwwYhhBB9+/YVrVq1Ev/884+Ijo4Wu3btEhUrVhSrV68WQggRGxsrqlatKkaOHCmuXr0qDh8+LD766COjkUGnT58u/P39DUOWT548WZQvX97QV8+PLlqvXj1RsWJFsWbNGnHjxg2xdu1aUb58ebFt2zYhhBAXL14UXl5eYsaMGSIiIkLs2bNHVK9e3WSE0oIgqxFRnzVlyhRRvXp1sXPnTnHjxg2xbt064e3tLX788UchxH/btlOnTuLGjRvi4sWLIikpSTRs2NAwRPzly5fFV199JapXry5iY2OFEEIMGDBA9OrVS1y5ckXcvHlTfPXVV6JatWoiKSlJJCQkiMGDBxuG7i4IoqKihIeHh9i5c+cry2aOfNuoUSNx9epVERYWJpKTk0VgYKAYPny4uHbtmrh586aYPXu28PDwEBcvXhRCCLF7927h5eUl1q1bJ65fvy6WLFkiPD09Rb169QzLfnaE0A0bNojq1auLXbt2iaioKPHrr7+KwMBAMWPGDKN21KlTRxw4cEBcu3ZNjB07Vnh6eoqoqCiRkpIiVq9eLTw8PER8fLxhP1nQvGiE4IEDB4qoqChx5coVERsbK2rUqCEmTZokrl27Js6fPy969+4t6tevbxhmfvbs2eKjjz4Shw4dEpGRkWLz5s3C19dXrFu3TgghxMGDB4Wfn584duyYuHXrltizZ4/w9vYW27dvfyvvO7e8M8EkLS1NBAYGiqFDhxqm9e/fX/j5+Ynk5GTx5MkT4e3tLTZt2mSYn5qaKgIDAw075YsXLxo+IJmOHTsmPDw8xO3bt4UQGcHE09NTVKlSRVSpUkX4+PgIDw8PUaNGDXHlyhVDvTZt2oiBAwcaLevgwYPCw8NDXLt2TRw+fFh4eHiIy5cvG+br9Xrx2WeficGDBwshhPjyyy9Ft27dREJCghAiI8wcOXLE8DokJMRohyNH9erVE97e3obt5e3tLTw8PETbtm0N72Pt2rXi0qVLRvXat28vxowZI4QQYt68eeKjjz4SWq3WMD9zW/71118iOTlZVKpUSfz8889Gy/jss89eGky+/PJLo/ItW7YU48aNE0IIMWrUKNGuXTuj+T/++GOBDSZeXl6GPsr8+eKLLwzfm7Vr1xrVmTZtmqhVq5bRkPIHDhwwzN+0aZPw8/Mz6jOdTmcUVFu0aCFGjBghUlNThRBCPHnyRPz555+G1y8b9j4/+vvvv4WHh4c4duyY0fQ+ffoYbfemTZsaAkHm8ONCCHH//n2xZMkSo2HQNRqN8PDwMATqdu3aiREjRhgt/8svv3xhMKlTp45Yvny5UfnNmzcLHx8fkZqaamjHqlWrDPMTEhKEh4eH2LVrlxDi7Q7jn1deFEye3W/NmTNHNG/e3Khe5r5py5YtIikpSfj4+Ih9+/YZlZk3b56hf1atWiUCAwPFzZs3DfNPnTpl9GiFguCducbkyJEjuHv3rtHFSU2bNkVoaCj27NmD8uXLIy0tDT4+Pob5arUaFSpUMLyuUKECHB0dsWzZMty4cQM3b97EpUuXAGQczs5UsWJFBAcHG6bfv38fq1evRocOHbBp0yaUK1cOV65cMbm+pXr16gCAy5cv49atW7C3t4eHh4dhviRJ8PPzw9GjRwEAvXr1Qt++fREQEABfX18EBgaiWbNmb/TCtbzQoUMHwymV9PR03Lx5E3PmzEGnTp2wZcsWdOrUCYcOHcKOHTsQFRWFK1euIDo6GqVLlwaQ8YRab29vo0fW+/n5GX6PiIhAamqq4dHjmapVq2b0BNrnPf/UWXt7e6SlpRnWWatWLaP5z66zoKlfvz5GjBhhNM3KygrXr19HWloaqlWrZjTPz88Pq1atwv379w3TMvsLyNh+iYmJqFGjhlE9jUZjOL06YMAAjBw5EqGhofDz80Pt2rXRtGlTqNXqN/zu5MHJyQlAxincZ02aNMlw2nLt2rVGT70tVaqU4XdnZ2d06tQJe/fuRXh4OCIjIw37p8xTL1ntd3x9fbP8Hjx48ACxsbGYN28eFixYYJiu1+uh0WgQExNj6ItnvyuZ+5/M78q77PnPfEREBHx9fY3KZH7mr127Bo1Gg9GjRxtOfwEZ+0StVovU1FS0aNECW7ZswSeffILy5csjMDAQDRs2RLFixfLqLeWJdyaYZJ4zHTRokMm8DRs2YMKECVnWs7D4bxOdOnUKQUFBqFu3Lvz8/NCsWTOkpKSgf//+RnWsrKyMdhhly5ZFpUqVULNmTWzevBmjR4+GEMLkmpPMcGNhYZHlfCBjp5DZJl9fXxw5cgR//vknjh8/js2bN2P+/PlYvnw5AgICsrNZZMHR0dFoe5UrVw6Ojo7o3Lkz/u///g/r16/H5cuX8emnn6JRo0YYNmwYxo0bZyivVCpNrgV6Vub2Emaeh1WpVCbTMpfxqnUWNLa2tkZ9lCk2NhYATD6rmdvm2e/Ps4FCr9ejTJky+OGHH0yWaWNjAwBo2LAhjh49iqNHj+L//u//sHz5csybNw+bNm3KlcfIv20lSpRA4cKFcfLkSaPwULRoUcPvjo6ORnWsrKwMv9+7dw/t2rWDk5MTGjRogICAAPj4+KBu3bpGdZ7/Hjwb6J+V2YdjxowxCeEA4Obmhvj4eAAv/668y57tH71ej5o1a2b5b429vT2io6MBAHPnzkXZsmVNyqhUKlhZWWHHjh04e/Ys/vzzTxw7dgwrV67EwIEDMWDAgNx7I3nsnbj49cGDBzhy5Ahat26N7du3G/20adMG58+fh1arhVqtxpkzZwz10tPTjf6SWLFiBfz9/bFgwQJ0794dgYGBuHPnDoBXfwklSYJerzeU8/DwMFoXAMOFreXKlUP58uWRkJCAK1euGJU5c+YM3n//fQBASEgIzpw5gwYNGuCbb77B/v37UaJECezfv9+wzvzu33//xZEjRxASEoIRI0agRYsWKFmyJKKiogzb0tPTExcuXDD6C+3cuXOG30uVKgUrKyv8888/RssOCwvLcbs8PT2N1vH8Ot8VZcuWhYWFhdFF2UDGZ7lw4cIm/5Bm8vDwwO3bt2Fvb49SpUqhVKlSKF68OGbPno1Tp05Bq9Vi2rRpiI6ORtOmTTFlyhSEhoZCoVDg8OHDAArG5/tZSqUSn3/+ObZv3/7CI3mZ+5us7Nq1C48ePcKGDRvQr18/NGzY0HBha+Z3pUKFCib7nfPnz2e5PBcXF7i4uCAqKsrQR6VKlcKFCxcwd+7cbL+vgtZPOfXBBx8gIiICbm5uhm3p6OiIqVOn4sqVK4bv0u3bt42295EjR7BixQooFArs2LEDP//8M6pVq4ZBgwZh06ZNaNu2Lfbu3fu2394b9U4Ekx07diA9PR09e/aEh4eH0U/fvn2hVCqxbds2dOnSBSEhIfjtt98QERGBCRMmGA1o5ObmhsuXL+P06dOIiYnBli1bMG/ePAAwGqwtLS0Nd+/eNfxcuXIFX3/9NbRaLZo3bw4A6NGjB3777TcsXLgQN27cwO+//45vv/0W9erVQ7ly5RAYGIjy5ctj+PDhOHHiBCIiIjBp0iRcuXIF3bp1AwBERkZiwoQJOH78OG7duoVff/0Vt2/fNhwqtLGxwePHj3Hjxg1ZH1ZNTk42bKv4+HicPn0aU6dORZEiRdC2bVtYWFhg3759iI6Oxvnz5zFkyBDcvXvXsM07deqEJ0+eYNy4cYiIiMDx48cxefJkABk7RWtra3Tt2hUhISE4cOAAbty4geDgYJOgYo6goCD8+++/CA4Oxo0bN3DgwAHDZ+Fd2hHb29ujXbt2CAkJwa5duxAZGYmffvoJ69evR1BQ0Au3RYsWLeDo6IgBAwbgn3/+QUREBMaMGYMjR47ggw8+gEqlwrlz5zBu3Dj8888/iImJwdatW5GUlGT0+Y6Pjzf8pVkQ9OzZE/Xq1UOnTp2wePFihIeHIyYmBocOHUJQUBC2bNmCmjVrZlnX1dUVKSkp2LdvH27fvo1jx45h2LBhAP7bP/Xu3RuhoaFYvnw5bt68ibVr1xr+kHmeJEno2bMn1q5di7Vr1yIqKgoHDhzApEmToFKpsjxKkpXMI2D//vuv0Z1075rM/dSwYcNw6dIlhIeHY/jw4QgLC8MHH3wAe3t7dOjQAXPnzsX27dsRHR2Nbdu2YdasWYZxazQaDWbMmIHt27cjJiYGp0+fxsmTJ01OD+V378SpnK1bt6JWrVom1wwAGYdPGzZsiD179uCPP/6AWq3G5MmTkZSUhCZNmhiNiDho0CDcu3fPcOvX+++/j6lTp2LkyJEICwszLP/s2bOoXbs2gIwvt62tLSpUqIDFixejYsWKADIGrNLpdFiyZAl++OEHODs7o3nz5oZTTRYWFli1ahVmzJiBgQMHQqvVwtvbG6tXrzZcKzFp0iTMmDEDI0eOxKNHj1C8eHGMGDECLVu2BAB88skn2LRpE1q0aIF169ahcuXKubOBX9PKlSuxcuVKAIBCoYCTkxOqVauG4OBgFC1aFNOnT8f8+fPx008/oXDhwvjoo4/QvXt3HDx4EEIIuLi4YPny5Zg6dSpatmwJV1dXdOzYETNnzjQcph48eDDS0tLwzTffICUlBfXq1UODBg2Mbs82h4eHBxYsWIDvv/8eq1evRpkyZdC5c2fMnz//hYfGC6qxY8fCyckJs2fPxr1791CqVCmMHz8e7dq1e2Ede3t7rFu3DjNnzkTPnj2h0+lQoUIFrFixwnCaZt68eZg2bRq+/PJLPHnyBGXLlsXs2bMN1/K0atUKoaGhaN68OUJDQ1GkSJE8eb+5SaFQYO7cudi3bx+2bNmCH3/8EQkJCXjvvffg5+eHdevWoXr16lnekt64cWNcuHABM2bMQGJiIooXL462bdvi4MGDCAsLQ8eOHfHRRx9h9uzZmD9/PubNm4cqVaogKCgIu3fvzrI9QUFBUKvVWLt2LWbMmAEXFxe0bt0aQ4cOzfZ7qlmzJipXrowOHTpg1qxZaNKkSY63T35WokQJrFu3DrNnz0anTp2gVCpRpUoVrFmzBi4uLgAyTps5OzsjJCQE8fHxcHV1xYABA9C7d28AQLt27fD48WMsWrQId+7cgaOjIxo1amRy/Vd+JwmeCKR87tq1a3j8+LHRBZh///03OnbsiMOHD8PNzQ2hoaGoVq2a0ciuQUFBcHV1xdSpU81eZ1hYGCwsLODl5WWYtmvXLnz99dc4e/as0bUVRESUfe/EqRwq2OLi4gzn5m/duoWzZ89i2rRpqFGjBtzc3ABkXB80fPhwXLp0CdHR0Vi9ejX++usvtGjRIkfrDA8Px+eff46DBw/i9u3bOH78OObPn49mzZoxlBARvQYeMaECYf369Vi7di1iYmJgb29vuL21UKFCADJGqJw+fTpOnTqF1NRUvP/+++jbty8aNmyYo/UJIbBw4UJs27YNcXFxcHFxQbNmzTBo0CCjK/GJiMg8DCZEREQkGzyVQ0RERLLBYEJE9JbVr18f5cuXN/xUrFgRjRo1wvLly/O0Hbdv38aePXuM2jV//vw8bQMRr9IjIpKBoKAgBAUFAQBSU1Nx7tw5fPPNN7C2tkbnzp3zpA2jR49G8eLFDSPPbt68ucA+AoDki8GEiEgGbGxsULhwYcPrEiVK4MSJE9iyZUueBZPnPXt7PVFe4akcIiKZsra2Nvyu0+mwevVqNGrUCD4+PmjUqBE2bdpkVD4iIgJ9+/aFv7+/Ydjy27dvG+bfvHkTPXr0QLVq1eDr64sePXrg8uXLAICuXbvi5MmT2LZtm2FgyWdP5cyfPx9du3bFsmXLUKdOHfj4+ODzzz/H9evXDct/8OABhg4dCj8/P/j7+2PWrFn4/PPPeTqIzMJgQkQkQ2FhYdi1axfat28PAJg+fToWLVqEAQMGYNeuXfj8888xefJkrF27FgBw69YttG/fHiqVCmvWrDE83blLly5ITEwEAAwbNgxFihTBli1b8Msvv0ChUBge/jZ//nz4+vqiSZMm2Lx5c5ZtOnv2LE6dOoWlS5di9erVuH37NiZNmgQg4yF1ffr0QWRkJJYtW4aVK1ciLCwMJ0+ezO1NRQUMT+UQEcnAkiVLDI9mSEtLQ1paGipXroymTZsiMTERP//8M7766it8+umnAIDSpUsjOjoaixcvRpcuXbB+/XrY2NggODjY8BybkJAQ1K9fHzt37kSnTp0QFRWFwMBAuLu7w8LCAlOnTsX169eh1+tRqFAhWFpawsrK6oWncNLT0zFz5kzD+EBdu3bFrFmzAAAnT55EWFgY9u3bZ3g67ty5c1GvXr3c3GxUAPGICRGRDHTo0MHw1PMdO3Zg0aJFSE5ORqdOnXD9+nWkpaUZPXYBAPz8/HDv3j3cv38fV65cQcWKFY0erufi4oIyZcoYTtcMHToUK1euRM2aNTFgwAAcOnQIFSpUgEKRvX8K3nvvPUMoATKeeZT5gNCLFy/C0dHREEqeXT+ROXjEhIhIBhwdHVGqVCnD63LlysHR0RGdO3fGH3/8AcD0ydV6vR5AxkM/hRBZPs1Zp9MZHizZuXNnNG7cGEeOHMHx48fx/fffY/78+di+fbvhCbYv87InCiuVSkN7iF4Hj5gQEcmcp6cnLCwscPr0aaPpp0+fRuHCheHo6AgPDw+EhYVBq9Ua5t+7dw+RkZEoV64c7t27h8mTJyMtLQ2tW7fGrFmzsHPnTty9e/eNXAfi6emJJ0+eICIiwjDt0aNHiIyMfO1l07uFwYSISAaSk5Nx9+5d3L17F/Hx8Th9+jSmTp2KIkWKIDAwEO3atUNISAh27dqFyMhI/PTTT1i/fj2CgoIgSRI6duyIxMREjBgxAuHh4QgLC8PgwYPh5OSEZs2aoVChQjh8+DC++eYbw8Ms169fD0tLS1SsWBEAYGtri1u3biE2Ntbs9vv7+6NKlSoYNWoU/vnnH4SHh2PEiBFISUnJ8kgO0YvwVA4RkQysXLnScPGrQqGAk5MTqlWrhuDgYFhbW2Ps2LFwcnLC7Nmzce/ePZQqVQrjx49Hu3btAGSMe7J27VoEBwcb7s4JDAzErFmz4ODgAABYtmwZZsyYge7duyMlJQUVKlTA0qVLUbJkSQAZ17mMHj0aLVq0wPHjx81+DyEhIZg8eTK6d+8OtVqNTp06ISIiwnAqiSg7+BA/IiJ6bQ8ePMC5c+dQu3ZtQxDRarXw9/fHhAkT0KpVq7fbQMo3eMSEiIhem4WFBYYOHYoOHTqgY8eOSEtLw4oVK6BSqVCnTp233TzKR3jEhIiI3oi//voLc+fOxeXLlyFJEqpVq4YRI0agfPnyb7tplI8wmBAREZFs8K4cIiIikg0GEyIiIpINBhMiIiKSDQYTIiIikg0GEyIiIpINBhMiIiKSDQYTIiIikg0GEyIiIpINBhMiIiKSjf8HEyqAQhx0H+UAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "sns.set()\n",
    "n= 5\n",
    "x = [0.824390243902439 , 1.0 , 1.0 , 0.9560975609756098 , 1.0 ]\n",
    "y = [ 0.8018018018018018 , 1.0 , 1.0 , 0.9326923076923077 , 1.0 ]\n",
    "z = [ 0.8640776699029126 , 0.970873786407767 , 1.0 , 0.941747572815534 , 0.970873786407767]\n",
    "w = [ 0.8317757009345795 , 0.9852216748768473 , 1.0 ,  0.9371980676328503 , 0.9852216748768473 ]\n",
    "index = np.arange(n)\n",
    "bar_width = 0.15\n",
    "opacity = 0.9\n",
    "\n",
    "r1 = plt.bar(index, x, bar_width,\n",
    "alpha=opacity, color='b', label='Accuracy')\n",
    " \n",
    "r2 = plt.bar(index + bar_width,y, bar_width,\n",
    "alpha=opacity, color='r', label='Precision')\n",
    "\n",
    "r3 = plt.bar(index + (2*bar_width),z, bar_width,\n",
    "alpha=opacity, color='y', label='Recall')\n",
    "\n",
    "r4 = plt.bar(index + (3*bar_width),w, bar_width,\n",
    "alpha=opacity, color='g', label='F1 Score')\n",
    "plt.xticks(index + (bar_width),('ACO+\\nAdaBoost','ACO+\\nBagging','ACO+Random\\nForest','ACO+\\nGradient\\nBoosting' ,\n",
    "                                'ACO+Extra\\nTrees'))\n",
    "\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}