diff --git a/models/Dementia Prediction Model/model.py b/models/Dementia Prediction Model/model.py new file mode 100644 index 00000000..d18b6a0b --- /dev/null +++ b/models/Dementia Prediction Model/model.py @@ -0,0 +1,31 @@ +import pandas as pd +from sklearn.model_selection import train_test_split +from sklearn.linear_model import LinearRegression +import joblib + +class CarPriceModel: + def __init__(self): + self.model = LinearRegression() + + def load_data(self, filepath): + data = pd.read_csv(filepath) + return data + + def preprocess_data(self, data): + # Assuming 'price' is the target column and the rest are features + X = data.drop('price', axis=1) # Replace 'price' with the actual target column name + y = data['price'] # Replace 'price' with the actual target column name + return train_test_split(X, y, test_size=0.2, random_state=42) + + def train(self, X_train, y_train): + self.model.fit(X_train, y_train) + + def save_model(self, model_path): + joblib.dump(self.model, model_path) + +if __name__ == "__main__": + car_model = CarPriceModel() + data = car_model.load_data('data/cleaned_car_data.csv') # Adjust the path to your dataset + X_train, X_test, y_train, y_test = car_model.preprocess_data(data) + car_model.train(X_train, y_train) + car_model.save_model('saved_models/car_price_model.pkl') \ No newline at end of file diff --git a/models/Dementia Prediction Model/modelevalution.py b/models/Dementia Prediction Model/modelevalution.py new file mode 100644 index 00000000..08e0b032 --- /dev/null +++ b/models/Dementia Prediction Model/modelevalution.py @@ -0,0 +1,21 @@ +import joblib +import pandas as pd +from sklearn.metrics import mean_squared_error, r2_score + +class ModelEvaluator: + def __init__(self, model_path): + self.model = joblib.load(model_path) + + def evaluate(self, X_test, y_test): + predictions = self.model.predict(X_test) + mse = mean_squared_error(y_test, predictions) + r2 = r2_score(y_test, predictions) + print("Mean Squared Error:", mse) + print("R^2 Score:", r2) + +if __name__ == "__main__": + data = pd.read_csv('data/cleaned_car_data.csv') # Load your test data + X_test = data.drop('price', axis=1) # Replace 'price' with the actual target column name + y_test = data['price'] # Replace 'price' with the actual target column name + evaluator = ModelEvaluator('saved_models/car_price_model.pkl') + evaluator.evaluate(X_test, y_test) \ No newline at end of file diff --git a/models/Dementia Prediction Model/notebook/dementia-prediction-using-different-ml-model.ipynb b/models/Dementia Prediction Model/notebook/dementia-prediction-using-different-ml-model.ipynb new file mode 100644 index 00000000..990a4df2 --- /dev/null +++ b/models/Dementia Prediction Model/notebook/dementia-prediction-using-different-ml-model.ipynb @@ -0,0 +1,3276 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 0.045864, + "end_time": "2021-02-21T05:24:40.532878", + "exception": false, + "start_time": "2021-02-21T05:24:40.487014", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "## Importing Libs" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19", + "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5", + "execution": { + "iopub.execute_input": "2021-02-21T05:24:40.625317Z", + "iopub.status.busy": "2021-02-21T05:24:40.624657Z", + "iopub.status.idle": "2021-02-21T05:24:41.846215Z", + "shell.execute_reply": "2021-02-21T05:24:41.846810Z" + }, + "papermill": { + "duration": 1.269347, + "end_time": "2021-02-21T05:24:41.847025", + "exception": false, + "start_time": "2021-02-21T05:24:40.577678", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "import pandas as pd # used to load, manipulate the data and for one-hot encoding\n", + "import numpy as np # data manipulation\n", + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.colors as colors\n", + "from sklearn.utils import resample # for downsample the dataset\n", + "from sklearn.model_selection import train_test_split # for splitting the dataset into train and test split\n", + "from sklearn.preprocessing import scale # scale and center the data\n", + "from sklearn.svm import SVC # will make a SVM for classification\n", + "from sklearn.model_selection import GridSearchCV # will do the cross validation\n", + "from sklearn.metrics import plot_confusion_matrix # will draw the confusion matrix\n", + "from sklearn.decomposition import PCA # to perform PCA to plot the data\n", + "from sklearn.impute import SimpleImputer\n", + "from sklearn.preprocessing import StandardScaler, MinMaxScaler\n", + "from sklearn.model_selection import cross_val_score\n", + "from sklearn.metrics import confusion_matrix, precision_score, accuracy_score, recall_score, roc_curve, auc\n", + "import seaborn as sns" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 0.044613, + "end_time": "2021-02-21T05:24:41.936713", + "exception": false, + "start_time": "2021-02-21T05:24:41.892100", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "## Load the data" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "_cell_guid": "79c7e3d0-c299-4dcb-8224-4455121ee9b0", + "_uuid": "d629ff2d2480ee46fbb7e2d37f6b5fab8052498a", + "execution": { + "iopub.execute_input": "2021-02-21T05:24:42.029211Z", + "iopub.status.busy": "2021-02-21T05:24:42.028542Z", + "iopub.status.idle": "2021-02-21T05:24:42.058687Z", + "shell.execute_reply": "2021-02-21T05:24:42.059215Z" + }, + "papermill": { + "duration": 0.077355, + "end_time": "2021-02-21T05:24:42.059378", + "exception": false, + "start_time": "2021-02-21T05:24:41.982023", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "data = pd.read_csv(\"../input/mri-and-alzheimers/oasis_longitudinal.csv\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 0.04491, + "end_time": "2021-02-21T05:24:42.149525", + "exception": false, + "start_time": "2021-02-21T05:24:42.104615", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "## Explore the data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:24:42.244342Z", + "iopub.status.busy": "2021-02-21T05:24:42.243655Z", + "iopub.status.idle": "2021-02-21T05:24:42.249012Z", + "shell.execute_reply": "2021-02-21T05:24:42.248425Z" + }, + "papermill": { + "duration": 0.053142, + "end_time": "2021-02-21T05:24:42.249140", + "exception": false, + "start_time": "2021-02-21T05:24:42.195998", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "pd.set_option('display.max_columns', None) # will show the all columns with pandas dataframe\n", + "pd.set_option('display.max_rows', None) # will show the all rows with pandas dataframe" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:24:42.359739Z", + "iopub.status.busy": "2021-02-21T05:24:42.359068Z", + "iopub.status.idle": "2021-02-21T05:24:42.371999Z", + "shell.execute_reply": "2021-02-21T05:24:42.372499Z" + }, + "papermill": { + "duration": 0.078228, + "end_time": "2021-02-21T05:24:42.372636", + "exception": false, + "start_time": "2021-02-21T05:24:42.294408", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "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", + "
Subject IDMRI IDGroupVisitMR DelayM/FHandAgeEDUCSESMMSECDReTIVnWBVASF
0OAS2_0001OAS2_0001_MR1Nondemented10MR87142.027.00.019870.6960.883
1OAS2_0001OAS2_0001_MR2Nondemented2457MR88142.030.00.020040.6810.876
2OAS2_0002OAS2_0002_MR1Demented10MR7512NaN23.00.516780.7361.046
3OAS2_0002OAS2_0002_MR2Demented2560MR7612NaN28.00.517380.7131.010
4OAS2_0002OAS2_0002_MR3Demented31895MR8012NaN22.00.516980.7011.034
\n", + "
" + ], + "text/plain": [ + " Subject ID MRI ID Group Visit MR Delay M/F Hand Age EDUC \\\n", + "0 OAS2_0001 OAS2_0001_MR1 Nondemented 1 0 M R 87 14 \n", + "1 OAS2_0001 OAS2_0001_MR2 Nondemented 2 457 M R 88 14 \n", + "2 OAS2_0002 OAS2_0002_MR1 Demented 1 0 M R 75 12 \n", + "3 OAS2_0002 OAS2_0002_MR2 Demented 2 560 M R 76 12 \n", + "4 OAS2_0002 OAS2_0002_MR3 Demented 3 1895 M R 80 12 \n", + "\n", + " SES MMSE CDR eTIV nWBV ASF \n", + "0 2.0 27.0 0.0 1987 0.696 0.883 \n", + "1 2.0 30.0 0.0 2004 0.681 0.876 \n", + "2 NaN 23.0 0.5 1678 0.736 1.046 \n", + "3 NaN 28.0 0.5 1738 0.713 1.010 \n", + "4 NaN 22.0 0.5 1698 0.701 1.034 " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.head()\n", + "# data.tail()\n", + "# data.size" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:24:42.468495Z", + "iopub.status.busy": "2021-02-21T05:24:42.467769Z", + "iopub.status.idle": "2021-02-21T05:24:42.473077Z", + "shell.execute_reply": "2021-02-21T05:24:42.472435Z" + }, + "papermill": { + "duration": 0.054333, + "end_time": "2021-02-21T05:24:42.473216", + "exception": false, + "start_time": "2021-02-21T05:24:42.418883", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(373, 15)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:24:42.571285Z", + "iopub.status.busy": "2021-02-21T05:24:42.570528Z", + "iopub.status.idle": "2021-02-21T05:24:42.586722Z", + "shell.execute_reply": "2021-02-21T05:24:42.585742Z" + }, + "papermill": { + "duration": 0.067194, + "end_time": "2021-02-21T05:24:42.586897", + "exception": false, + "start_time": "2021-02-21T05:24:42.519703", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 373 entries, 0 to 372\n", + "Data columns (total 15 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 Subject ID 373 non-null object \n", + " 1 MRI ID 373 non-null object \n", + " 2 Group 373 non-null object \n", + " 3 Visit 373 non-null int64 \n", + " 4 MR Delay 373 non-null int64 \n", + " 5 M/F 373 non-null object \n", + " 6 Hand 373 non-null object \n", + " 7 Age 373 non-null int64 \n", + " 8 EDUC 373 non-null int64 \n", + " 9 SES 354 non-null float64\n", + " 10 MMSE 371 non-null float64\n", + " 11 CDR 373 non-null float64\n", + " 12 eTIV 373 non-null int64 \n", + " 13 nWBV 373 non-null float64\n", + " 14 ASF 373 non-null float64\n", + "dtypes: float64(5), int64(5), object(5)\n", + "memory usage: 43.8+ KB\n" + ] + } + ], + "source": [ + "data.info()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 0.046597, + "end_time": "2021-02-21T05:24:42.681879", + "exception": false, + "start_time": "2021-02-21T05:24:42.635282", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "## Converting Categorical Data to Numerical Data" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 0.046699, + "end_time": "2021-02-21T05:24:42.776013", + "exception": false, + "start_time": "2021-02-21T05:24:42.729314", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "When **inplace = True** , the data is modified in place, which means it will return nothing and the dataframe is now updated. \n", + "When **inplace = False** , which is the *default*, then the operation is performed and it returns a copy of the object. You then need to save it to something." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 0.046777, + "end_time": "2021-02-21T05:24:42.872082", + "exception": false, + "start_time": "2021-02-21T05:24:42.825305", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "set axis=0 for rows or, just put axis='rows' to access the rows\n", + "\n", + "set axis=1 for columns or, just put axis='columns' to access the columns" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:24:42.982688Z", + "iopub.status.busy": "2021-02-21T05:24:42.981824Z", + "iopub.status.idle": "2021-02-21T05:24:42.985482Z", + "shell.execute_reply": "2021-02-21T05:24:42.986097Z" + }, + "papermill": { + "duration": 0.067422, + "end_time": "2021-02-21T05:24:42.986242", + "exception": false, + "start_time": "2021-02-21T05:24:42.918820", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 373 entries, 0 to 372\n", + "Data columns (total 15 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 Subject ID 373 non-null object \n", + " 1 MRI ID 373 non-null object \n", + " 2 Group 373 non-null int64 \n", + " 3 Visit 373 non-null int64 \n", + " 4 MR Delay 373 non-null int64 \n", + " 5 M/F 373 non-null int64 \n", + " 6 Hand 373 non-null object \n", + " 7 Age 373 non-null int64 \n", + " 8 EDUC 373 non-null int64 \n", + " 9 SES 354 non-null float64\n", + " 10 MMSE 371 non-null float64\n", + " 11 CDR 373 non-null float64\n", + " 12 eTIV 373 non-null int64 \n", + " 13 nWBV 373 non-null float64\n", + " 14 ASF 373 non-null float64\n", + "dtypes: float64(5), int64(7), object(3)\n", + "memory usage: 43.8+ KB\n" + ] + } + ], + "source": [ + "data['M/F'] = [1 if each == \"M\" else 0 for each in data['M/F']]\n", + "data['Group'] = [1 if each == \"Demented\" or each == \"Converted\" else 0 for each in data['Group']]\n", + "# data['Group'] = data['Group'].replace(['Converted'], ['Demented']) # Target variable\n", + "# data['Group'] = data['Group'].replace(['Demented', 'Nondemented'], [1,0]) # Target variable\n", + "data.info()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 0.046981, + "end_time": "2021-02-21T05:24:43.080526", + "exception": false, + "start_time": "2021-02-21T05:24:43.033545", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "Note: Based on the given data **CDR** is used to tell what the condition of the patient meaning, does the patient has any dementia or, not.\n", + "\n", + "CDR Value Meaning:\n", + "\n", + "* 0 ---> Normal\n", + "* 0.5 ---> Very Mild Dementia\n", + "* 1 ---> Mild Dementia\n", + "* 2 ---> Moderate Dementia\n", + "* 3 ---> Severe Dementia" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 0.047171, + "end_time": "2021-02-21T05:24:43.175738", + "exception": false, + "start_time": "2021-02-21T05:24:43.128567", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "## Correlation Between Attributes" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:24:43.274629Z", + "iopub.status.busy": "2021-02-21T05:24:43.273593Z", + "iopub.status.idle": "2021-02-21T05:24:43.287746Z", + "shell.execute_reply": "2021-02-21T05:24:43.287173Z" + }, + "papermill": { + "duration": 0.064432, + "end_time": "2021-02-21T05:24:43.287873", + "exception": false, + "start_time": "2021-02-21T05:24:43.223441", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Group 1.000000\n", + "CDR 0.778049\n", + "M/F 0.222146\n", + "SES 0.062463\n", + "ASF 0.032495\n", + "Age -0.005941\n", + "eTIV -0.042700\n", + "Visit -0.095507\n", + "MR Delay -0.120638\n", + "EDUC -0.193060\n", + "nWBV -0.311346\n", + "MMSE -0.524775\n", + "Name: Group, dtype: float64" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "correlation_matrix = data.corr()\n", + "data_corr = correlation_matrix['Group'].sort_values(ascending=False)\n", + "data_corr" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:24:43.387454Z", + "iopub.status.busy": "2021-02-21T05:24:43.386736Z", + "iopub.status.idle": "2021-02-21T05:24:45.327091Z", + "shell.execute_reply": "2021-02-21T05:24:45.326421Z" + }, + "papermill": { + "duration": 1.99135, + "end_time": "2021-02-21T05:24:45.327222", + "exception": false, + "start_time": "2021-02-21T05:24:43.335872", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[,\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", + " dtype=object)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from pandas.plotting import scatter_matrix\n", + "\n", + "attributes = [\"Group\", \"CDR\", \"M/F\", \"SES\", \"ASF\"]\n", + "\n", + "scatter_matrix(data[attributes], figsize=(15, 11), alpha=0.3)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:24:45.433703Z", + "iopub.status.busy": "2021-02-21T05:24:45.433017Z", + "iopub.status.idle": "2021-02-21T05:24:47.540106Z", + "shell.execute_reply": "2021-02-21T05:24:47.540628Z" + }, + "papermill": { + "duration": 2.163236, + "end_time": "2021-02-21T05:24:47.540769", + "exception": false, + "start_time": "2021-02-21T05:24:45.377533", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + " \n", + " " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import plotly.express as px\n", + "\n", + "fig = px.scatter(data, x='Group', y='SES', color='Group')\n", + "fig.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:24:47.650865Z", + "iopub.status.busy": "2021-02-21T05:24:47.649810Z", + "iopub.status.idle": "2021-02-21T05:24:47.721817Z", + "shell.execute_reply": "2021-02-21T05:24:47.722413Z" + }, + "papermill": { + "duration": 0.129299, + "end_time": "2021-02-21T05:24:47.722563", + "exception": false, + "start_time": "2021-02-21T05:24:47.593264", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import plotly.express as px\n", + "\n", + "fig = px.scatter(data, x='Group', y='Age', color='Group')\n", + "fig.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:24:47.832887Z", + "iopub.status.busy": "2021-02-21T05:24:47.831861Z", + "iopub.status.idle": "2021-02-21T05:24:47.904040Z", + "shell.execute_reply": "2021-02-21T05:24:47.904522Z" + }, + "papermill": { + "duration": 0.130189, + "end_time": "2021-02-21T05:24:47.904674", + "exception": false, + "start_time": "2021-02-21T05:24:47.774485", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import plotly.express as px\n", + "\n", + "fig = px.scatter(data, x='Group', y='ASF', color='Group')\n", + "fig.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 0.053096, + "end_time": "2021-02-21T05:24:48.011350", + "exception": false, + "start_time": "2021-02-21T05:24:47.958254", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "## Checking For Missig/Null Values" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:24:48.126795Z", + "iopub.status.busy": "2021-02-21T05:24:48.125994Z", + "iopub.status.idle": "2021-02-21T05:24:48.130278Z", + "shell.execute_reply": "2021-02-21T05:24:48.129746Z" + }, + "papermill": { + "duration": 0.065537, + "end_time": "2021-02-21T05:24:48.130397", + "exception": false, + "start_time": "2021-02-21T05:24:48.064860", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Subject ID 0\n", + "MRI ID 0\n", + "Group 0\n", + "Visit 0\n", + "MR Delay 0\n", + "M/F 0\n", + "Hand 0\n", + "Age 0\n", + "EDUC 0\n", + "SES 19\n", + "MMSE 2\n", + "CDR 0\n", + "eTIV 0\n", + "nWBV 0\n", + "ASF 0\n", + "dtype: int64" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.isnull().sum()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 0.053518, + "end_time": "2021-02-21T05:24:48.237952", + "exception": false, + "start_time": "2021-02-21T05:24:48.184434", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "### Taking median values for the missing values of MMSE" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:24:48.355837Z", + "iopub.status.busy": "2021-02-21T05:24:48.355128Z", + "iopub.status.idle": "2021-02-21T05:24:48.357901Z", + "shell.execute_reply": "2021-02-21T05:24:48.358483Z" + }, + "papermill": { + "duration": 0.066666, + "end_time": "2021-02-21T05:24:48.358626", + "exception": false, + "start_time": "2021-02-21T05:24:48.291960", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Subject ID 0\n", + "MRI ID 0\n", + "Group 0\n", + "Visit 0\n", + "MR Delay 0\n", + "M/F 0\n", + "Hand 0\n", + "Age 0\n", + "EDUC 0\n", + "SES 19\n", + "MMSE 0\n", + "CDR 0\n", + "eTIV 0\n", + "nWBV 0\n", + "ASF 0\n", + "dtype: int64" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "median = data['MMSE'].median()\n", + "data['MMSE'].fillna(median, inplace=True)\n", + "data.isnull().sum()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 0.054757, + "end_time": "2021-02-21T05:24:48.468036", + "exception": false, + "start_time": "2021-02-21T05:24:48.413279", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "### Taking median values for the missing values of SES" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:24:48.580903Z", + "iopub.status.busy": "2021-02-21T05:24:48.580254Z", + "iopub.status.idle": "2021-02-21T05:24:48.589172Z", + "shell.execute_reply": "2021-02-21T05:24:48.589795Z" + }, + "papermill": { + "duration": 0.067076, + "end_time": "2021-02-21T05:24:48.589954", + "exception": false, + "start_time": "2021-02-21T05:24:48.522878", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Subject ID 0\n", + "MRI ID 0\n", + "Group 0\n", + "Visit 0\n", + "MR Delay 0\n", + "M/F 0\n", + "Hand 0\n", + "Age 0\n", + "EDUC 0\n", + "SES 0\n", + "MMSE 0\n", + "CDR 0\n", + "eTIV 0\n", + "nWBV 0\n", + "ASF 0\n", + "dtype: int64" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "median = data['SES'].median()\n", + "data['SES'].fillna(median, inplace=True)\n", + "data.isnull().sum()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 0.054489, + "end_time": "2021-02-21T05:24:48.700670", + "exception": false, + "start_time": "2021-02-21T05:24:48.646181", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "## Train-Test Split" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 0.055984, + "end_time": "2021-02-21T05:24:48.812635", + "exception": false, + "start_time": "2021-02-21T05:24:48.756651", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "## Prepare the data for X and y where, \n", + "\n", + "1. X = The columns/features for **making the prediction**\n", + "2. y = The **predicted value**" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:24:48.926932Z", + "iopub.status.busy": "2021-02-21T05:24:48.926288Z", + "iopub.status.idle": "2021-02-21T05:24:48.933312Z", + "shell.execute_reply": "2021-02-21T05:24:48.932717Z" + }, + "papermill": { + "duration": 0.065077, + "end_time": "2021-02-21T05:24:48.933436", + "exception": false, + "start_time": "2021-02-21T05:24:48.868359", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "y = data['Group'].values\n", + "X = data[['M/F', 'Age', 'EDUC', 'SES', 'MMSE', 'eTIV', 'nWBV', 'ASF']]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 0.055011, + "end_time": "2021-02-21T05:24:49.044676", + "exception": false, + "start_time": "2021-02-21T05:24:48.989665", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "### Train-Test distribution Without Stratified Sampling" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:24:49.159712Z", + "iopub.status.busy": "2021-02-21T05:24:49.158704Z", + "iopub.status.idle": "2021-02-21T05:24:49.174698Z", + "shell.execute_reply": "2021-02-21T05:24:49.175197Z" + }, + "papermill": { + "duration": 0.075266, + "end_time": "2021-02-21T05:24:49.175352", + "exception": false, + "start_time": "2021-02-21T05:24:49.100086", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "In Training Split:\n", + "0 158\n", + "1 140\n", + "Name: 0, dtype: int64\n", + "\n", + "In Testing Split:\n", + "1 43\n", + "0 32\n", + "Name: 0, dtype: int64\n" + ] + } + ], + "source": [ + "# by default test_size= 0.25\n", + "X_trainval, X_test, y_trainval, y_test = train_test_split(X, y, test_size= 0.20, random_state=42)\n", + "\n", + "df_ytrain = pd.DataFrame(y_trainval)\n", + "df_ytest = pd.DataFrame(y_test)\n", + "\n", + "print('In Training Split:')\n", + "print(df_ytrain[0].value_counts())\n", + "\n", + "print('\\nIn Testing Split:')\n", + "print(df_ytest[0].value_counts())" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 0.055463, + "end_time": "2021-02-21T05:24:49.286592", + "exception": false, + "start_time": "2021-02-21T05:24:49.231129", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "### With Stratified Sampling" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:24:49.402123Z", + "iopub.status.busy": "2021-02-21T05:24:49.401433Z", + "iopub.status.idle": "2021-02-21T05:24:49.418062Z", + "shell.execute_reply": "2021-02-21T05:24:49.417434Z" + }, + "papermill": { + "duration": 0.075377, + "end_time": "2021-02-21T05:24:49.418177", + "exception": false, + "start_time": "2021-02-21T05:24:49.342800", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "In Training Split:\n", + "0 152\n", + "1 146\n", + "Name: 0, dtype: int64\n", + "\n", + "In Testing Split:\n", + "0 38\n", + "1 37\n", + "Name: 0, dtype: int64\n" + ] + } + ], + "source": [ + "# by default test_size= 0.25\n", + "X_trainval, X_test, y_trainval, y_test = train_test_split(X, y, test_size= 0.20, random_state=42, stratify=y)\n", + "\n", + "\n", + "df_ytrain = pd.DataFrame(y_trainval)\n", + "df_ytest = pd.DataFrame(y_test)\n", + "\n", + "print('In Training Split:')\n", + "print(df_ytrain[0].value_counts())\n", + "\n", + "print('\\nIn Testing Split:')\n", + "print(df_ytest[0].value_counts())" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 0.056065, + "end_time": "2021-02-21T05:24:49.530652", + "exception": false, + "start_time": "2021-02-21T05:24:49.474587", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "### Scale the dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:24:49.651835Z", + "iopub.status.busy": "2021-02-21T05:24:49.650741Z", + "iopub.status.idle": "2021-02-21T05:24:49.660072Z", + "shell.execute_reply": "2021-02-21T05:24:49.659484Z" + }, + "papermill": { + "duration": 0.073448, + "end_time": "2021-02-21T05:24:49.660201", + "exception": false, + "start_time": "2021-02-21T05:24:49.586753", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# here StandardScaler() means z = (x - u) / s\n", + "scaler = StandardScaler().fit(X_trainval)\n", + "#scaler = MinMaxScaler().fit(X_trainval)\n", + "X_trainval_scaled = scaler.transform(X_trainval)\n", + "X_test_scaled = scaler.transform(X_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:24:49.777554Z", + "iopub.status.busy": "2021-02-21T05:24:49.776541Z", + "iopub.status.idle": "2021-02-21T05:24:49.782686Z", + "shell.execute_reply": "2021-02-21T05:24:49.783257Z" + }, + "papermill": { + "duration": 0.066296, + "end_time": "2021-02-21T05:24:49.783400", + "exception": false, + "start_time": "2021-02-21T05:24:49.717104", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-0.87966444, 0.38449006, -0.87500081, ..., -0.30880564,\n", + " 0.16961408, 0.21548547],\n", + " [ 1.13679712, 1.04832574, -0.87500081, ..., 1.23805919,\n", + " -0.67676996, -1.21558429],\n", + " [-0.87966444, -0.9431813 , -1.22928103, ..., -1.08511327,\n", + " 0.4605586 , 1.14751551],\n", + " ...,\n", + " [-0.87966444, -0.01381135, 1.2506805 , ..., -0.92985174,\n", + " 0.01091708, 0.94202857],\n", + " [-0.87966444, -1.20871557, -0.87500081, ..., -0.00978344,\n", + " 0.5663566 , -0.10742258],\n", + " [-0.87966444, 0.11895579, 1.2506805 , ..., -1.38413547,\n", + " 0.4605586 , 1.56582821]])" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_trainval_scaled" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:24:49.907580Z", + "iopub.status.busy": "2021-02-21T05:24:49.906515Z", + "iopub.status.idle": "2021-02-21T05:24:49.938315Z", + "shell.execute_reply": "2021-02-21T05:24:49.937670Z" + }, + "papermill": { + "duration": 0.09737, + "end_time": "2021-02-21T05:24:49.938439", + "exception": false, + "start_time": "2021-02-21T05:24:49.841069", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "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", + "
M/FAgeEDUCSESMMSEeTIVnWBVASF
count298.000000298.000000298.000000298.000000298.000000298.000000298.000000298.000000
mean0.43624277.10402714.4697992.48993327.3557051483.7013420.7305871.198638
std0.4967527.5446542.8273721.1168593.689231174.1926490.0378710.136491
min0.00000060.0000006.0000001.0000004.0000001106.0000000.6440000.883000
25%0.00000071.25000012.0000002.00000027.0000001357.0000000.6992501.107250
50%0.00000077.00000014.0000002.00000029.0000001462.0000000.7310001.200500
75%1.00000082.00000016.0000003.00000030.0000001585.2500000.7570001.293000
max1.00000096.00000023.0000005.00000030.0000001987.0000000.8370001.587000
\n", + "
" + ], + "text/plain": [ + " M/F Age EDUC SES MMSE \\\n", + "count 298.000000 298.000000 298.000000 298.000000 298.000000 \n", + "mean 0.436242 77.104027 14.469799 2.489933 27.355705 \n", + "std 0.496752 7.544654 2.827372 1.116859 3.689231 \n", + "min 0.000000 60.000000 6.000000 1.000000 4.000000 \n", + "25% 0.000000 71.250000 12.000000 2.000000 27.000000 \n", + "50% 0.000000 77.000000 14.000000 2.000000 29.000000 \n", + "75% 1.000000 82.000000 16.000000 3.000000 30.000000 \n", + "max 1.000000 96.000000 23.000000 5.000000 30.000000 \n", + "\n", + " eTIV nWBV ASF \n", + "count 298.000000 298.000000 298.000000 \n", + "mean 1483.701342 0.730587 1.198638 \n", + "std 174.192649 0.037871 0.136491 \n", + "min 1106.000000 0.644000 0.883000 \n", + "25% 1357.000000 0.699250 1.107250 \n", + "50% 1462.000000 0.731000 1.200500 \n", + "75% 1585.250000 0.757000 1.293000 \n", + "max 1987.000000 0.837000 1.587000 " + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_trainval.describe()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 0.057412, + "end_time": "2021-02-21T05:24:50.054067", + "exception": false, + "start_time": "2021-02-21T05:24:49.996655", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "## Data Visualization" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:24:50.175069Z", + "iopub.status.busy": "2021-02-21T05:24:50.174376Z", + "iopub.status.idle": "2021-02-21T05:24:51.959428Z", + "shell.execute_reply": "2021-02-21T05:24:51.958796Z" + }, + "papermill": { + "duration": 1.847829, + "end_time": "2021-02-21T05:24:51.959546", + "exception": false, + "start_time": "2021-02-21T05:24:50.111717", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "X_trainval.hist(bins=30, figsize=(20,15))\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:24:52.090627Z", + "iopub.status.busy": "2021-02-21T05:24:52.089685Z", + "iopub.status.idle": "2021-02-21T05:24:52.168509Z", + "shell.execute_reply": "2021-02-21T05:24:52.167818Z" + }, + "papermill": { + "duration": 0.150146, + "end_time": "2021-02-21T05:24:52.168625", + "exception": false, + "start_time": "2021-02-21T05:24:52.018479", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import plotly.express as px\n", + "\n", + "x = ['M/F', 'Age', 'EDUC', 'SES', 'MMSE', 'eTIV', 'nWBV', 'ASF']\n", + "\n", + "fig = px.histogram(X_trainval, x='eTIV', nbins=50)\n", + "fig.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:24:52.349421Z", + "iopub.status.busy": "2021-02-21T05:24:52.321695Z", + "iopub.status.idle": "2021-02-21T05:24:52.362716Z", + "shell.execute_reply": "2021-02-21T05:24:52.362055Z" + }, + "papermill": { + "duration": 0.133606, + "end_time": "2021-02-21T05:24:52.362833", + "exception": false, + "start_time": "2021-02-21T05:24:52.229227", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import plotly.express as px\n", + "\n", + "x = ['M/F', 'Age', 'EDUC', 'SES', 'MMSE', 'eTIV', 'nWBV', 'ASF']\n", + "\n", + "fig = px.scatter(X_trainval, x='eTIV')\n", + "fig.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 0.060847, + "end_time": "2021-02-21T05:24:52.484599", + "exception": false, + "start_time": "2021-02-21T05:24:52.423752", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "# SVM" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:24:52.614683Z", + "iopub.status.busy": "2021-02-21T05:24:52.613922Z", + "iopub.status.idle": "2021-02-21T05:24:52.791187Z", + "shell.execute_reply": "2021-02-21T05:24:52.790597Z" + }, + "papermill": { + "duration": 0.245707, + "end_time": "2021-02-21T05:24:52.791313", + "exception": false, + "start_time": "2021-02-21T05:24:52.545606", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "clf_svm = SVC(random_state=42)\n", + "clf_svm.fit(X_trainval_scaled, y_trainval)\n", + "\n", + "# for test there are 94 cases\n", + "plot_confusion_matrix(clf_svm, \n", + " X_test_scaled, \n", + " y_test, \n", + " values_format='d', \n", + " display_labels=['Nondemented', 'Demented'])" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:24:52.925317Z", + "iopub.status.busy": "2021-02-21T05:24:52.924620Z", + "iopub.status.idle": "2021-02-21T05:24:52.935820Z", + "shell.execute_reply": "2021-02-21T05:24:52.935250Z" + }, + "papermill": { + "duration": 0.08155, + "end_time": "2021-02-21T05:24:52.935942", + "exception": false, + "start_time": "2021-02-21T05:24:52.854392", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train accuracy 0.8590604026845637\n", + "Test accuracy 0.7466666666666667\n", + "Test recall 0.5945945945945946\n", + "Test AUC 0.744665718349929\n" + ] + } + ], + "source": [ + "train_score = 0\n", + "test_score = 0\n", + "test_recall = 0\n", + "test_auc = 0\n", + "\n", + "train_score = clf_svm.score(X_trainval_scaled, y_trainval)\n", + "test_score = clf_svm.score(X_test_scaled, y_test)\n", + "y_predict = clf_svm.predict(X_test_scaled)\n", + "\n", + "test_recall = recall_score(y_test, y_predict)\n", + "fpr, tpr, thresholds = roc_curve(y_test, y_predict)\n", + "test_auc = auc(fpr, tpr)\n", + "\n", + "\n", + "print(\"Train accuracy \", train_score)\n", + "print(\"Test accuracy \", test_score)\n", + "print(\"Test recall\", test_recall)\n", + "print(\"Test AUC\", test_auc)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 0.062406, + "end_time": "2021-02-21T05:24:53.061149", + "exception": false, + "start_time": "2021-02-21T05:24:52.998743", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "### Optimize parameters(Finetuning) --> GridSearchCV() for SVM" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:24:53.196144Z", + "iopub.status.busy": "2021-02-21T05:24:53.195430Z", + "iopub.status.idle": "2021-02-21T05:25:04.937936Z", + "shell.execute_reply": "2021-02-21T05:25:04.938471Z" + }, + "papermill": { + "duration": 11.814617, + "end_time": "2021-02-21T05:25:04.938646", + "exception": false, + "start_time": "2021-02-21T05:24:53.124029", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'C': 6, 'gamma': 1, 'kernel': 'rbf'}\n" + ] + } + ], + "source": [ + "# Normally, C = 1 and gamma = 'scale' are default values\n", + "# C controls how wide the margin will be with respect to how many misclassification we are allowing\n", + "# C is increasing --> reduce the size of the margin and fewer misclassification and vice versa\n", + "param_grid = [\n", + " {'C': [0.5, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 30, 50, 80, 100],\n", + " 'gamma': ['scale', 0.5, 1, 0.1, 0.01, 0.001, 0.0001, 0.00001],\n", + " 'kernel': ['rbf', 'linear', 'poly', 'sigmoid']},\n", + "]\n", + "\n", + "optimal_params = GridSearchCV(SVC(),\n", + " param_grid,\n", + " cv=5, # we are taking 5-fold as in k-fold cross validation\n", + " scoring='accuracy', # try the other scoring if have time\n", + " verbose=0,\n", + " n_jobs=-1)\n", + "\n", + "optimal_params.fit(X_trainval_scaled, y_trainval)\n", + "print(optimal_params.best_params_)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:25:05.073634Z", + "iopub.status.busy": "2021-02-21T05:25:05.072673Z", + "iopub.status.idle": "2021-02-21T05:25:05.076294Z", + "shell.execute_reply": "2021-02-21T05:25:05.075675Z" + }, + "papermill": { + "duration": 0.074232, + "end_time": "2021-02-21T05:25:05.076406", + "exception": false, + "start_time": "2021-02-21T05:25:05.002174", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "C = optimal_params.best_params_['C']\n", + "gamma = optimal_params.best_params_['gamma']\n", + "kernel = optimal_params.best_params_['kernel']" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:25:05.207035Z", + "iopub.status.busy": "2021-02-21T05:25:05.206326Z", + "iopub.status.idle": "2021-02-21T05:25:05.382139Z", + "shell.execute_reply": "2021-02-21T05:25:05.382632Z" + }, + "papermill": { + "duration": 0.242652, + "end_time": "2021-02-21T05:25:05.382801", + "exception": false, + "start_time": "2021-02-21T05:25:05.140149", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "clf_svm = SVC(random_state=42, C=C, gamma=gamma, kernel=kernel)\n", + "clf_svm.fit(X_trainval_scaled, y_trainval)\n", + "\n", + "plot_confusion_matrix(clf_svm, \n", + " X_test_scaled, \n", + " y_test, \n", + " values_format='d', \n", + " display_labels=['Nondemented', 'Demented'])" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:25:05.517061Z", + "iopub.status.busy": "2021-02-21T05:25:05.516041Z", + "iopub.status.idle": "2021-02-21T05:25:05.535028Z", + "shell.execute_reply": "2021-02-21T05:25:05.534191Z" + }, + "papermill": { + "duration": 0.08746, + "end_time": "2021-02-21T05:25:05.535192", + "exception": false, + "start_time": "2021-02-21T05:25:05.447732", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train accuracy 1.0\n", + "Test accuracy 0.92\n", + "Test recall 0.918918918918919\n", + "Test AUC 0.9199857752489331\n" + ] + } + ], + "source": [ + "train_score = 0\n", + "test_score = 0\n", + "test_recall = 0\n", + "test_auc = 0\n", + "\n", + "train_score = clf_svm.score(X_trainval_scaled, y_trainval)\n", + "test_score = clf_svm.score(X_test_scaled, y_test)\n", + "y_predict = clf_svm.predict(X_test_scaled)\n", + "\n", + "test_recall = recall_score(y_test, y_predict)\n", + "svm_fpr, svm_tpr, thresholds = roc_curve(y_test, y_predict)\n", + "test_auc = auc(svm_fpr, svm_tpr)\n", + "\n", + "\n", + "print(\"Train accuracy \", train_score)\n", + "print(\"Test accuracy \", test_score)\n", + "print(\"Test recall\", test_recall)\n", + "print(\"Test AUC\", test_auc)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 0.064261, + "end_time": "2021-02-21T05:25:05.665444", + "exception": false, + "start_time": "2021-02-21T05:25:05.601183", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "# Random Forest" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:25:05.798235Z", + "iopub.status.busy": "2021-02-21T05:25:05.797535Z", + "iopub.status.idle": "2021-02-21T05:25:05.857124Z", + "shell.execute_reply": "2021-02-21T05:25:05.856511Z" + }, + "papermill": { + "duration": 0.126931, + "end_time": "2021-02-21T05:25:05.857258", + "exception": false, + "start_time": "2021-02-21T05:25:05.730327", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "from sklearn.ensemble import RandomForestClassifier" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:25:06.011800Z", + "iopub.status.busy": "2021-02-21T05:25:06.001387Z", + "iopub.status.idle": "2021-02-21T05:25:06.381618Z", + "shell.execute_reply": "2021-02-21T05:25:06.381041Z" + }, + "papermill": { + "duration": 0.459083, + "end_time": "2021-02-21T05:25:06.381735", + "exception": false, + "start_time": "2021-02-21T05:25:05.922652", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# n_estimators(M) --> the number of trees in the forest\n", + "# max_features(d) --> the number of features to consider when looking for the best split\n", + "# max_depth(m) --> the maximum depth of the tree.\n", + "\n", + "rfc = RandomForestClassifier(random_state=42)\n", + "rfc.fit(X_trainval_scaled, y_trainval)\n", + "\n", + "# for test there are 94 cases\n", + "plot_confusion_matrix(rfc, \n", + " X_test_scaled, \n", + " y_test, \n", + " values_format='d', \n", + " display_labels=['Nondemented', 'Demented'])" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:25:06.524845Z", + "iopub.status.busy": "2021-02-21T05:25:06.524139Z", + "iopub.status.idle": "2021-02-21T05:25:06.567152Z", + "shell.execute_reply": "2021-02-21T05:25:06.566168Z" + }, + "papermill": { + "duration": 0.119008, + "end_time": "2021-02-21T05:25:06.567316", + "exception": false, + "start_time": "2021-02-21T05:25:06.448308", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train accuracy 1.0\n", + "Test accuracy 0.8133333333333334\n", + "Test recall 0.7027027027027027\n", + "Test AUC 0.811877667140825\n" + ] + } + ], + "source": [ + "train_score = 0\n", + "test_score = 0\n", + "test_recall = 0\n", + "test_auc = 0\n", + "\n", + "train_score = rfc.score(X_trainval_scaled, y_trainval)\n", + "test_score = rfc.score(X_test_scaled, y_test)\n", + "y_predict = rfc.predict(X_test_scaled)\n", + "test_recall = recall_score(y_test, y_predict)\n", + "fpr, tpr, thresholds = roc_curve(y_test, y_predict)\n", + "test_auc = auc(fpr, tpr)\n", + "\n", + "print(\"Train accuracy \", train_score)\n", + "print(\"Test accuracy \", test_score)\n", + "print(\"Test recall\", test_recall)\n", + "print(\"Test AUC\", test_auc)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 0.066938, + "end_time": "2021-02-21T05:25:06.702778", + "exception": false, + "start_time": "2021-02-21T05:25:06.635840", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "### Optimize parameters(Finetuning) --> GridSearchCV()" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:25:06.846366Z", + "iopub.status.busy": "2021-02-21T05:25:06.845356Z", + "iopub.status.idle": "2021-02-21T05:25:06.848964Z", + "shell.execute_reply": "2021-02-21T05:25:06.848404Z" + }, + "papermill": { + "duration": 0.078921, + "end_time": "2021-02-21T05:25:06.849108", + "exception": false, + "start_time": "2021-02-21T05:25:06.770187", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Number of trees in random forest\n", + "n_estimators = [int(x) for x in np.linspace(start = 10, stop = 100, num = 10)]\n", + "\n", + "# Number of features to consider at every split\n", + "max_features = ['auto', 'sqrt', 'log2']\n", + "\n", + "# Maximum number of levels in tree\n", + "max_depth = range(1,10)\n", + "\n", + "# measure the quality of a split\n", + "criterion = ['gini']\n", + "\n", + "# Method of selecting samples for training each tree\n", + "bootstrap = [True, False]" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:25:06.987850Z", + "iopub.status.busy": "2021-02-21T05:25:06.987210Z", + "iopub.status.idle": "2021-02-21T05:25:06.992272Z", + "shell.execute_reply": "2021-02-21T05:25:06.991634Z" + }, + "papermill": { + "duration": 0.07594, + "end_time": "2021-02-21T05:25:06.992384", + "exception": false, + "start_time": "2021-02-21T05:25:06.916444", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Create the param grid\n", + "param_grid = {'n_estimators': n_estimators,\n", + " 'max_features': max_features,\n", + " 'max_depth': max_depth,\n", + " 'criterion': criterion,\n", + " 'bootstrap': bootstrap}" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:25:07.136382Z", + "iopub.status.busy": "2021-02-21T05:25:07.135353Z", + "iopub.status.idle": "2021-02-21T05:26:57.959858Z", + "shell.execute_reply": "2021-02-21T05:26:57.960433Z" + }, + "papermill": { + "duration": 110.901375, + "end_time": "2021-02-21T05:26:57.960599", + "exception": false, + "start_time": "2021-02-21T05:25:07.059224", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'bootstrap': False, 'criterion': 'gini', 'max_depth': 8, 'max_features': 'auto', 'n_estimators': 60}\n" + ] + } + ], + "source": [ + "optimal_params = GridSearchCV(RandomForestClassifier(),\n", + " param_grid,\n", + " cv=5, # we are taking 5-fold as in k-fold cross validation\n", + " scoring='accuracy', # try the other scoring if have time\n", + " verbose=0,\n", + " n_jobs=-1)\n", + "\n", + "optimal_params.fit(X_trainval_scaled, y_trainval)\n", + "print(optimal_params.best_params_)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:26:58.102512Z", + "iopub.status.busy": "2021-02-21T05:26:58.101661Z", + "iopub.status.idle": "2021-02-21T05:26:58.104540Z", + "shell.execute_reply": "2021-02-21T05:26:58.104022Z" + }, + "papermill": { + "duration": 0.076703, + "end_time": "2021-02-21T05:26:58.104654", + "exception": false, + "start_time": "2021-02-21T05:26:58.027951", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "bootstrap = optimal_params.best_params_['bootstrap']\n", + "criterion = optimal_params.best_params_['criterion']\n", + "max_depth = optimal_params.best_params_['max_depth']\n", + "max_features = optimal_params.best_params_['max_features']\n", + "n_estimators = optimal_params.best_params_['n_estimators']" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:26:58.264473Z", + "iopub.status.busy": "2021-02-21T05:26:58.263365Z", + "iopub.status.idle": "2021-02-21T05:26:58.573331Z", + "shell.execute_reply": "2021-02-21T05:26:58.572415Z" + }, + "papermill": { + "duration": 0.401085, + "end_time": "2021-02-21T05:26:58.573516", + "exception": false, + "start_time": "2021-02-21T05:26:58.172431", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "rfc = RandomForestClassifier(n_estimators=n_estimators, \n", + " max_features=max_features, \n", + " max_depth=max_depth, \n", + " criterion=criterion,\n", + " bootstrap=bootstrap,\n", + " random_state=42)\n", + "\n", + "rfc.fit(X_trainval_scaled, y_trainval)\n", + "\n", + "# for test there are 94 cases\n", + "plot_confusion_matrix(rfc, \n", + " X_test_scaled, \n", + " y_test, \n", + " values_format='d', \n", + " display_labels=['Nondemented', 'Demented'])" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:26:58.733907Z", + "iopub.status.busy": "2021-02-21T05:26:58.732790Z", + "iopub.status.idle": "2021-02-21T05:26:58.764470Z", + "shell.execute_reply": "2021-02-21T05:26:58.765236Z" + }, + "papermill": { + "duration": 0.111182, + "end_time": "2021-02-21T05:26:58.765445", + "exception": false, + "start_time": "2021-02-21T05:26:58.654263", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train accuracy 0.9966442953020134\n", + "Test accuracy 0.7866666666666666\n", + "Test recall 0.7027027027027027\n", + "Test AUC 0.7855618776671409\n" + ] + } + ], + "source": [ + "train_score = 0\n", + "test_score = 0\n", + "test_recall = 0\n", + "test_auc = 0\n", + "\n", + "train_score = rfc.score(X_trainval_scaled, y_trainval)\n", + "test_score = rfc.score(X_test_scaled, y_test)\n", + "y_predict = rfc.predict(X_test_scaled)\n", + "test_recall = recall_score(y_test, y_predict)\n", + "rfc_fpr, rfc_tpr, thresholds = roc_curve(y_test, y_predict)\n", + "test_auc = auc(rfc_fpr, rfc_tpr)\n", + "\n", + "print(\"Train accuracy \", train_score)\n", + "print(\"Test accuracy \", test_score)\n", + "print(\"Test recall\", test_recall)\n", + "print(\"Test AUC\", test_auc)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 0.071036, + "end_time": "2021-02-21T05:26:58.907460", + "exception": false, + "start_time": "2021-02-21T05:26:58.836424", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "# Logistic Regression" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:26:59.053932Z", + "iopub.status.busy": "2021-02-21T05:26:59.052923Z", + "iopub.status.idle": "2021-02-21T05:26:59.056562Z", + "shell.execute_reply": "2021-02-21T05:26:59.055881Z" + }, + "papermill": { + "duration": 0.078846, + "end_time": "2021-02-21T05:26:59.056676", + "exception": false, + "start_time": "2021-02-21T05:26:58.977830", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.tree import DecisionTreeClassifier\n", + "from sklearn.metrics import confusion_matrix, precision_score, accuracy_score, recall_score, roc_curve, auc" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:26:59.210264Z", + "iopub.status.busy": "2021-02-21T05:26:59.209530Z", + "iopub.status.idle": "2021-02-21T05:26:59.392907Z", + "shell.execute_reply": "2021-02-21T05:26:59.392347Z" + }, + "papermill": { + "duration": 0.263735, + "end_time": "2021-02-21T05:26:59.393060", + "exception": false, + "start_time": "2021-02-21T05:26:59.129325", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "log_reg_model = LogisticRegression().fit(X_trainval_scaled, y_trainval)\n", + "\n", + "# for test there are 94 cases\n", + "plot_confusion_matrix(log_reg_model, \n", + " X_test_scaled, \n", + " y_test, \n", + " values_format='d', \n", + " display_labels=['Nondemented', 'Demented'])" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:26:59.553251Z", + "iopub.status.busy": "2021-02-21T05:26:59.545050Z", + "iopub.status.idle": "2021-02-21T05:26:59.562200Z", + "shell.execute_reply": "2021-02-21T05:26:59.562678Z" + }, + "papermill": { + "duration": 0.098292, + "end_time": "2021-02-21T05:26:59.562830", + "exception": false, + "start_time": "2021-02-21T05:26:59.464538", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train accuracy 0.8221476510067114\n", + "Test accuracy 0.7466666666666667\n", + "Test recall 0.7027027027027027\n", + "Test AUC 0.7460881934566145\n" + ] + } + ], + "source": [ + "train_score = 0\n", + "test_score = 0\n", + "test_recall = 0\n", + "test_auc = 0\n", + "\n", + "log_reg_model = LogisticRegression().fit(X_trainval_scaled, y_trainval)\n", + "train_score = log_reg_model.score(X_trainval_scaled, y_trainval)\n", + "test_score = log_reg_model.score(X_test_scaled, y_test)\n", + "scores = log_reg_model.score(X_test_scaled, y_test)\n", + "y_predict = log_reg_model.predict(X_test_scaled)\n", + "test_recall = recall_score(y_test, y_predict)\n", + "fpr, tpr, thresholds = roc_curve(y_test, y_predict)\n", + "test_auc = auc(fpr, tpr)\n", + "\n", + "\n", + "print(\"Train accuracy \", train_score)\n", + "print(\"Test accuracy \", test_score)\n", + "print(\"Test recall\", test_recall)\n", + "print(\"Test AUC\", test_auc)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 0.072092, + "end_time": "2021-02-21T05:26:59.707748", + "exception": false, + "start_time": "2021-02-21T05:26:59.635656", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "### Optimize parameters(Finetuning) --> GridSearchCV()" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:26:59.859870Z", + "iopub.status.busy": "2021-02-21T05:26:59.859194Z", + "iopub.status.idle": "2021-02-21T05:27:00.087736Z", + "shell.execute_reply": "2021-02-21T05:27:00.088576Z" + }, + "papermill": { + "duration": 0.308978, + "end_time": "2021-02-21T05:27:00.088785", + "exception": false, + "start_time": "2021-02-21T05:26:59.779807", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'C': 2, 'penalty': 'l2'}\n" + ] + } + ], + "source": [ + "param_grid = {'penalty': ['l1','l2'], \n", + " 'C': [0.001,0.01,0.1,1, 2, 3, 5, 10,100,1000]}\n", + "\n", + "optimal_params = GridSearchCV(LogisticRegression(),\n", + " param_grid,\n", + " cv=5, # we are taking 5-fold as in k-fold cross validation\n", + " scoring='accuracy', # try the other scoring if have time\n", + " verbose=0,\n", + " n_jobs=-1)\n", + "\n", + "optimal_params.fit(X_trainval_scaled, y_trainval)\n", + "print(optimal_params.best_params_)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:27:00.240392Z", + "iopub.status.busy": "2021-02-21T05:27:00.239384Z", + "iopub.status.idle": "2021-02-21T05:27:00.243000Z", + "shell.execute_reply": "2021-02-21T05:27:00.242454Z" + }, + "papermill": { + "duration": 0.080874, + "end_time": "2021-02-21T05:27:00.243134", + "exception": false, + "start_time": "2021-02-21T05:27:00.162260", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# best_score = -10\n", + "# for c in range(1, 20): \n", + "# log_reg_model = LogisticRegression(C=c)\n", + "# scores = cross_val_score(log_reg_model, X_trainval_scaled, y_trainval, cv=5, scoring='accuracy')\n", + " \n", + "# mean_score = scores.mean()\n", + " \n", + "# if mean_score > best_score:\n", + "# best_score = mean_score\n", + "# best_c = c\n", + "# print(best_c)" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:27:00.393338Z", + "iopub.status.busy": "2021-02-21T05:27:00.392646Z", + "iopub.status.idle": "2021-02-21T05:27:00.394698Z", + "shell.execute_reply": "2021-02-21T05:27:00.395162Z" + }, + "papermill": { + "duration": 0.079368, + "end_time": "2021-02-21T05:27:00.395308", + "exception": false, + "start_time": "2021-02-21T05:27:00.315940", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "best_C = optimal_params.best_params_['C']\n", + "best_penalty = optimal_params.best_params_['penalty']" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:27:00.543733Z", + "iopub.status.busy": "2021-02-21T05:27:00.543072Z", + "iopub.status.idle": "2021-02-21T05:27:00.726618Z", + "shell.execute_reply": "2021-02-21T05:27:00.725951Z" + }, + "papermill": { + "duration": 0.258901, + "end_time": "2021-02-21T05:27:00.726760", + "exception": false, + "start_time": "2021-02-21T05:27:00.467859", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "log_reg_model = LogisticRegression(C=best_C, penalty=best_penalty).fit(X_trainval_scaled, y_trainval)\n", + "\n", + "# for test there are 94 cases\n", + "plot_confusion_matrix(log_reg_model, \n", + " X_test_scaled, \n", + " y_test, \n", + " values_format='d', \n", + " display_labels=['Nondemented', 'Demented'])" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:27:00.902586Z", + "iopub.status.busy": "2021-02-21T05:27:00.887719Z", + "iopub.status.idle": "2021-02-21T05:27:00.911752Z", + "shell.execute_reply": "2021-02-21T05:27:00.912556Z" + }, + "papermill": { + "duration": 0.108288, + "end_time": "2021-02-21T05:27:00.912736", + "exception": false, + "start_time": "2021-02-21T05:27:00.804448", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train accuracy with Logistec regression: 0.8288590604026845\n", + "Test accuracy with Logistec regression: 0.7466666666666667\n", + "Test recall with Logistec regression: 0.7027027027027027\n", + "Test AUC with Logistec regression: 0.7460881934566145\n" + ] + } + ], + "source": [ + "train_score = 0\n", + "test_score = 0\n", + "test_recall = 0\n", + "test_auc = 0\n", + "\n", + "best_log_reg_model = LogisticRegression(C=best_C, penalty=best_penalty).fit(X_trainval_scaled, y_trainval)\n", + "train_score = best_log_reg_model.score(X_trainval_scaled, y_trainval)\n", + "test_score = best_log_reg_model.score(X_test_scaled, y_test)\n", + "y_predict = best_log_reg_model.predict(X_test_scaled)\n", + "test_recall = recall_score(y_test, y_predict)\n", + "lgr_fpr, lgr_tpr, thresholds = roc_curve(y_test, y_predict)\n", + "test_auc = auc(lgr_fpr, lgr_tpr)\n", + "\n", + "print(\"Train accuracy with Logistec regression:\", train_score)\n", + "print(\"Test accuracy with Logistec regression:\", test_score)\n", + "print(\"Test recall with Logistec regression:\", test_recall)\n", + "print(\"Test AUC with Logistec regression:\", test_auc)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 0.074221, + "end_time": "2021-02-21T05:27:01.064257", + "exception": false, + "start_time": "2021-02-21T05:27:00.990036", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "# Decision Tree" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:27:01.218547Z", + "iopub.status.busy": "2021-02-21T05:27:01.217821Z", + "iopub.status.idle": "2021-02-21T05:27:01.391666Z", + "shell.execute_reply": "2021-02-21T05:27:01.391137Z" + }, + "papermill": { + "duration": 0.253607, + "end_time": "2021-02-21T05:27:01.391785", + "exception": false, + "start_time": "2021-02-21T05:27:01.138178", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "dt_model = DecisionTreeClassifier().fit(X_trainval_scaled, y_trainval)\n", + "\n", + "# for test there are 94 cases\n", + "plot_confusion_matrix(dt_model, \n", + " X_test_scaled, \n", + " y_test, \n", + " values_format='d', \n", + " display_labels=['Nondemented', 'Demented'])" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:27:01.552124Z", + "iopub.status.busy": "2021-02-21T05:27:01.551400Z", + "iopub.status.idle": "2021-02-21T05:27:01.561205Z", + "shell.execute_reply": "2021-02-21T05:27:01.560544Z" + }, + "papermill": { + "duration": 0.094559, + "end_time": "2021-02-21T05:27:01.561320", + "exception": false, + "start_time": "2021-02-21T05:27:01.466761", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train accuracy with DecisionTreeClassifier: 1.0\n", + "Test accuracy with DecisionTreeClassifier: 0.72\n", + "Test recall with DecisionTreeClassifier: 0.6756756756756757\n", + "Test AUC with DecisionTreeClassifier: 0.719416785206259\n" + ] + } + ], + "source": [ + "train_score = 0\n", + "test_score = 0\n", + "test_recall = 0\n", + "test_auc = 0\n", + "\n", + "dt_model = DecisionTreeClassifier().fit(X_trainval_scaled, y_trainval)\n", + "train_score = dt_model.score(X_trainval_scaled, y_trainval)\n", + "test_score = dt_model.score(X_test_scaled, y_test)\n", + "y_predict = dt_model.predict(X_test_scaled)\n", + "test_recall = recall_score(y_test, y_predict)\n", + "fpr, tpr, thresholds = roc_curve(y_test, y_predict)\n", + "test_auc = auc(fpr, tpr)\n", + "\n", + "print(\"Train accuracy with DecisionTreeClassifier:\", train_score)\n", + "print(\"Test accuracy with DecisionTreeClassifier:\", test_score)\n", + "print(\"Test recall with DecisionTreeClassifier:\", test_recall)\n", + "print(\"Test AUC with DecisionTreeClassifier:\", test_auc)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 0.075289, + "end_time": "2021-02-21T05:27:01.712002", + "exception": false, + "start_time": "2021-02-21T05:27:01.636713", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "### Optimize parameters(Finetuning) --> GridSearchCV()" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:27:01.872535Z", + "iopub.status.busy": "2021-02-21T05:27:01.871460Z", + "iopub.status.idle": "2021-02-21T05:27:01.957853Z", + "shell.execute_reply": "2021-02-21T05:27:01.957187Z" + }, + "papermill": { + "duration": 0.169737, + "end_time": "2021-02-21T05:27:01.957989", + "exception": false, + "start_time": "2021-02-21T05:27:01.788252", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'criterion': 'gini', 'max_depth': 2}\n" + ] + } + ], + "source": [ + "param_grid = {'criterion': ['gini'], \n", + " 'max_depth': range(1,10)}\n", + "\n", + "optimal_params = GridSearchCV(DecisionTreeClassifier(),\n", + " param_grid,\n", + " cv=5, # we are taking 5-fold as in k-fold cross validation\n", + " scoring='accuracy', # try the other scoring if have time\n", + " verbose=0,\n", + " n_jobs=-1)\n", + "\n", + "optimal_params.fit(X_trainval_scaled, y_trainval)\n", + "print(optimal_params.best_params_)" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:27:02.116441Z", + "iopub.status.busy": "2021-02-21T05:27:02.115645Z", + "iopub.status.idle": "2021-02-21T05:27:02.118675Z", + "shell.execute_reply": "2021-02-21T05:27:02.118177Z" + }, + "papermill": { + "duration": 0.085294, + "end_time": "2021-02-21T05:27:02.118786", + "exception": false, + "start_time": "2021-02-21T05:27:02.033492", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "criterion = optimal_params.best_params_['criterion']\n", + "max_depth = optimal_params.best_params_['max_depth']" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:27:02.276080Z", + "iopub.status.busy": "2021-02-21T05:27:02.275361Z", + "iopub.status.idle": "2021-02-21T05:27:02.278765Z", + "shell.execute_reply": "2021-02-21T05:27:02.278075Z" + }, + "papermill": { + "duration": 0.08369, + "end_time": "2021-02-21T05:27:02.278885", + "exception": false, + "start_time": "2021-02-21T05:27:02.195195", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# best_score = -1\n", + "# for d in range(1, 25): \n", + "# dt_model = DecisionTreeClassifier(max_depth = d)\n", + "# scores = cross_val_score(dt_model, X_trainval_scaled, y_trainval, cv=5, scoring='accuracy')\n", + " \n", + "# mean_score = scores.mean()\n", + " \n", + "# if mean_score > best_score:\n", + "# best_score = mean_score\n", + "# best_d = d\n", + "# print(best_d)" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:27:02.439628Z", + "iopub.status.busy": "2021-02-21T05:27:02.438933Z", + "iopub.status.idle": "2021-02-21T05:27:02.607174Z", + "shell.execute_reply": "2021-02-21T05:27:02.606465Z" + }, + "papermill": { + "duration": 0.251238, + "end_time": "2021-02-21T05:27:02.607295", + "exception": false, + "start_time": "2021-02-21T05:27:02.356057", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "dt_model = DecisionTreeClassifier(criterion=criterion, max_depth=max_depth).fit(X_trainval_scaled, y_trainval)\n", + "\n", + "# for test there are 94 cases\n", + "plot_confusion_matrix(dt_model, \n", + " X_test_scaled, \n", + " y_test, \n", + " values_format='d', \n", + " display_labels=['Nondemented', 'Demented'])" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:27:02.771744Z", + "iopub.status.busy": "2021-02-21T05:27:02.771062Z", + "iopub.status.idle": "2021-02-21T05:27:02.780168Z", + "shell.execute_reply": "2021-02-21T05:27:02.780646Z" + }, + "papermill": { + "duration": 0.096343, + "end_time": "2021-02-21T05:27:02.780797", + "exception": false, + "start_time": "2021-02-21T05:27:02.684454", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train accuracy with DecisionTreeClassifier: 0.7751677852348994\n", + "Test accuracy with DecisionTreeClassifier: 0.8\n", + "Test recall with DecisionTreeClassifier: 0.5945945945945946\n", + "Test AUC with DecisionTreeClassifier: 0.7972972972972974\n" + ] + } + ], + "source": [ + "train_score = 0\n", + "test_score = 0\n", + "test_recall = 0\n", + "test_auc = 0\n", + "\n", + "dt_model = DecisionTreeClassifier(criterion=criterion, max_depth=max_depth).fit(X_trainval_scaled, y_trainval)\n", + "train_score = dt_model.score(X_trainval_scaled, y_trainval)\n", + "test_score = dt_model.score(X_test_scaled, y_test)\n", + "y_predict = dt_model.predict(X_test_scaled)\n", + "test_recall = recall_score(y_test, y_predict)\n", + "dt_fpr, dt_tpr, thresholds = roc_curve(y_test, y_predict)\n", + "test_auc = auc(dt_fpr, dt_tpr)\n", + "\n", + "print(\"Train accuracy with DecisionTreeClassifier:\", train_score)\n", + "print(\"Test accuracy with DecisionTreeClassifier:\", test_score)\n", + "print(\"Test recall with DecisionTreeClassifier:\", test_recall)\n", + "print(\"Test AUC with DecisionTreeClassifier:\", test_auc)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "papermill": { + "duration": 0.079404, + "end_time": "2021-02-21T05:27:02.938142", + "exception": false, + "start_time": "2021-02-21T05:27:02.858738", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "## Plot ROC and compare AUC" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": { + "execution": { + "iopub.execute_input": "2021-02-21T05:27:03.110051Z", + "iopub.status.busy": "2021-02-21T05:27:03.109234Z", + "iopub.status.idle": "2021-02-21T05:27:03.296587Z", + "shell.execute_reply": "2021-02-21T05:27:03.295893Z" + }, + "papermill": { + "duration": 0.279336, + "end_time": "2021-02-21T05:27:03.296703", + "exception": false, + "start_time": "2021-02-21T05:27:03.017367", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(5, 5), dpi=100)\n", + "plt.plot(svm_fpr, svm_tpr, linestyle='-', label='SVM')\n", + "plt.plot(lgr_fpr, lgr_tpr, marker='.', label='Logistic')\n", + "plt.plot(rfc_fpr, rfc_tpr, linestyle=':', label='Random Forest')\n", + "plt.plot(dt_fpr, dt_tpr, linestyle='-.', label='Decision Tree')\n", + "\n", + "plt.xlabel('False Positive Rate')\n", + "plt.ylabel('True Positive Rate')\n", + "\n", + "plt.legend()\n", + "\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.11.7" + }, + "papermill": { + "duration": 147.570544, + "end_time": "2021-02-21T05:27:03.491568", + "environment_variables": {}, + "exception": null, + "input_path": "__notebook__.ipynb", + "output_path": "__notebook__.ipynb", + "parameters": {}, + "start_time": "2021-02-21T05:24:35.921024", + "version": "2.1.0" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/models/Dementia Prediction Model/predict.py b/models/Dementia Prediction Model/predict.py new file mode 100644 index 00000000..95721d7b --- /dev/null +++ b/models/Dementia Prediction Model/predict.py @@ -0,0 +1,19 @@ +import joblib +import pandas as pd + +class CarPricePredictor: + def __init__(self, model_path): + self.model = joblib.load(model_path) + + def predict(self, input_data): + return self.model.predict(input_data) + +if __name__ == "__main__": + predictor = CarPricePredictor('saved_models/car_price_model.pkl') + + # Example input data, replace with actual data + # Ensure the input data has the same feature columns as used in training + input_data = pd.DataFrame([[2015, 'Toyota', 'Corolla', 50000, 'Petrol']], + columns=['year', 'company', 'model', 'kms_driven', 'fuel_type']) # Adjust columns accordingly + predictions = predictor.predict(input_data) + print("Predicted Price: ₹", predictions[0]) \ No newline at end of file