HypertensionAnalysis.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Stroke Prediction Dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import plotly.graph_objects as go\n",
    "import plotly.offline as py\n",
    "import plotly.express as px\n",
    "from plotly.subplots import make_subplots\n",
    "py.init_notebook_mode(connected=True)\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.utils import resample\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.model_selection import StratifiedKFold\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics import accuracy_score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# caricamento dati\n",
    "df = pd.read_csv('./healthcare-dataset-stroke-data.csv')\n",
    "# dimensioni\n",
    "nRow, nCol = df.shape\n",
    "print('Le dimensioni del dataframe sono:')\n",
    "print(nRow, nCol)\n",
    "\n",
    "# nomi delle colonne\n",
    "print(df.columns)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data cleaning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# salvo una copia\n",
    "dfOriginal = df.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# rinomino colonne\n",
    "df.rename(columns = {'Residence_type':'residence_type'}, inplace = True)\n",
    "columnNames = df.columns.tolist()\n",
    "columnNames"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# trovo i valori NaN\n",
    "for i in columnNames:\n",
    "    print(str(i) + ' has: ' + str(df[i].isnull().values.sum()) + ' NaN values')\n",
    "# BMI ha dei valori mancanti"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# rimuovo tutti i NaN presenti dal dataframe (in questo caso solo dalla colonna BMI)\n",
    "df = df.dropna() # rimuove 201 righe\n",
    "# rimuovo tutti i soggetti con età inferiore a 14 (età in cui è visibile il primo stroke = 1)\n",
    "df = df[df.age >= 14] # rimuove 629 righe\n",
    "# rimuovo il soggetto in cui non è specificato il genere\n",
    "df = df[df.gender != 'Other'] # Rimuove 1 riga\n",
    "df.reset_index(inplace=True, drop=True)\n",
    "df.index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# nuove dimensioni\n",
    "nRow, nCol = df.shape\n",
    "print('Le dimensioni del dataframe pulito sono:')\n",
    "print(nRow, nCol)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Prima analisi delle variabili numeriche"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# rimuovo le colonne degli ID e degli index per una visualizzazione grafica migliore\n",
    "df_noID = df.copy().drop(columns=['id'])\n",
    "df_noID.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_noID.hist(bins = 10)\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# trovo i valori 'unique' per ogni colonna\n",
    "for i in columnNames:\n",
    "    if i == 'id' or i == 'index' or i == 'age' or i == 'bmi' or i == 'avg_glucose_level':\n",
    "        pass\n",
    "    else:\n",
    "        print(str(i) + ' has: ' + str(pd.unique(df[i])) + ' unique values\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Analisi sull'incidenza di ipertensione\n",
    "Plotto la distribuzione del genere all'interno del dataset, la distribuzione dei soggetti che hanno riportato ipertensione e la distribuzione di quest'ultima all'interno delle due classi di genere.\n",
    "\n",
    "Si può notare che il dataset include una leggera maggioranza di donne, l'incidenza di ipetensione è molto sbilanciata rispetto al dataset completo (solo 10.5% del totale) e che è leggermente più presente nel subset di soggetti maschili nonstante siano in numero minore."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numero di soggetti che riportano ipertensione sul totale di soggetti (4279):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.query('hypertension==1').count()['hypertension']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numero di soggetti di genere femminile che riportano ipertensione sul totale di soggetti femminili (2599):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[df.gender == 'Female'].query('hypertension==1').count()['hypertension']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numero di soggetti di genere maschile che riportano ipertensione sul totale di soggetti maschili (1680):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[df.gender == 'Male'].query('hypertension==1').count()['hypertension']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = make_subplots(\n",
    "    rows=2, cols=2,subplot_titles=('<b>Distribution of <i>Genders</i></b>','<b>Distribution of <i>Hypertension</i></b>','<b><i>Hypertension</i> of Male Subjects</b>','<b><i>Hypertension</i> of Female Subjects</b>'),\n",
    "    vertical_spacing=0.09,\n",
    "    specs=[[{\"type\": \"pie\",\"colspan\": 1}       ,{\"type\": \"pie\",\"colspan\": 1}],\n",
    "           [{\"type\": \"pie\",\"rowspan\": 1}       ,{\"type\": \"pie\",\"rowspan\": 1}],                                      \n",
    "          ]\n",
    ")\n",
    "\n",
    "fig.add_trace(\n",
    "    go.Pie(values=df.gender.value_counts().values,labels=['Donne','Uomini'],hole=0.5,pull=[0,0.02,0.5],marker_colors=['lightpink','lightblue'],textposition='inside'\n",
    "          ),\n",
    "    row=1, col=1\n",
    ")\n",
    "\n",
    "fig.add_trace(\n",
    "    go.Pie(values=df.hypertension.value_counts().values,labels=['No Hypertension','Hypertension'],hole=0.5,pull=[0,0.02,0.5],marker_colors=['lightgreen','red'],textposition='inside'\n",
    "          ),\n",
    "    row=1, col=2\n",
    ")\n",
    "\n",
    "fig.add_trace(\n",
    "    go.Pie(values=df.query('gender==\"Male\"').hypertension.value_counts().values,labels=['No Hypertension','Hypertension'],hole=0,pull=[0,0.02,0.5],marker_colors=['lightgreen','red'],textposition='inside'\n",
    "          ),\n",
    "    row=2, col=1\n",
    ")\n",
    "\n",
    "fig.add_trace(\n",
    "    go.Pie(values=df.query('gender==\"Female\"').hypertension.value_counts().values,labels=['No Hypertension','Hypertension'],hole=0,pull=[0,0.02,0.5],marker_colors=['lightgreen','red'],textposition='inside'\n",
    "          ),\n",
    "    row=2, col=2\n",
    ")\n",
    "\n",
    "fig.update_layout(\n",
    "    height=800,\n",
    "    showlegend=True,\n",
    "    title_text=\"<b>Gender and Hypertension<b>\"\n",
    ")\n",
    "\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A questo punto plotto la distribuzione delle età dei soggetti del dataset all'interno di un istogramma evidenziando in rosso l'incidenza di ipertensione i base all'età."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "age_distr = px.histogram(\n",
    "        df,x=df.age,color=\"hypertension\",title='<b>Age distribution</b>',color_discrete_sequence=px.colors.qualitative.G10#Dark2\n",
    "    )\n",
    "age_distr.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'età media dei soggetti è:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.age.mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'età media dei soggetti che riportano ipertensione è:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.query('hypertension==1').mean()['age'].round(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Categorie in base all'indice di massa corporea (BMI)\n",
    "Calcolo le categorie di appartenenza sulla base del valore di BMI e le inserisco in una nuova colonna del dataframe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bmi_g = []\n",
    "for i in df['bmi']:\n",
    "    if i > 30:\n",
    "        bmi_g.append('obesità')\n",
    "    elif i <= 30 and i >= 25:\n",
    "        bmi_g.append('sovrappeso')\n",
    "    elif i < 25 and i >= 18.5:\n",
    "        bmi_g.append('normopeso')\n",
    "    elif i < 18.5:\n",
    "        bmi_g.append('sottopeso')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['bmi_group']=pd.Series(bmi_g)\n",
    "df.sort_values('id')#.drop(columns=['index'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Categorie in base alla media del livello di glucosio\n",
    "Calcolo le categorie di appartenenza sulla base del valore medio del livello di glucosio e le inserisco in una nuova colonna del dataframe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "glucose_g = []\n",
    "for i in df['avg_glucose_level']:\n",
    "    if i < 60:\n",
    "        glucose_g.append('ipoglicemia')\n",
    "    elif i >= 60 and i <= 110:\n",
    "        glucose_g.append('normale')\n",
    "    elif i >= 110:\n",
    "        glucose_g.append('iperglicemia')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['glucose_group']=pd.Series(glucose_g)\n",
    "df.sort_values('id')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Categorie in base all'età'\n",
    "Calcolo le categorie di appartenenza sulla base dell'età e le inserisco in una nuova colonna del dataframe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "age_g = []\n",
    "for i in df['age']:\n",
    "    if i < 35:\n",
    "        age_g.append('giovane')\n",
    "    elif i >= 35 and i <= 55:\n",
    "        age_g.append('adulto')\n",
    "    elif i >= 55:\n",
    "        age_g.append('anziano')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['age_group']=pd.Series(age_g)\n",
    "df.sort_values('id')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# aggiorno la lista delle colonne\n",
    "columnNames = df.columns.tolist()\n",
    "columnNames"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ciclo for per creare tutte le coppie di immagini:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "for i in columnNames:\n",
    "    if i != 'id' and i != 'bmi' and i != 'age' and i != 'hypertension' and i != 'avg_glucose_level':\n",
    "        fig = px.histogram(\n",
    "        df,x=df[str(i)],color='hypertension',title=('<b>Hypertension - '+str(i)+' relation</b>'),color_discrete_sequence=px.colors.qualitative.Pastel2\n",
    "        )\n",
    "        fig.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Non si nota un particolare comportamento prevalente per distinguere in modo evidente le due classi di ipertensione.\n",
    "L'unico aspetto evidente è che l'ipertensione si presenta soprattutto nei soggetti con età maggiore."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Per vedere tutti i plot incrociati per tutti gli attributi decommentare la seguente cella:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "#for i in columnNames:\n",
    "#    for j in columnNames:\n",
    "#        if i != 'id' and i != 'bmi' and i != 'age' and j != 'id' and j != 'bmi' and j != 'age' and i != j:\n",
    "#            fig = px.histogram(\n",
    "#            df,x=df.bmi_group,color=str(i),title=('<b>BMI-'+str(i)+' relation</b>'),color_discrete_sequence=px.colors.qualitative.Pastel2\n",
    "#            )\n",
    "#        fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Resampling\n",
    "Poichè il dataset è molto sbilanciato è bene ricampionare i dati. Per evitare di sovracampionare e rendere meno realistica la previsione, si decide di utilizzare un sottogruppo di campioni che riportano un target pari a 0 e la totalità dei campioni che hanno target pari a 1:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nuovo set di campioni con target pari a 1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "resampled1 = resample(df.query('hypertension==1'), replace=True, n_samples=400, random_state=None, stratify=None)\n",
    "resampled1.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nuovo set di campioni con target pari a 0:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "resampled0 = resample(df.query('hypertension!=1'), replace=True, n_samples=1200, random_state=None, stratify=None)\n",
    "resampled0.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nuovo set di campioni completo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "frames = [resampled0, resampled1]\n",
    "\n",
    "resampled = pd.concat(frames)\n",
    "\n",
    "resampled.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# converto i valori stringa in numerici\n",
    "resampled.gender = resampled.gender.replace({'Male':0,'Female':1}).astype(np.uint8)\n",
    "resampled.ever_married = resampled.ever_married.replace({'No':0,'Yes':1}).astype(np.uint8)\n",
    "resampled.residence_type = resampled.residence_type.replace({'Rural':0,'Urban':1}).astype(np.uint8)\n",
    "resampled.work_type = resampled.work_type.replace({'Private':0,'Self-employed':1,'Govt_job':2,'children':-1,'Never_worked':-2}).astype(np.uint8)\n",
    "resampled.smoking_status = resampled.smoking_status.replace({'Unknown':-1,'never smoked':0,'formerly smoked':1,'smokes':2}).astype(np.uint8)\n",
    "resampled.bmi_group = resampled.bmi_group.replace({'sottopeso':-1,'normopeso':0,'sovrappeso':1,'obesità':2}).astype(np.uint8)\n",
    "resampled.glucose_group = resampled.glucose_group.replace({'ipoglicemia':-1,'normale':0,'iperglicemia':1}).astype(np.uint8)\n",
    "resampled.age_group = resampled.age_group.replace({'giovane':0,'adulto':1,'anziano':2}).astype(np.uint8)\n",
    "\n",
    "resampled"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Utilizzo la funzione train_test_split per dividere i campioi in train e test set, untilizzando l'attributo 'stratify' che permette di mantenere la proporzione originale di campioni con etichetta 0 o 1 (quindi 1:3 in questo caso)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Caso 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Caso 1:\n",
    "Utilizzo le seguenti colonne di attributi per l'analisi:\n",
    "- 'gender'\n",
    "- 'heart_disease'\n",
    "- 'ever_married'\n",
    "- 'work_type'\n",
    "- 'residence_type'\n",
    "- 'smoking_status'\n",
    "- 'stroke'\n",
    "- 'bmi_group'\n",
    "- 'glucose_group'\n",
    "- 'age_group'\n",
    "\n",
    "NB: non utilizzo le colonne 'bmi', 'avg_glucose_level' e 'age' che hanno dei valori puntuali ma utilizzo i loro corrispettivi gruppi 'bmi_group', 'glucose_group' e 'age_group'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = resampled[['gender', 'heart_disease', 'ever_married', 'work_type', 'residence_type', 'smoking_status', 'stroke', 'bmi_group', 'glucose_group', 'age_group']]\n",
    "y = resampled['hypertension']\n",
    "X_train, X_validation, Y_train, Y_validation = train_test_split(X, y, test_size=0.30, random_state=1, shuffle=True, stratify=y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modelli di classificazione"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "models = []\n",
    "models.append(('LR', LogisticRegression(solver='liblinear', multi_class='ovr')))\n",
    "models.append(('KNN', KNeighborsClassifier()))\n",
    "models.append(('CART', DecisionTreeClassifier()))\n",
    "models.append(('NB', GaussianNB()))\n",
    "models.append(('SVM', SVC(gamma='auto')))\n",
    "models"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Risultati della classificazione"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "results = []\n",
    "names = []\n",
    "for name, model in models:\n",
    "\tkfold = StratifiedKFold(n_splits=10, random_state=1, shuffle=True)\n",
    "\tcv_results = cross_val_score(model, X_train, Y_train, cv=kfold, scoring='accuracy')\n",
    "\tresults.append(cv_results)\n",
    "\tnames.append(name)\n",
    "\tprint('%s: %f (%f)' % (name, cv_results.mean(), cv_results.std()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La SVM LR e CART sono quelle che mi danno i risultati migliori.\n",
    "Plotto un boxplot per comparare le performance dei modelli e i relativi risultati di predizione."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.boxplot(results, labels=names)\n",
    "plt.title('Algorithm Comparison')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### SVM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = SVC(gamma='auto')\n",
    "model.fit(X_train, Y_train)\n",
    "predictions = model.predict(X_validation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(accuracy_score(Y_validation, predictions))\n",
    "print(confusion_matrix(Y_validation, predictions))\n",
    "print(classification_report(Y_validation, predictions))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### LR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = LogisticRegression(solver='liblinear', multi_class='ovr')\n",
    "model.fit(X_train, Y_train)\n",
    "predictions = model.predict(X_validation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(accuracy_score(Y_validation, predictions))\n",
    "print(confusion_matrix(Y_validation, predictions))\n",
    "print(classification_report(Y_validation, predictions))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### CART"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = DecisionTreeClassifier()\n",
    "model.fit(X_train, Y_train)\n",
    "predictions = model.predict(X_validation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(accuracy_score(Y_validation, predictions))\n",
    "print(confusion_matrix(Y_validation, predictions))\n",
    "print(classification_report(Y_validation, predictions))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Caso 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Caso 2:\n",
    "Utilizzo le seguenti colonne di attributi per l'analisi:\n",
    "- 'gender'\n",
    "- 'heart_disease'\n",
    "- 'ever_married'\n",
    "- 'work_type'\n",
    "- 'residence_type'\n",
    "- 'smoking_status'\n",
    "- 'stroke'\n",
    "- 'bmi'\n",
    "- 'avg_glucose_level'\n",
    "- 'age'\n",
    "\n",
    "NB: in questo caso utilizzo le colonne 'bmi', 'avg_glucose_level' e 'age' che hanno dei valori puntuali ed escludo i loro corrispettivi gruppi 'bmi_group', 'glucose_group' e 'age_group'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = resampled[['gender', 'heart_disease', 'ever_married', 'work_type', 'residence_type', 'smoking_status', 'stroke', 'bmi', 'avg_glucose_level', 'age']]\n",
    "y = resampled['hypertension']\n",
    "X_train, X_validation, Y_train, Y_validation = train_test_split(X, y, test_size=0.30, random_state=1, shuffle=True, stratify=y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Risultati della classificazione"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "results = []\n",
    "names = []\n",
    "for name, model in models:\n",
    "    kfold = StratifiedKFold(n_splits=10, random_state=1, shuffle=True)\n",
    "    cv_results = cross_val_score(model, X_train, Y_train, cv=kfold, scoring='accuracy')\n",
    "    results.append(cv_results)\n",
    "    names.append(name)\n",
    "    print('%s: %f (%f)' % (name, cv_results.mean(), cv_results.std()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Come nel caso 1, la SVM è quella con l'accuracy più alta.\n",
    "Plotto un boxplot per comparare le performance dei modelli."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.boxplot(results, labels=names)\n",
    "plt.title('Algorithm Comparison')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(accuracy_score(Y_validation, predictions))\n",
    "print(confusion_matrix(Y_validation, predictions))\n",
    "print(classification_report(Y_validation, predictions))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "results = []\n",
    "names = []\n",
    "for name, model in models:\n",
    "    kfold = StratifiedKFold(n_splits=10, random_state=1, shuffle=True)\n",
    "    cv_results = cross_val_score(model, X_train, Y_train, cv=kfold, scoring='roc_auc')\n",
    "    results.append(cv_results)\n",
    "    names.append(name)\n",
    "    print('%s: %f (%f)' % (name, cv_results.mean(), cv_results.std()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(12,10))\n",
    "plt.title('Classification Algorithms')\n",
    "plt.xlabel('Algorithm')\n",
    "plt.ylabel('ROC-AUC')\n",
    "plt.boxplot(results)\n",
    "ax = fig.add_subplot(111)\n",
    "ax.set_xticklabels(names)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Commento\n",
    "La confusion matrix mostra come la predizione sia molto influenzata dalla distribuzione del dataset, infatti si può notare che, in entrambi i casi, il numero più alto dovuto alle misclassificazioni è da attribuirsi al numero di falsi negativi. Questo può essere spiegato dal fatto che la parte più importante dei campioni utilizzati presenta un target negativo e quindi è più facile classificare un nuovo campione all'interno di quella classe.\n",
    "La possibile differenza tra il caso 1 e il caso 2 è da attribuirsi all'utilizzo di attributi categorici rispetto a valori numerici."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}