heartDisease_MLP.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as mplot\n",
    "from matplotlib.colors import ListedColormap\n",
    "import os\n",
    "import subprocess\n",
    "import sklearn\n",
    "\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from sklearn.datasets import load_files\n",
    "from sklearn.feature_extraction.text import TfidfTransformer\n",
    "from sklearn.model_selection import train_test_split, KFold\n",
    "from sklearn.metrics import classification_report, confusion_matrix, ConfusionMatrixDisplay, accuracy_score, f1_score, precision_score, recall_score,  precision_recall_fscore_support\n",
    "from sklearn.metrics import roc_auc_score\n",
    "from sklearn.metrics import roc_curve\n",
    " \n",
    "import random\n",
    " \n",
    "\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "\n",
    "from imblearn.under_sampling import RandomUnderSampler\n",
    "from imblearn.over_sampling import SMOTE\n",
    "\n",
    "import tensorflow as tf\n",
    "import keras\n",
    "from keras import Sequential\n",
    "from keras.layers import Dense, Dropout\n",
    "from keras.utils import to_categorical\n",
    "from keras.datasets import mnist\n",
    "from keras.utils import plot_model\n",
    "\n",
    "\n",
    "\n",
    "from sklearn.tree import export_graphviz\n",
    "import pydotplus\n",
    "import seaborn as sns\n",
    "\n",
    "from tabulate import tabulate \n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of fileData: (37079, 51)\n",
      "Column Headings: Index(['SEQN', 'Gender', 'Age', 'Annual-Family-Income',\n",
      "       'Ratio-Family-Income-Poverty', 'X60-sec-pulse', 'Systolic', 'Diastolic',\n",
      "       'Weight', 'Height', 'Body-Mass-Index', 'White-Blood-Cells',\n",
      "       'Lymphocyte', 'Monocyte', 'Eosinophils', 'Basophils', 'Red-Blood-Cells',\n",
      "       'Hemoglobin', 'Mean-Cell-Vol', 'Mean-Cell-Hgb-Conc.',\n",
      "       'Mean-cell-Hemoglobin', 'Platelet-count', 'Mean-Platelet-Vol',\n",
      "       'Segmented-Neutrophils', 'Hematocrit', 'Red-Cell-Distribution-Width',\n",
      "       'Albumin', 'ALP', 'AST', 'ALT', 'Cholesterol', 'Creatinine', 'Glucose',\n",
      "       'GGT', 'Iron', 'LDH', 'Phosphorus', 'Bilirubin', 'Protein', 'Uric.Acid',\n",
      "       'Triglycerides', 'Total-Cholesterol', 'HDL', 'Glycohemoglobin',\n",
      "       'Vigorous-work', 'Moderate-work', 'Health-Insurance', 'Diabetes',\n",
      "       'Blood-Rel-Diabetes', 'Blood-Rel-Stroke', 'CoronaryHeartDisease'],\n",
      "      dtype='object')\n",
      "Number of Records: 37079\n",
      "\n",
      "Number of Missing Values: 0\n",
      "Number of duplicate records removed: 0\n",
      "Shape of fileData: (37079, 51)\n",
      "Shape of fileData End: (37079, 51)\n",
      "\n",
      "\n",
      "columns of x:: 50 \n",
      "\n",
      " and features of X: Index(['SEQN', 'Gender', 'Age', 'Annual-Family-Income',\n",
      "       'Ratio-Family-Income-Poverty', 'X60-sec-pulse', 'Systolic', 'Diastolic',\n",
      "       'Weight', 'Height', 'Body-Mass-Index', 'White-Blood-Cells',\n",
      "       'Lymphocyte', 'Monocyte', 'Eosinophils', 'Basophils', 'Red-Blood-Cells',\n",
      "       'Hemoglobin', 'Mean-Cell-Vol', 'Mean-Cell-Hgb-Conc.',\n",
      "       'Mean-cell-Hemoglobin', 'Platelet-count', 'Mean-Platelet-Vol',\n",
      "       'Segmented-Neutrophils', 'Hematocrit', 'Red-Cell-Distribution-Width',\n",
      "       'Albumin', 'ALP', 'AST', 'ALT', 'Cholesterol', 'Creatinine', 'Glucose',\n",
      "       'GGT', 'Iron', 'LDH', 'Phosphorus', 'Bilirubin', 'Protein', 'Uric.Acid',\n",
      "       'Triglycerides', 'Total-Cholesterol', 'HDL', 'Glycohemoglobin',\n",
      "       'Vigorous-work', 'Moderate-work', 'Health-Insurance', 'Diabetes',\n",
      "       'Blood-Rel-Diabetes', 'Blood-Rel-Stroke'],\n",
      "      dtype='object')\n"
     ]
    }
   ],
   "source": [
    "dataSetIndex = 4\n",
    "needToMakePictureOfTrees = 0\n",
    "''' ---------------------------------------------------------- '''\n",
    "dataSetFilePath = \"\"\n",
    "dataSetName = \"\"\n",
    "dataSetResultDirectory = \"./\"\n",
    "\n",
    "if(dataSetIndex == 0):\n",
    "    dataSetFilePath = \"./heartDisease/0_statLog_dataSet.csv\"\n",
    "    dataSetName = \"SateLog_DataSet\"\n",
    "elif (dataSetIndex == 1):\n",
    "    dataSetFilePath = \"./heartDisease/1_heart_statlog_cleveland_hungary_final.csv\"\n",
    "    dataSetName = \"ALL_StateLog_CleveLand_Hungary\"\n",
    "elif (dataSetIndex == 2):\n",
    "    dataSetFilePath = \"./heartDisease/2_cleveland.csv\"\n",
    "    dataSetName = \"Cleveland\"\n",
    "elif (dataSetIndex == 3):\n",
    "    dataSetFilePath = \"./heartDisease/3_framingham.csv\"\n",
    "    dataSetName = \"framingham\"\n",
    "elif (dataSetIndex == 4):\n",
    "    dataSetFilePath = \"./heartDisease/4_CardiacPrediction.xlsx\"\n",
    "    dataSetName = \"CardiacPrediction\"\n",
    "elif (dataSetIndex == 5):\n",
    "    dataSetFilePath = \"./heartDisease/5_CardiacPredictionLessDimensions.xlsx\"\n",
    "    dataSetName = \"CardiacPrediction\"\n",
    "elif (dataSetIndex == 6):\n",
    "    dataSetFilePath = \"./heartDisease/6_CardiacPredictionFewDimensions.xlsx\"\n",
    "    dataSetName = \"CardiacPrediction\"\n",
    "else:\n",
    "    dataSetFilePath = \"\"\n",
    "    dataSetName = \"\"\n",
    "\n",
    "if(dataSetIndex==4 or dataSetIndex==5 or dataSetIndex==6):\n",
    "    #fileData = pd.read_excel(dataSetFilePath, sheet_name='CoroHeartDis')\n",
    "    fileData = pd.read_excel(dataSetFilePath)\n",
    "else:\n",
    "    fileData = pd.read_csv(dataSetFilePath)\n",
    "\n",
    "print(\"Shape of fileData: {}\".format(fileData.shape))\n",
    "print(\"Column Headings: {}\".format(fileData.__dataframe__().column_names()))\n",
    "print(\"Number of Records: {}\".format(fileData.__dataframe__().num_rows()))\n",
    "\n",
    "\n",
    "missingValues = fileData.isnull().any().sum()\n",
    "print(f\"\\nNumber of Missing Values: {missingValues}\")\n",
    "\n",
    "num_rows_before = fileData.shape[0]\n",
    "# Remove duplicate records based on all columns\n",
    "fileData.drop_duplicates(inplace=True)\n",
    "# Check the number of rows after removing duplicates\n",
    "num_rows_after = fileData.shape[0]\n",
    "# Print the number of duplicate records removed\n",
    "num_duplicates_removed = num_rows_before - num_rows_after\n",
    "print(f\"Number of duplicate records removed: {num_duplicates_removed}\")\n",
    " \n",
    " # Preprocess Steps from the ChatGPT\n",
    "# 1. Handling Missing Values:\n",
    "fileData = fileData.dropna()\n",
    "print(\"Shape of fileData: {}\".format(fileData.shape))              \n",
    "#fileData.replace({'?': np.nan}).dropna().astype(float)\n",
    "#fileData = fileData.fillna(0) \n",
    "\n",
    "fileData = fileData.fillna(0) \n",
    "\n",
    "print(\"Shape of fileData End: {}\".format(fileData.shape))\n",
    "\n",
    "\n",
    "\n",
    "finalResultTable = [ ['Index', 'Method', 'Accuracy %','Recall %','Precision %','F1 Score','AUC'], ]  \n",
    "\n",
    "X = fileData.drop(fileData.__dataframe__().column_names()[-1], axis=1)  # Features\n",
    "Y = fileData[fileData.__dataframe__().column_names()[-1]]  # Labels\n",
    "\n",
    "columns = fileData.__dataframe__().column_names() \n",
    "totalRecords = (fileData.__dataframe__().num_rows())\n",
    "\n",
    "print(\"\\n\")\n",
    "print(\"columns of x:: {} \\n\\n and features of X: {}\".format(len(X.columns), X.columns))\n",
    "\n",
    "dataSetResultDirectory = \"./\"\n",
    "dataSetResultDirectory += (\"DatasetResults_MLP_\" + dataSetName)\n",
    "dataSetResultDirectory += \"/\"\n",
    "if not os.path.isdir(dataSetResultDirectory):\n",
    "    os.makedirs(dataSetResultDirectory)\n",
    "\n",
    "dataSetName += \" {}\".format(fileData.shape)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fileData.hist(figsize=(10, 8))\n",
    "mplot.tight_layout()\n",
    "mplot.show()\n",
    "mplot.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Target Column Name: CoronaryHeartDisease\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "columns = fileData.__dataframe__().column_names() \n",
    "totalRecords = (fileData.__dataframe__().num_rows())\n",
    "columnsForGraph = []\n",
    "columnsForGraph.clear()\n",
    "tableDataRow = []\n",
    "for column in columns:\n",
    "    singleColumnCount = fileData[column].value_counts()\n",
    "    if(len(singleColumnCount) < 3):\n",
    "        #print('Column Name:{} -> total records:{}'.format(column, totalRecords ) )\n",
    "        #print('Number of classes:', len(singleColumnCount))\n",
    "        #print('Class distribution:')\n",
    "        #print(singleColumnCount)\n",
    "        #print(\"np Array: {}\".format(np.array(singleColumnCount)))\n",
    "        #print(\"index: 0: {} -> {} %\".format(np.array(singleColumnCount)[0], (np.array(singleColumnCount)[0] /totalRecords) * 100))\n",
    "        #print(\"index: 1: {} -> {} %\".format(np.array(singleColumnCount)[1], ( np.array(singleColumnCount)[1] /totalRecords) * 100))  \n",
    "        #print('---------------------------------------------------------------')\n",
    "        columnsForGraph.append(column)\n",
    " \n",
    "\n",
    "tableDataRow = [\n",
    "    ['Index', 'Column Name', 'Total Classes','Class A Records','Class B Records'],\n",
    "    \n",
    "]\n",
    "\n",
    "indexx = 1\n",
    "for column in columnsForGraph:\n",
    "    singleColumnCount = fileData[column].value_counts()\n",
    "    singleRowInTable = [] \n",
    "    singleRowInTable.append(indexx)\n",
    "    singleRowInTable.append(column)\n",
    "    singleRowInTable.append(len(singleColumnCount))\n",
    "    cellDataString = \"{} -> {:.2f}%\".format(np.array(singleColumnCount)[0], (np.array(singleColumnCount)[0] /totalRecords) * 100)\n",
    "    singleRowInTable.append((cellDataString)) \n",
    "    cellDataString = \"{} -> {:.2f}%\".format(np.array(singleColumnCount)[1], (np.array(singleColumnCount)[1] /totalRecords) * 100)\n",
    "    singleRowInTable.append((cellDataString)) \n",
    "    indexx += 1\n",
    "    tableDataRow.append(singleRowInTable) \n",
    "\n",
    "# Create the figure and axes\n",
    "fig, ax = mplot.subplots() \n",
    "table = mplot.table(cellText=tableDataRow, loc='center') \n",
    "\n",
    "table.auto_set_font_size(False)\n",
    "table.set_fontsize(12) \n",
    "table.scale(2.0, 2.0) \n",
    "print(\"Target Column Name: {}\".format(columns[-1]))\n",
    "\n",
    "\n",
    "dataSetString = \"Dataset:  {}, Total Records: {}, No. Features: {}\".format(dataSetName, totalRecords, fileData.__dataframe__().num_columns())\n",
    "target =\"Target Column Name: {} , No of Classes: {}\".format(columns[-1], len(fileData[columns[-1]].value_counts()))\n",
    "distributionOfTargetClassA =\"Class A Records: {} , {:.2f} %\".format(np.array(fileData[columns[-1]].value_counts())[0], (np.array(fileData[columns[-1]].value_counts())[0] /totalRecords) * 100)\n",
    "distributionOfTargetClassB =\"Class B Records: {} , {:.2f} %\".format(np.array(fileData[columns[-1]].value_counts())[1], (np.array(fileData[columns[-1]].value_counts())[1] /totalRecords) * 100)\n",
    "\n",
    "fig.text(-0.1, +0.25,  dataSetString, horizontalalignment='left', wrap=False , fontsize=12 )  \n",
    "fig.text(-0.1, +0.20,  target, horizontalalignment='left', wrap=False  , fontsize=12 )   \n",
    "fig.text(-0.1, 0.15,  distributionOfTargetClassA, horizontalalignment='left', wrap=False , fontsize=12  )   \n",
    "fig.text(-0.1, 0.10,  distributionOfTargetClassB, horizontalalignment='left', wrap=False  , fontsize=12 )   \n",
    " \n",
    " \n",
    "mplot.axis('off')\n",
    "mplot.title(f'Exploring Dataset - {dataSetName}' ,fontsize=16, fontweight='bold') \n",
    "\n",
    "picturePath = \"{}1.DataSet_analysis_{}.png\".format(dataSetResultDirectory, dataSetName)\n",
    "mplot.savefig(picturePath,  dpi=300, bbox_inches='tight')\n",
    "#mplot.savefig('DataSet_analysis.png', dpi=300)\n",
    "mplot.show()\n",
    "mplot.close()\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of fileData: (37079, 51) , target Len:37079\n",
      "X: (37079, 50) , Y:(37079,)\n",
      "Target Column Name:: CoronaryHeartDisease \n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\Mubashir Iqbal\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\joblib\\externals\\loky\\backend\\context.py:136: UserWarning: Could not find the number of physical cores for the following reason:\n",
      "found 0 physical cores < 1\n",
      "Returning the number of logical cores instead. You can silence this warning by setting LOKY_MAX_CPU_COUNT to the number of cores you want to use.\n",
      "  warnings.warn(\n",
      "  File \"c:\\Users\\Mubashir Iqbal\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\joblib\\externals\\loky\\backend\\context.py\", line 282, in _count_physical_cores\n",
      "    raise ValueError(f\"found {cpu_count_physical} physical cores < 1\")\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " X Train: Shape:: (56914, 50)\n",
      " X Test: Shape:: (14228, 50)\n",
      "Train DataSet Positive Class Records:: 28457\n",
      "Train DataSet Negative Class Records:: 28457\n",
      "Train DataSet Total Records:: 56914\n",
      "\n",
      "\n",
      "\n",
      "Test DataSet Positive Class Records:: 7114\n",
      "Test DataSet Negative Class Records:: 7114\n",
      "Test DataSet Total Records:: 14228\n"
     ]
    }
   ],
   "source": [
    "print(\"Shape of fileData: {} , target Len:{}\".format(fileData.shape, len(Y)))\n",
    "print(\"X: {} , Y:{}\".format(X.shape, Y.shape))\n",
    "#print(\"\\n\\nX: head:: \\n{}\".format(X.head()))\n",
    "#print(\"\\n\\nY: head::\\n {}\".format(Y.head()))\n",
    "\n",
    "# Split dataset into training set and test set\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.2, stratify=Y, random_state=42)\n",
    " \n",
    "\n",
    "print(\"Target Column Name:: {} \\n\".format(fileData.__dataframe__().column_names()[-1]))\n",
    "\n",
    "\n",
    "rus = RandomUnderSampler(random_state=42)\n",
    "smote = SMOTE(random_state=42)\n",
    "\n",
    "'''\n",
    "# Undersample the majority class\n",
    "X_train, y_train = rus.fit_resample(X_train, y_train)\n",
    "X_test, y_test = rus.fit_resample(X_test, y_test)\n",
    "'''\n",
    "\n",
    "# Oversample the minority class using SMOTE\n",
    "X_train, y_train = smote.fit_resample(X_train, y_train)\n",
    "#X_test, y_test = rus.fit_resample(X_test, y_test)\n",
    "X_test, y_test = smote.fit_resample(X_test, y_test) \n",
    "\n",
    "\n",
    "scaler = StandardScaler().fit(X_train)\n",
    "X_train_scaled = scaler.fit_transform(X_train)\n",
    "X_test_scaled = scaler.transform(X_test)\n",
    "\n",
    "\n",
    "\n",
    "print(\"\\n X Train: Shape:: {}\".format(X_train.shape))\n",
    "print(\" X Test: Shape:: {}\".format(X_test.shape))  \n",
    " \n",
    " \n",
    "positiveClass =  0\n",
    "negativeClass = 0\n",
    "for i in y_train:\n",
    "    if(i == 0):\n",
    "        negativeClass += 1\n",
    "    if(i == 1):\n",
    "        positiveClass += 1\n",
    "print(\"Train DataSet Positive Class Records:: {}\".format(positiveClass)) \n",
    "print(\"Train DataSet Negative Class Records:: {}\".format(negativeClass)) \n",
    "print(\"Train DataSet Total Records:: {}\".format(positiveClass + negativeClass)) \n",
    "\n",
    "print(\"\\n\\n\") \n",
    "\n",
    "\n",
    "positiveClass =  0\n",
    "negativeClass = 0\n",
    "for i in y_test:\n",
    "    if(i == 0):\n",
    "        negativeClass += 1\n",
    "    if(i == 1):\n",
    "        positiveClass += 1\n",
    "print(\"Test DataSet Positive Class Records:: {}\".format(positiveClass)) \n",
    "print(\"Test DataSet Negative Class Records:: {}\".format(negativeClass)) \n",
    "print(\"Test DataSet Total Records:: {}\".format(positiveClass + negativeClass)) \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def makeCorrelationPic(correlationMatrix, numberOfTopFeatures, targetColumnName):     \n",
    "    correlation_values = correlationMatrix.abs()\n",
    "    sorted_correlation = correlation_values.unstack().sort_values(ascending=False)\n",
    "    sorted_correlation = sorted_correlation[sorted_correlation != 1.0]\n",
    "\n",
    "    num_features = numberOfTopFeatures  # Number of top features to display\n",
    "    top_features = sorted_correlation.head(num_features)\n",
    "    print(\"Top\", num_features, \"features based on correlation:\")\n",
    "    print(top_features)\n",
    " \n",
    "    top_features = correlationMatrix.abs().nlargest(numberOfTopFeatures, targetColumnName)[targetColumnName].index\n",
    "    top_correlation_matrix = correlationMatrix.loc[top_features, top_features]\n",
    "\n",
    "    mplot.figure(figsize=(10, 8))\n",
    "    sns.heatmap(top_correlation_matrix, annot=True, cmap='coolwarm')\n",
    "    # Set the title of the plot\n",
    "    mplot.title('Correlation Heatmap ({})'.format(dataSetName))\n",
    "    \n",
    "    picturePath = \"Correlation_Matrix_DateSetName_{}.png\".format(dataSetName)\n",
    "    mplot.savefig(picturePath,  dpi=300, bbox_inches='tight')\n",
    "    mplot.show()\n",
    "    mplot.close()\n",
    "\n",
    "def makeConfusionMatrixPic(method, dataSet, classifierObj , X_test, y_test, predicted_Y):\n",
    "    display = ConfusionMatrixDisplay.from_estimator(classifierObj, X_test, y_test, display_labels=['Healthy', \"Heart Disease\"], cmap=mplot.cm.Blues) #, normalize=\"true\"\n",
    "    display.ax_.set_title(\"Confusion Matrix ({} Model)\".format(method))\n",
    "    display.ax_.set_xlabel('\\nPredicted Values')\n",
    "    display.ax_.set_ylabel('Actual Values ')\n",
    "\n",
    "\n",
    "    accuracyString =\"Accuracy {}: {:.2f}\".format(method, accuracy_score(y_test, predicted_Y)*100.0 ) \n",
    "    recallString =  'Recall {}: {:.2f}'.format(method, recall_score(y_test, predicted_Y) * 100.0)\n",
    "    precisionString = 'Precision {}: {:.2f}'.format(method, precision_score(y_test, predicted_Y) * 100.0) \n",
    "    dataSetString = \"Dataset: {}\".format(dataSet)\n",
    "\n",
    "    \n",
    "    if(classifierObj.n_features_in_ > 10):\n",
    "        featureListString = 'Total Features: {}'.format(classifierObj.n_features_in_) \n",
    "    else:\n",
    "        featureListString = 'Features: {}'.format(classifierObj.feature_names_in_) \n",
    "    \n",
    "    display.figure_.text(0.010, -0.05,  accuracyString, horizontalalignment='left', wrap=False )  \n",
    "    display.figure_.text(0.010, -0.09,  recallString, horizontalalignment='left', wrap=False )      \n",
    "    display.figure_.text(0.010, -0.13,  precisionString, horizontalalignment='left', wrap=False ) \n",
    "    display.figure_.text(0.010, -0.17,  dataSetString, horizontalalignment='left', wrap=False ) \n",
    "    display.figure_.text(0.010, -0.28,  featureListString, horizontalalignment='left', wrap=False ) \n",
    " \n",
    "    picturePath = \"{}Confusion_Matrix_{}_{}.png\".format(dataSetResultDirectory, method, dataSetName)\n",
    "    mplot.savefig(picturePath,  dpi=300, bbox_inches='tight')\n",
    "    #print(\"{} Confusion Matrix saved:: path: {}\".format(method, picturePath))\n",
    "    #os.startfile(picturePath)\n",
    "    mplot.show()\n",
    "    mplot.close()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_train_scaler shape: (56914, 50)   and dType: float64\n",
      "X_test_scaler shape: (14228, 50)   and dType: float64\n",
      "y_train shape: (56914,)   and dType: int64\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'y_train_scaler' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32me:\\Comsats\\python\\heartDiseasePrediction\\heartDisease_MLP.ipynb Cell 8\u001b[0m line \u001b[0;36m2\n\u001b[0;32m     <a href='vscode-notebook-cell:/e%3A/Comsats/python/heartDiseasePrediction/heartDisease_MLP.ipynb#X10sZmlsZQ%3D%3D?line=24'>25</a>\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m\"\u001b[39m\u001b[39mX_test_scaler shape: \u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m   and dType: \u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m\"\u001b[39m\u001b[39m.\u001b[39mformat(X_test_scaler\u001b[39m.\u001b[39mshape, X_test_scaler\u001b[39m.\u001b[39mdtype)) \n\u001b[0;32m     <a href='vscode-notebook-cell:/e%3A/Comsats/python/heartDiseasePrediction/heartDisease_MLP.ipynb#X10sZmlsZQ%3D%3D?line=27'>28</a>\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m\"\u001b[39m\u001b[39my_train shape: \u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m   and dType: \u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m\"\u001b[39m\u001b[39m.\u001b[39mformat(y_train\u001b[39m.\u001b[39mshape, y_train\u001b[39m.\u001b[39mdtype)) \n\u001b[1;32m---> <a href='vscode-notebook-cell:/e%3A/Comsats/python/heartDiseasePrediction/heartDisease_MLP.ipynb#X10sZmlsZQ%3D%3D?line=28'>29</a>\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m\"\u001b[39m\u001b[39my_train_scaler shape: \u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m   and dType: \u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m\"\u001b[39m\u001b[39m.\u001b[39mformat(y_train_scaler\u001b[39m.\u001b[39mshape, y_train_scaler\u001b[39m.\u001b[39mdtype)) \n\u001b[0;32m     <a href='vscode-notebook-cell:/e%3A/Comsats/python/heartDiseasePrediction/heartDisease_MLP.ipynb#X10sZmlsZQ%3D%3D?line=29'>30</a>\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m\"\u001b[39m\u001b[39my_test_scaler shape: \u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m   and dType: \u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m\"\u001b[39m\u001b[39m.\u001b[39mformat(y_test_scaler\u001b[39m.\u001b[39mshape, y_test_scaler\u001b[39m.\u001b[39mdtype)) \n\u001b[0;32m     <a href='vscode-notebook-cell:/e%3A/Comsats/python/heartDiseasePrediction/heartDisease_MLP.ipynb#X10sZmlsZQ%3D%3D?line=32'>33</a>\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m\"\u001b[39m\u001b[39mfeatures shape: \u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m   and dType: \u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m\"\u001b[39m\u001b[39m.\u001b[39mformat(features\u001b[39m.\u001b[39mshape, features\u001b[39m.\u001b[39mdtype))\n",
      "\u001b[1;31mNameError\u001b[0m: name 'y_train_scaler' is not defined"
     ]
    }
   ],
   "source": [
    "X_train_normalized = tf.keras.utils.normalize(X_train, axis=1)\n",
    "X_test_normalized = tf.keras.utils.normalize(X_test, axis=1)\n",
    "\n",
    "scaler = StandardScaler()\n",
    "X_train_scaler = scaler.fit_transform(X_train)\n",
    "X_test_scaler = scaler.fit_transform(X_test) \n",
    "# Our vectorized labels\n",
    "\n",
    "#X_train = np.asarray(X_train).astype(np.float32)  #.astype('float32').reshape((-1,1))\n",
    "#X_test = np.asarray(X_test).astype(np.float32)\n",
    "\n",
    "#y_train_scaler = np.asarray(y_train).astype('float32').reshape((-1,1))\n",
    "#y_test_scaler = np.asarray(y_test).astype('float32').reshape((-1,1))\n",
    "\n",
    " \n",
    "\n",
    "# Separate features and target variable\n",
    "features = X_train_scaler # data.iloc[:, :-1]\n",
    "target = np.asarray(y_train).astype('float64').reshape((-1,1))  #data['CoronaryHeartDisease']\n",
    " \n",
    " \n",
    "\n",
    "#print(\"X_train shape: {}   and dType: {}\".format(X_train.shape, X_train.dtype))\n",
    "print(\"X_train_scaler shape: {}   and dType: {}\".format(X_train_scaler.shape, X_train_scaler.dtype))\n",
    "print(\"X_test_scaler shape: {}   and dType: {}\".format(X_test_scaler.shape, X_test_scaler.dtype)) \n",
    "\n",
    "\n",
    "print(\"y_train shape: {}   and dType: {}\".format(y_train.shape, y_train.dtype)) \n",
    "#print(\"y_train_scaler shape: {}   and dType: {}\".format(y_train_scaler.shape, y_train_scaler.dtype)) \n",
    "#print(\"y_test_scaler shape: {}   and dType: {}\".format(y_test_scaler.shape, y_test_scaler.dtype)) \n",
    "\n",
    "\n",
    "print(\"features shape: {}   and dType: {}\".format(features.shape, features.dtype))\n",
    "print(\"target shape: {}   and dType: {}\".format(target.shape, target.dtype)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from tensorflow.keras import layers\n",
    "from tensorflow.keras.metrics import AUC, Precision, Recall, F1Score\n",
    "\n",
    "# Define custom metrics\n",
    "recall = Recall()\n",
    "precision = Precision()\n",
    "f1_score = F1Score()\n",
    "auc = AUC()\n",
    "\n",
    "\n",
    "# Adjust model architecture\n",
    "model = tf.keras.Sequential([\n",
    "    layers.Dense(256, activation='relu', input_shape=(features.shape[1],) ),\n",
    "    layers.Dropout(0.5),\n",
    "    layers.Dense(128, activation='relu'),\n",
    "    layers.Dropout(0.5),\n",
    "    layers.Dense(64, activation='relu'),\n",
    "    layers.Dropout(0.5),\n",
    "    layers.Dense(1, activation='sigmoid')\n",
    "])\n",
    "\n",
    "# Adjust optimizer and learning rate\n",
    "model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.001), loss='binary_crossentropy', metrics=['accuracy', recall, precision, f1_score, auc])\n",
    "\n",
    "# Train the model\n",
    "#history = model.fit(features, y_train, epochs=20, batch_size=64, validation_split=0.2)\n",
    "history = model.fit(features, target, epochs=20, batch_size=64)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from tensorflow.keras import layers\n",
    "from tensorflow.keras.metrics import AUC, Precision, Recall, F1Score\n",
    "\n",
    "# Define custom metrics\n",
    "recall = Recall()\n",
    "precision = Precision()\n",
    "f1_score = F1Score()\n",
    "auc = AUC()\n",
    "\n",
    "\n",
    "# Build the MLP model\n",
    "model = tf.keras.Sequential([\n",
    "    layers.Dense(128, activation='relu', input_shape=(features.shape[1],)),\n",
    "    layers.Dense(64, activation='relu'),\n",
    "    layers.Dense(64, activation='relu'),\n",
    "    layers.Dense(1, activation='sigmoid')\n",
    "])\n",
    "\n",
    "# Compile the model\n",
    "#model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy', 'recall', 'precision', 'f1_score', 'AUC' ])\n",
    "model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy', recall, precision, f1_score, auc])\n",
    "# Train the model\n",
    "history = model.fit(features, y_train, epochs=20, batch_size=32)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Evaluate the model using the evaluate method\n",
    "y_test_float64 = np.asarray(y_test).astype('float64').reshape((-1,1))  #data['CoronaryHeartDisease']\n",
    "\n",
    "loss, accuracy, recall_value, precision_value, f1_score_value, auc_value = model.evaluate(X_test_scaler, y_test_float64)\n",
    "\n",
    "# Print the results\n",
    "print('Test loss: {}'.format(loss))\n",
    "print('Test accuracy: {}'.format(accuracy))\n",
    "print('Test recall: {}'.format(recall_value))\n",
    "print('Test precision: {}'.format(precision_value))\n",
    "print('Test F1 score: {}'.format(f1_score_value))\n",
    "print('Test AUC: {}'.format(auc_value))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions = model.predict(X_test_scaler)\n",
    "binary_predictions = predictions > 0.5 if 1 else 0\n",
    " \n",
    "display = ConfusionMatrixDisplay.from_predictions(y_test, binary_predictions, display_labels=['Healthy', 'Heart Disease'], cmap=mplot.cm.Blues)\n",
    "\n",
    "\n",
    "#display = ConfusionMatrixDisplay.from_estimator(model, X_test_scaler, y_test, display_labels=['Healthy', \"Heart Disease\"], cmap=mplot.cm.Blues) #, normalize=\"true\"\n",
    "method = \"Multi-Layer Perceptron\"\n",
    "display.ax_.set_title(\"Results {} Model\".format(method))\n",
    "display.ax_.set_xlabel('\\nPredicted Values')\n",
    "display.ax_.set_ylabel('Actual Values ')\n",
    "\n",
    "accuracyString =\"Accuracy {}: {:.2f}\".format(method, accuracy*100.0 ) \n",
    "recallString =  'Recall {}: {:.2f}'.format(method, recall_value* 100.0)\n",
    "precisionString = 'Precision {}: {:.2f}'.format(method, precision_value * 100.0) \n",
    "dataSetString = \"F1 Score: {}\".format(f1_score_value)\n",
    "featureListString = \"AUC Score: {}\".format(auc_value)\n",
    "\n",
    "display.figure_.text(0.010, -0.05,  accuracyString, horizontalalignment='left', wrap=False )  \n",
    "display.figure_.text(0.010, -0.09,  recallString, horizontalalignment='left', wrap=False )      \n",
    "display.figure_.text(0.010, -0.13,  precisionString, horizontalalignment='left', wrap=False ) \n",
    "display.figure_.text(0.010, -0.17,  dataSetString, horizontalalignment='left', wrap=False ) \n",
    "display.figure_.text(0.010, -0.21,  featureListString, horizontalalignment='left', wrap=False ) \n",
    " \n",
    "picturePath = \"{}Model_Evaluation_{}_{}.png\".format(dataSetResultDirectory, method, dataSetName)\n",
    "mplot.savefig(picturePath,  dpi=300, bbox_inches='tight')\n",
    "print(\"{} Confusion Matrix saved:: path: {}\".format(method, picturePath))\n",
    "\n",
    "mplot.show()\n",
    "mplot.close()\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Plot accuracy\n",
    "plt.plot(history.history['accuracy'], label='Train accuracy')\n",
    "#plt.plot(history.history['val_accuracy'], label='Val accuracy')\n",
    "plt.title('Model Accuracy')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "# Add additional metrics and labels\n",
    "metrics = ['loss', 'recall', 'precision', 'f1_score', 'auc']\n",
    "for metric in metrics:\n",
    "    ax2 = plt.twinx()\n",
    "    plt.plot(history.history[metric], label=metric.capitalize(), ax=ax2)\n",
    "    ax2.set_ylabel(metric.capitalize(), labelpad=10)\n",
    "    ax2.tick_params(axis='y', labelcolor='blue')\n",
    "\n",
    "# Adjust layout\n",
    "plt.subplots_adjust(right=0.75)\n",
    "plt.legend(loc='upper left', bbox_to_anchor=(1, 1))\n",
    "\n",
    "# Save and clear plot\n",
    "picturePath = \"{}Confusion_Matrix_{}_{}.png\".format(dataSetResultDirectory, \"RNN Model\", dataSetName)\n",
    "plt.savefig(picturePath, dpi=300, bbox_inches='tight')\n",
    "plt.show()\n",
    "plt.close()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Plot accuracy\n",
    "plt.plot(history.history['accuracy'], label='Train accuracy')\n",
    "#plt.plot(history.history['val_accuracy'], label='Val accuracy')\n",
    "plt.title('Model Accuracy')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "# Add additional metrics and adjust label positions\n",
    "metrics = ['loss', 'recall', 'precision', 'f1_score', 'auc']\n",
    "for i, metric in enumerate(metrics):\n",
    "    plt.plot(history.history[metric], label=metric.capitalize())\n",
    "    y_offset = (i - 2) * 0.1  # Adjust based on desired spacing\n",
    "    plt.text(1, 1 - y_offset, metric.capitalize(), verticalalignment='top', ha='right', transform=plt.gca().transAxes)\n",
    "\n",
    "# Adjust layout and legend\n",
    "plt.subplots_adjust(right=0.75)\n",
    "plt.legend(loc='upper left', bbox_to_anchor=(1, 1))\n",
    "\n",
    "# Save and clear plot\n",
    "picturePath = \"{}Result_Matrix2_{}_{}.png\".format(dataSetResultDirectory, \"RNN Model\", dataSetName)\n",
    "plt.savefig(picturePath, dpi=300, bbox_inches='tight')\n",
    "plt.show()\n",
    "plt.close()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.plot(history.history['accuracy'])\n",
    "#plt.plot(history.history['val_accuracy'])\n",
    "plt.title('Model Accuracy')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend(['Train', 'Val'])\n",
    "\n",
    "picturePath = \"{}Confusion_Matrix_{}_{}.png\".format(dataSetResultDirectory, \"RNN Model\", dataSetName)\n",
    "plt.savefig(picturePath,  dpi=300, bbox_inches='tight')\n",
    "\n",
    "plt.show()\n",
    "plt.close()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime\n",
    "currentDateTime = datetime.datetime.now() \n",
    "currentDateTime = currentDateTime.strftime(\"%Y%m%d %H%M\") \n",
    "modelPath = \"{}model1_trained_{}_{}_{}percent.model\".format(dataSetResultDirectory, dataSetName, currentDateTime, accuracy)\n",
    "print(modelPath)\n",
    "model.save(modelPath)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.10.0"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}