diff --git a/Heart Attack Prediction/HeartAttackPrediction.ipynb b/Heart Attack Prediction/HeartAttackPrediction.ipynb index 668b9a99..3a3f6a14 100644 --- a/Heart Attack Prediction/HeartAttackPrediction.ipynb +++ b/Heart Attack Prediction/HeartAttackPrediction.ipynb @@ -2418,20 +2418,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Heart Attack Prediction | 3. Data Processing\n", - "\n", - "+ Conclusions from EDA\n", - "\n", - "+ Importing Packages\n", - "\n", - "+ Making features model ready" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# 1. Conclusions from EDA" + "# Conclusions from EDA" ] }, { @@ -2455,632 +2442,6 @@ " - People with no exercise induced angina, that is with exng = 0 have higher chance of heart attack." ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# 2. Importing Packages" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Packages imported...\n" - ] - } - ], - "source": [ - "# Scaling\n", - "from sklearn.preprocessing import RobustScaler\n", - "\n", - "# Train Test Split\n", - "from sklearn.model_selection import train_test_split\n", - "\n", - "# Models\n", - "import torch\n", - "import torch.nn as nn\n", - "from sklearn.svm import SVC\n", - "from sklearn.linear_model import LogisticRegression\n", - "from sklearn.ensemble import RandomForestClassifier\n", - "from sklearn.tree import DecisionTreeClassifier\n", - "from sklearn.ensemble import GradientBoostingClassifier\n", - "\n", - "# Metrics\n", - "from sklearn.metrics import accuracy_score, classification_report, roc_curve\n", - "\n", - "# Cross Validation\n", - "from sklearn.model_selection import cross_val_score\n", - "from sklearn.model_selection import GridSearchCV\n", - "\n", - "print('Packages imported...')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# 3. Making features model ready" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "+ ## Scaling and Encoding features" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The first 5 rows of X are\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
agetrtbpscholthalachholdpeaksex_1exng_1caa_1caa_2caa_3...cp_2cp_3fbs_1restecg_1restecg_2slp_1slp_2thall_1thall_2thall_3
00.5925930.75-0.110236-0.0923080.9375TrueFalseFalseFalseFalse...FalseTrueTrueFalseFalseFalseFalseTrueFalseFalse
1-1.3333330.000.1574801.0461541.6875TrueFalseFalseFalseFalse...TrueFalseFalseTrueFalseFalseFalseFalseTrueFalse
2-1.0370370.00-0.5669290.5846150.3750FalseFalseFalseFalseFalse...FalseFalseFalseFalseFalseFalseTrueFalseTrueFalse
30.074074-0.50-0.0629920.7692310.0000TrueFalseFalseFalseFalse...FalseFalseFalseTrueFalseFalseTrueFalseTrueFalse
40.148148-0.501.7952760.307692-0.1250FalseTrueFalseFalseFalse...FalseFalseFalseTrueFalseFalseTrueFalseTrueFalse
\n", - "

5 rows × 22 columns

\n", - "
" - ], - "text/plain": [ - " age trtbps chol thalachh oldpeak sex_1 exng_1 caa_1 caa_2 \\\n", - "0 0.592593 0.75 -0.110236 -0.092308 0.9375 True False False False \n", - "1 -1.333333 0.00 0.157480 1.046154 1.6875 True False False False \n", - "2 -1.037037 0.00 -0.566929 0.584615 0.3750 False False False False \n", - "3 0.074074 -0.50 -0.062992 0.769231 0.0000 True False False False \n", - "4 0.148148 -0.50 1.795276 0.307692 -0.1250 False True False False \n", - "\n", - " caa_3 ... cp_2 cp_3 fbs_1 restecg_1 restecg_2 slp_1 slp_2 \\\n", - "0 False ... False True True False False False False \n", - "1 False ... True False False True False False False \n", - "2 False ... False False False False False False True \n", - "3 False ... False False False True False False True \n", - "4 False ... False False False True False False True \n", - "\n", - " thall_1 thall_2 thall_3 \n", - "0 True False False \n", - "1 False True False \n", - "2 False True False \n", - "3 False True False \n", - "4 False True False \n", - "\n", - "[5 rows x 22 columns]" - ] - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# creating a copy of df\n", - "df1 = df\n", - "\n", - "# define the columns to be encoded and scaled\n", - "cat_cols = ['sex','exng','caa','cp','fbs','restecg','slp','thall']\n", - "con_cols = [\"age\",\"trtbps\",\"chol\",\"thalachh\",\"oldpeak\"]\n", - "\n", - "# encoding the categorical columns\n", - "df1 = pd.get_dummies(df1, columns = cat_cols, drop_first = True)\n", - "\n", - "# defining the features and target\n", - "X = df1.drop(['output'],axis=1)\n", - "y = df1[['output']]\n", - "\n", - "# instantiating the scaler\n", - "scaler = RobustScaler()\n", - "\n", - "# scaling the continuous featuree\n", - "X[con_cols] = scaler.fit_transform(X[con_cols])\n", - "print(\"The first 5 rows of X are\")\n", - "X.head()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "- ## Train and test split" - ] - }, - { - "cell_type": "code", - "execution_count": 50, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The shape of X_train is (242, 22)\n", - "The shape of X_test is (61, 22)\n", - "The shape of y_train is (242, 1)\n", - "The shape of y_test is (61, 1)\n" - ] - } - ], - "source": [ - "X_train, X_test, y_train, y_test = train_test_split(X,y, test_size = 0.2, random_state = 42)\n", - "print(\"The shape of X_train is \", X_train.shape)\n", - "print(\"The shape of X_test is \",X_test.shape)\n", - "print(\"The shape of y_train is \",y_train.shape)\n", - "print(\"The shape of y_test is \",y_test.shape)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "---" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "---" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Heart Attack Prediction | 4. Modeling\n", - "\n", - "+ Linear Classifiers\n", - " - Support Vector Machines\n", - " - Hyperparameter tuning of SVC\n", - " - Logistic Regression\n", - " - ROC Curve\n", - "\n", - "+ Tree Models\n", - " - Decision Tree\n", - " - Random Forest\n", - " - Gradient Boosting Classifier - without tuning" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# 1. Linear Classifiers" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Support Vector Machines" - ] - }, - { - "cell_type": "code", - "execution_count": 51, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The test accuracy score of SVM is 0.8688524590163934\n" - ] - } - ], - "source": [ - "# instantiating the object and fitting\n", - "clf = SVC(kernel='linear', C=1, random_state=42).fit(X_train,y_train)\n", - "\n", - "# predicting the values\n", - "y_pred = clf.predict(X_test)\n", - "\n", - "# printing the test accuracy\n", - "print(\"The test accuracy score of SVM is \", accuracy_score(y_test, y_pred))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Hyperparameter tuning of SVC" - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The best params are : {'C': 3, 'gamma': 0.1}\n", - "The best score is : 0.8384353741496599\n", - "The test accuracy score of SVM after hyper-parameter tuning is 0.9016393442622951\n" - ] - } - ], - "source": [ - "# instantiating the object\n", - "svm = SVC()\n", - "\n", - "# setting a grid - not so extensive\n", - "parameters = {\"C\":np.arange(1,10,1),'gamma':[0.00001,0.00005, 0.0001,0.0005,0.001,0.005,0.01,0.05,0.1,0.5,1,5]}\n", - "\n", - "# instantiating the GridSearchCV object\n", - "searcher = GridSearchCV(svm, parameters)\n", - "\n", - "# fitting the object\n", - "searcher.fit(X_train, y_train)\n", - "\n", - "# the scores\n", - "print(\"The best params are :\", searcher.best_params_)\n", - "print(\"The best score is :\", searcher.best_score_)\n", - "\n", - "# predicting the values\n", - "y_pred = searcher.predict(X_test)\n", - "\n", - "# printing the test accuracy\n", - "print(\"The test accuracy score of SVM after hyper-parameter tuning is \", accuracy_score(y_test, y_pred))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Logistic Regression" - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The test accuracy score of Logistric Regression is 0.9016393442622951\n" - ] - } - ], - "source": [ - "# instantiating the object\n", - "logreg = LogisticRegression()\n", - "\n", - "# fitting the object\n", - "logreg.fit(X_train, y_train)\n", - "\n", - "# calculating the probabilities\n", - "y_pred_proba = logreg.predict_proba(X_test)\n", - "\n", - "# finding the predicted valued\n", - "y_pred = np.argmax(y_pred_proba,axis=1)\n", - "\n", - "# printing the test accuracy\n", - "print(\"The test accuracy score of Logistric Regression is \", accuracy_score(y_test, y_pred))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## ROC Curve" - ] - }, - { - "cell_type": "code", - "execution_count": 46, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# calculating the probabilities\n", - "y_pred_prob = logreg.predict_proba(X_test)[:,1]\n", - "\n", - "# instantiating the roc_cruve\n", - "fpr,tpr,threshols=roc_curve(y_test,y_pred_prob)\n", - "\n", - "# plotting the curve\n", - "plt.plot([0,1],[0,1],\"k--\",'r+')\n", - "plt.plot(fpr,tpr,label='Logistic Regression')\n", - "plt.xlabel(\"False Positive Rate\")\n", - "plt.ylabel(\"True Positive Rate\")\n", - "plt.title(\"Logistric Regression ROC Curve\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# 2. Tree Models" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Decision Tree" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The test accuracy score of Decision Tree is 0.7868852459016393\n" - ] - } - ], - "source": [ - "# instantiating the object\n", - "dt = DecisionTreeClassifier(random_state = 42)\n", - "\n", - "# fitting the model\n", - "dt.fit(X_train, y_train)\n", - "\n", - "# calculating the predictions\n", - "y_pred = dt.predict(X_test)\n", - "\n", - "# printing the test accuracy\n", - "print(\"The test accuracy score of Decision Tree is \", accuracy_score(y_test, y_pred))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Random Forest" - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The test accuracy score of Random Forest is 0.7868852459016393\n" - ] - } - ], - "source": [ - "# instantiating the object\n", - "rf = RandomForestClassifier()\n", - "\n", - "# fitting the model\n", - "rf.fit(X_train, y_train)\n", - "\n", - "# calculating the predictions\n", - "y_pred = dt.predict(X_test)\n", - "\n", - "# printing the test accuracy\n", - "print(\"The test accuracy score of Random Forest is \", accuracy_score(y_test, y_pred))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Gradient Boosting Classifier - without tuning" - ] - }, - { - "cell_type": "code", - "execution_count": 49, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The test accuracy score of Gradient Boosting Classifier is 0.8688524590163934\n" - ] - } - ], - "source": [ - "# instantiate the classifier\n", - "gbt = GradientBoostingClassifier(n_estimators = 300,max_depth=1,subsample=0.8,max_features=0.2,random_state=42)\n", - "\n", - "# fitting the model\n", - "gbt.fit(X_train,y_train)\n", - "\n", - "# predicting values\n", - "y_pred = gbt.predict(X_test)\n", - "print(\"The test accuracy score of Gradient Boosting Classifier is \", accuracy_score(y_test, y_pred))" - ] - }, { "cell_type": "markdown", "metadata": {}, diff --git a/Heart Attack Prediction/Steps.md b/Heart Attack Prediction/Steps.md index ab203b7d..0f7aa9e4 100644 --- a/Heart Attack Prediction/Steps.md +++ b/Heart Attack Prediction/Steps.md @@ -28,23 +28,6 @@ - Some other relations that seemed intuitive - Pairplot according to target variable - one plot to rule them all -## 3. Data Processing - + Conclusions from EDA -+ Importing Packages - -+ Making features model ready - -## 4. Modeling - -+ Linear Classifiers - - Support Vector Machines - - Hyperparameter tuning of SVC - - Logistic Regression - - ROC Curve -+ Tree Models - - Decision Tree - - Random Forest - - Gradient Boosting Classifier - without tuning