
Part_3 Stroke_Prediction – Czy palenie przyczynia się do udaru mózgu
W tej części przeprowadzę klasyfikację za pomocą modeli
- Model regresji logistycznej
- Random Forest Classifier
- Naive Bayes Classifier
- Support Vector Machine Classifier
Z powodu zastosowania systemów optymalizacji sklearn.pipeline i GridSearchCV niektóre modele bardzo długo się liczą.
Dlatego zostały one zablokowane.
import time
start_time = time.time() ## pomiar czasu: start pomiaru czasu
print(time.ctime())
print('Pomiar czasu wykonania tego zadania')
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
df= pd.read_csv('c:/1/Stroke_Prediction_NUM.csv' , nrows = 29000)
# , nrows = 290
headers = ['ID', 'Gender', 'Hypertension', 'Heart_Disease', 'Ever_Married',
'Type_Of_Work', 'Residence', 'Avg_Glucose', 'BMI', 'Smoking_Status',
'Stroke', 'Age_years', 'Age_years_10', 'Gender_C', 'Ever_Married_C',
'Type_Of_Work_C', 'Residence_C', 'Smoking_Status_C', 'Age_years_10_C']
grupa_testowa= pd.read_csv('c:/1/Stroke_Prediction_NUM.csv', skiprows = 29000, header=None, names=headers)
# , nrows = 1000
print(df.shape)
print(grupa_testowa.shape)
df.head(5)
Wprowadzam zmienną syntetyczną¶
Wprowadzanie zmiennych syntetycznych może poprawić zdolności klasyfikacyjne modelu.
Tę zmienną zrobiłem, aby pokazać, że stosuję tę technikę.
df['C_Factor'] = (df['BMI']+(5*(df['Age_years_10_C']*df['Smoking_Status_C'])))
fig, ax = plt.subplots()
df['C_Factor'].plot.kde(ax=ax, legend=False, title='C_Factor')
Analiza poziomu zbilansowania zmiennej wynikowej¶
del df['Unnamed: 0']
df.Stroke.value_counts(dropna = False, normalize=True)
Zbiór zmiennych wynikowych wymaga zbilansowania. Do bilansowania zmiennych wynikowych stosuję trzy metody:
- class_weight (http://sigmaquality.pl/models/classification/logistic-regression/model-regresji-logistyczne-czesc-4-zastosowanie-class_weight/)
- oversampling (http://sigmaquality.pl/models/classification/logistic-regression/model-regresji-logistycznej-czesc-2-oversampling/)
- zmiana progu (http://sigmaquality.pl/models/classification/logistic-regression/model-regresji-logistycznej-czesc-3-zmiana-progu-w-modelu-regresji-logistycznej/)
Wszystkie trzy metody powinny dać podobne efekty przy klasyfikacji. Dzisiaj do zbilansowania zbioru zastosuję metodę oversampling. Oversampling odbywa się na zbiorze treningowym, więc najpierw trzeba podzielić zbiór na treningowy i testowy.
2. Podział na zbiór testowy i wynikowy¶
df2 = df[['C_Factor','Hypertension','Heart_Disease','Avg_Glucose','BMI','Stroke','Age_years','Gender_C','Ever_Married_C','Type_Of_Work_C','Residence_C','Smoking_Status_C','Age_years_10_C']]
y = df2['Stroke']
X = df2.drop('Stroke', axis=1)
from sklearn.model_selection import train_test_split
Xtrain, Xtest, ytrain, ytest = train_test_split(X,y, test_size=0.33, stratify = y, random_state = 148)
print ('Zbiór X treningowy: ',Xtrain.shape)
print ('Zbiór X testowy: ', Xtest.shape)
print ('Zbiór y treningowy: ', ytrain.shape)
print ('Zbiór y testowy: ', ytest.shape)
print("ytrain = 0: ", sum(ytrain == 0))
print("ytrain = 1: ", sum(ytrain == 1))
Proporcja = sum(ytrain == 0) / sum(ytrain == 1)
Proporcja = np.round(Proporcja, decimals=0)
Proporcja = Proporcja.astype(int)
print('Ilość 0 Stroke na 1 Stroke: ', Proporcja)
ytrain_OVSA = pd.concat([ytrain[ytrain==1]] * Proporcja, axis = 0)
ytrain_OVSA.count()
Powiękrzyliśmy ilość zmiennych wynikowych 1. Teraz mamy tę samą liczbę wierszy zmiennych wynikowych i zmiennych niezależnych. Teraz wprowadzamy nowe, dodatkowe zmienne 1 do zbioru treningowego.
Xtrain_OVSA = pd.concat([Xtrain.loc[ytrain==1, :]] * Proporcja, axis = 0)
ytrain_OVSA.count()
ytrain_OVSA = pd.concat([ytrain, ytrain_OVSA], axis = 0).reset_index(drop = True)
Xtrain_OVSA = pd.concat([Xtrain, Xtrain_OVSA], axis = 0).reset_index(drop = True)
print("ilość elementów w zbiorze Xtrain: ", Xtrain.BMI.count())
print("ilość elementów w zbiorze Xtrain_OVSA: ", Xtrain_OVSA.BMI.count())
print("ilość elementów w zbiorze ytrain: ", ytrain.count())
print("ilość elementów w zbiorze ytrain_OVSA: ", ytrain_OVSA.count())
Poziom zbilansowania zbioru wynikowego:
ytrain_OVSA.value_counts(dropna = False, normalize=True).plot(kind='pie')
Model regresji logistycznej¶
from sklearn import model_selection
from sklearn.pipeline import make_pipeline
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import GridSearchCV
Parameteres = {'C': np.power(10.0, np.arange(-3, 3))}
LR = LogisticRegression(warm_start = True)
LR_Grid = GridSearchCV(LR, param_grid = Parameteres, scoring = 'roc_auc', n_jobs = -1, cv=2)
LR_Grid.fit(Xtrain_OVSA, ytrain_OVSA)
y_pred_LRC = LR_Grid.predict(Xtest)
Ocena modelu:
from sklearn import metrics
from sklearn.metrics import classification_report, confusion_matrix
from sklearn.metrics import confusion_matrix, log_loss, auc, roc_curve, roc_auc_score, recall_score, precision_recall_curve
from sklearn.metrics import make_scorer, precision_score, fbeta_score, f1_score, classification_report
print("Recall Training data: ", np.round(recall_score(ytrain_OVSA, LR_Grid.predict(Xtrain_OVSA)), decimals=4))
print("Precision Training data: ", np.round(precision_score(ytrain_OVSA, LR_Grid.predict(Xtrain_OVSA)), decimals=4))
print("----------------------------------------------------------------------")
print("Recall Test data: ", np.round(recall_score(ytest, LR_Grid.predict(Xtest)), decimals=4))
print("Precision Test data: ", np.round(precision_score(ytest, LR_Grid.predict(Xtest)), decimals=4))
print("----------------------------------------------------------------------")
print("Confusion Matrix Test data")
print(confusion_matrix(ytest, LR_Grid.predict(Xtest)))
print("----------------------------------------------------------------------")
print(classification_report(ytest, LR_Grid.predict(Xtest)))
y_pred_proba = LR_Grid.predict_proba(Xtest)[::,1]
fpr, tpr, _ = metrics.roc_curve(ytest, y_pred_LRC)
auc = metrics.roc_auc_score(ytest, y_pred_LRC)
plt.plot(fpr, tpr, label='Logistic Regression (auc = plt.xlabel('False Positive Rate',color='grey', fontsize = 13)
plt.ylabel('True Positive Rate',color='grey', fontsize = 13)
plt.title('Receiver operating characteristic')
plt.legend(loc="lower right")
plt.legend(loc=4)
plt.plot([0, 1], [0, 1],'r--')
plt.show()
4. Random Forest Classifier – with pipeline GridSearchCV¶
Hiperparametry:
„n_estimators” – liczba drzew. Większa liczba drzew zwiększa wydajność i sprawia, że prognozy są bardziej stabilne, ale także spowalnia obliczenia.
„N_jobs” – ile procesorów jest dozwolone do użycia. Jeśli ma wartość 1, może używać tylko jednego procesora. Wartość „-1” oznacza, że nie ma limitu.
„Random_state” umożliwia replikację danych wyjściowych modelu. Model zawsze będzie dawał takie same wyniki, gdy ma określoną wartość random_state i jeśli otrzymał te same hiperparametry i te same dane treningowe.
„min_sample_leaf” minimalną liczbę listków wymaganych do podziału wewnętrznego węzła.
Model został zamrożony dla zaoszczędzenia czasu.</div>
from sklearn.pipeline import make_pipeline
from sklearn import preprocessing
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV
from sklearn.datasets import make_classification
import time
start_time = time.time() ## pomiar czasu: start pomiaru czasu
print(time.ctime())
print(’Pomiar czasu wykonania tego zadania’)
rfc=RandomForestClassifier(random_state=42)
param_grid = {
'n_estimators’: [200, 500],
'max_features’: [’auto’, 'sqrt’, 'log2′],
'max_depth’ : [4,5,6,7,8],
'criterion’ :[’gini’, 'entropy’]
}
CV_rfc = GridSearchCV(estimator=rfc, param_grid=param_grid, cv= 5)
CV_rfc.fit(Xtrain_OVSA, ytrain_OVSA)
y_pred_RFC = CV_rfc.predict(Xtest)
print(time.time() – start_time) ## koniec pomiaru czasuimport pprint
pparam=pprint.PrettyPrinter(indent=2)
print(CV_rfc.best_params_)print(„Recall Training data: „, np.round(recall_score(ytrain_OVSA, CV_rfc.predict(Xtrain_OVSA)), decimals=4))
print(„Precision Training data: „, np.round(precision_score(ytrain_OVSA, CV_rfc.predict(Xtrain_OVSA)), decimals=4))
print(„———————————————————————-„)
print(„Recall Test data: „, np.round(recall_score(ytest, CV_rfc.predict(Xtest)), decimals=4))
print(„Precision Test data: „, np.round(precision_score(ytest, CV_rfc.predict(Xtest)), decimals=4))
print(„———————————————————————-„)
print(„Confusion Matrix Test data”)
print(confusion_matrix(ytest, CV_rfc.predict(Xtest)))
print(„———————————————————————-„)
print(classification_report(ytest, CV_rfc.predict(Xtest)))
y_pred_proba = CV_rfc.predict_proba(Xtest)[::,1]
fpr, tpr, _ = metrics.roc_curve(ytest, y_pred_RFC)
auc = metrics.roc_auc_score(ytest, y_pred_RFC)
plt.plot(fpr, tpr, label=’Random Forest (auc =
plt.xlabel(’False Positive Rate’,color=’grey’, fontsize = 13)
plt.ylabel(’True Positive Rate’,color=’grey’, fontsize = 13)
plt.title(’Receiver operating characteristic’)
plt.legend(loc=”lower right”)
plt.legend(loc=4)
plt.plot([0, 1], [0, 1],’r–’)
plt.show()
Random Forest Classifier – simple version¶
Hiperparametry dobrane ręcznie
from sklearn.ensemble import RandomForestClassifier
forestVC = RandomForestClassifier (random_state = 1,
n_estimators = 350,
max_depth = 2,
min_samples_split = 2, min_samples_leaf = 3)
RFC_S = forestVC.fit(Xtrain_OVSA, ytrain_OVSA)
y_pred_RFC = RFC_S.predict(Xtest)
Ocena modelu:
print("Recall Training data: ", np.round(recall_score(ytrain_OVSA, RFC_S.predict(Xtrain_OVSA)), decimals=4))
print("Precision Training data: ", np.round(precision_score(ytrain_OVSA, RFC_S.predict(Xtrain_OVSA)), decimals=4))
print("----------------------------------------------------------------------")
print("Recall Test data: ", np.round(recall_score(ytest, RFC_S.predict(Xtest)), decimals=4))
print("Precision Test data: ", np.round(precision_score(ytest, RFC_S.predict(Xtest)), decimals=4))
print("----------------------------------------------------------------------")
print("Confusion Matrix Test data")
print(confusion_matrix(ytest, RFC_S.predict(Xtest)))
print("----------------------------------------------------------------------")
print(classification_report(ytest, RFC_S.predict(Xtest)))
y_pred_proba = RFC_S.predict_proba(Xtest)[::,1]
fpr, tpr, _ = metrics.roc_curve(ytest, y_pred_RFC)
auc = metrics.roc_auc_score(ytest, y_pred_RFC)
plt.plot(fpr, tpr, label='Random Forest (auc = plt.xlabel('False Positive Rate',color='grey', fontsize = 13)
plt.ylabel('True Positive Rate',color='grey', fontsize = 13)
plt.title('Receiver operating characteristic')
plt.legend(loc="lower right")
plt.legend(loc=4)
plt.plot([0, 1], [0, 1],'r--')
plt.show()
Naive Bayes Classifier¶
from sklearn.naive_bayes import GaussianNB
NBC = GaussianNB()
NBC.fit(Xtrain_OVSA, ytrain_OVSA)
GaussianNB(priors=None, var_smoothing=1e-09)
y_pred_NBC = NBC.predict(Xtest)
Ocena modelu:
print("Recall Training data: ", np.round(recall_score(ytrain_OVSA, NBC.predict(Xtrain_OVSA)), decimals=4))
print("Precision Training data: ", np.round(precision_score(ytrain_OVSA, NBC.predict(Xtrain_OVSA)), decimals=4))
print("----------------------------------------------------------------------")
print("Recall Test data: ", np.round(recall_score(ytest, NBC.predict(Xtest)), decimals=4))
print("Precision Test data: ", np.round(precision_score(ytest, NBC.predict(Xtest)), decimals=4))
print("----------------------------------------------------------------------")
print("Confusion Matrix Test data")
print(confusion_matrix(ytest, NBC.predict(Xtest)))
print("----------------------------------------------------------------------")
print(classification_report(ytest, NBC.predict(Xtest)))
y_pred_proba = NBC.predict_proba(Xtest)[::,1]
fpr, tpr, _ = metrics.roc_curve(ytest, y_pred_NBC)
auc = metrics.roc_auc_score(ytest, y_pred_NBC)
plt.plot(fpr, tpr, label='Naive Bayes Classifier (auc = plt.xlabel('False Positive Rate',color='grey', fontsize = 13)
plt.ylabel('True Positive Rate',color='grey', fontsize = 13)
plt.title('Receiver operating characteristic')
plt.legend(loc="lower right")
plt.legend(loc=4)
plt.plot([0, 1], [0, 1],'r--')
plt.show()
Support Vector Machine Classifier¶
Model został zamrożony dla zaoszczędzenia czasu.
</div>
from sklearn.pipeline import Pipeline
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.model_selection import train_test_split
from sklearn import preprocessing
from sklearn.model_selection import GridSearchCV
from sklearn.metrics import mean_squared_error, r2_score
from sklearn.externals import joblib
start_time = time.time() ## pomiar czasu: start pomiaru czasu
print(time.ctime())
print(’Pomiar czasu wykonania tego zadania’)
ew = [(’scaler’, StandardScaler()), (’SVM’, SVC())]
pipeline = Pipeline(ew)parameteres = {’SVM__C’:[0.001,0.1,10,100,10e5], 'SVM__gamma’:[0.1,0.01]}
SVM_12 = GridSearchCV(pipeline, param_grid=parameteres, cv=5)
SVM_12.fit(Xtrain_OVSA, ytrain_OVSA)
y_pred_SVM12 = SVM_12.predict(Xtest)
print(time.time() – start_time) ## koniec pomiaru czasuimport pprint
pparam=pprint.PrettyPrinter(indent=2)
print(SVM_12.best_params_)print(„Recall Training data: „, np.round(recall_score(ytrain_OVSA, SVM_12.predict(Xtrain_OVSA)), decimals=4))
print(„Precision Training data: „, np.round(precision_score(ytrain_OVSA, SVM_12.predict(Xtrain_OVSA)), decimals=4))
print(„———————————————————————-„)
print(„Recall Test data: „, np.round(recall_score(ytest, SVM_12.predict(Xtest)), decimals=4))
print(„Precision Test data: „, np.round(precision_score(ytest, SVM_12.predict(Xtest)), decimals=4))
print(„———————————————————————-„)
print(„Confusion Matrix Test data”)
print(confusion_matrix(ytest, SVM_12.predict(Xtest)))
print(„———————————————————————-„)
print(classification_report(ytest, SVM_12.predict(Xtest)))
Support Vector Machine Classifier – simple version¶
import time
start_time = time.time() ## pomiar czasu: start pomiaru czasu
print(time.ctime())
print('Pomiar czasu wykonania tego zadania')
from sklearn import svm
SVM_S = svm.SVC(kernel='linear')
SVM_S.fit(Xtrain_OVSA, ytrain_OVSA)
y_pred_SVM = SVM_S.predict(Xtest)
print(time.time() - start_time) ## koniec pomiaru czasu
print("Recall Training data: ", np.round(recall_score(ytrain_OVSA, SVM_S.predict(Xtrain_OVSA)), decimals=4))
print("Precision Training data: ", np.round(precision_score(ytrain_OVSA, SVM_S.predict(Xtrain_OVSA)), decimals=4))
print("----------------------------------------------------------------------")
print("Recall Test data: ", np.round(recall_score(ytest, SVM_S.predict(Xtest)), decimals=4))
print("Precision Test data: ", np.round(precision_score(ytest, SVM_S.predict(Xtest)), decimals=4))
print("----------------------------------------------------------------------")
print("Confusion Matrix Test data")
print(confusion_matrix(ytest, SVM_S.predict(Xtest)))
print("----------------------------------------------------------------------")
print(classification_report(ytest, SVM_S.predict(Xtest)))
Podsumowanie modeli klasyfikacji¶
- Modele osiagnęły wynik ROC od 73 do 89.
- Modele nie są przeuczone, ponieważ wartość Recall dla zbiorów testowych i treningowych miały podobne wartości.
- Istnieje bardzo duża różnica w mierniku 'precision’ pomiedzy zmiennymi testowymi i treningowymi.
W modelach w zestawach testowych istnieje bardzo niski poziom 'precision’. Wynika to z ogromnego niezbilansowania zbiorów wynikowych. Tylko jeden pacjent na 52 doznaje udaru.
'Recall’ jest miarą kompletności wyników.
'Precision’ jest miarą 'zaśmiecenia wyników’.
PRECISION definiuje się jako liczbę zjawisk: 'stroke’ pobranych przez wyszukiwanie podzieloną przez całkowitą liczbę pacjentów pobranych przez to wyszukiwanie.
Aby udowodnić to, że powodem niskiego poziomu 'precision’ jest niezbilansowanie testowego zbioru wynikowego przeprowadziłem krótkie doświadczenie. Wykonałem oversampling w zbiorze testowym, a następnie wstawiłem zbilansowany zbiór testowy do najprostszego z modeli: Naive Bayes Classifier
Oversampling dla zbioru testowego¶
print("ytest = 0: ", sum(ytest == 0))
print("ytest = 1: ", sum(ytest == 1))
ProporcjaT = sum(ytrain == 0) / sum(ytrain == 1)
ProporcjaT = np.round(ProporcjaT, decimals=0)
ProporcjaT = Proporcja.astype(int)
print('Ilość 0 Stroke na 1 Stroke: ', ProporcjaT)
ytest_OVSA = pd.concat([ytest[ytest==1]] * ProporcjaT, axis = 0)
ytest_OVSA.count()
Xtest_OVSA = pd.concat([Xtest.loc[ytest==1, :]] * ProporcjaT, axis = 0)
ytest_OVSA.count()
ytest_OVSA = pd.concat([ytest, ytest_OVSA], axis = 0).reset_index(drop = True)
Xtest_OVSA = pd.concat([Xtest, Xtest_OVSA], axis = 0).reset_index(drop = True)
print("ilość elementów w zbiorze Xtrain: ", Xtest.BMI.count())
print("ilość elementów w zbiorze Xtrain_OVSA: ", Xtest_OVSA.BMI.count())
print("ilość elementów w zbiorze ytrain: ", ytest.count())
print("ilość elementów w zbiorze ytrain_OVSA: ", ytest_OVSA.count())
Podstawienie Xtrain_OVSA do modelu Naive Bayes Classifier¶
from sklearn.naive_bayes import GaussianNB
gnb = GaussianNB()
gnb.fit(Xtrain_OVSA, ytrain_OVSA)
GaussianNB(priors=None, var_smoothing=1e-09)
y_pred = gnb.predict(Xtest_OVSA)
print("Recall Training data: ", np.round(recall_score(ytrain_OVSA, gnb.predict(Xtrain_OVSA)), decimals=4))
print("Precision Training data: ", np.round(precision_score(ytrain_OVSA, gnb.predict(Xtrain_OVSA)), decimals=4))
print("----------------------------------------------------------------------")
print("Recall Test data: ", np.round(recall_score(ytest_OVSA, gnb.predict(Xtest_OVSA)), decimals=4))
print("Precision Test data: ", np.round(precision_score(ytest_OVSA, gnb.predict(Xtest_OVSA)), decimals=4))
print("----------------------------------------------------------------------")
print(time.time() - start_time) ## koniec pomiaru czasu
Jak widać, model posiada podobne właściwości dla danych testowych i treningowych.
Eksperyment potwiedził, że powodem niskiego stanu 'precision’ było wysokie niezbilansowanie zbioru testowego.
Wykorzystanie modeli w praktyce¶
grupa_testowa.head(3)
Wprowadzam zmienną syntetyczną.
grupa_testowa['C_Factor'] = (grupa_testowa['BMI']+(5*(grupa_testowa['Age_years_10_C']*grupa_testowa['Smoking_Status_C'])))
grupa_testowa.head(3)
grupa_testowa.reset_index()
grupa_testowa.index = np.arange(1, 64)
grupa_testowa.index
Podział na zbiór zmiennych wynikowych i zmiennych niezależnych¶
grupa_testowa.describe(include=[np.number]).columns
grupa_testowa.head(3)
grupa_testowa2 = grupa_testowa[['C_Factor','Hypertension','Heart_Disease','Avg_Glucose','BMI','Stroke','Age_years','Gender_C','Ever_Married_C','Type_Of_Work_C','Residence_C','Smoking_Status_C','Age_years_10_C']]
y_gt = grupa_testowa2['Stroke']
X_gt = grupa_testowa2.drop('Stroke', axis=1)
grupa_testowa2.head(3)
df2.head(3)
X_gt.head(3)
RFC_S¶
y_pred_RFC_S = RFC_S.predict(X_gt)
y_pred_RFC_S
RFC_S_model=pd.Series(y_pred_RFC_S).reset_index()
RFC_S_model.columns =['index','RFC_S_model']
RFC_S_model.index = np.arange(1, 64)
#grupa_testowa.index
LR_Grid¶
y_pred_LR_Grid = LR_Grid.predict(X_gt)
y_pred_LR_Grid
LR_Grid_model=pd.Series(y_pred_LR_Grid).reset_index()
LR_Grid_model.columns =['index','LR_Grid_model']
LR_Grid_model.index = np.arange(1, 64)
#grupa_testowa.index
Naive Bayes Classifier¶
y_pred_NBC = NBC.predict(X_gt)
y_pred_NBC
NBC_model=pd.Series(y_pred_NBC).reset_index()
NBC_model.columns =['index','NBC_model']
NBC_model.index = np.arange(1, 64)
#grupa_testowa.index
Support Vector Machine Classifier – simple version¶
y_pred_SVM = SVM_S.predict(X_gt)
y_pred_SVM
SVM_model=pd.Series(y_pred_SVM).reset_index()
SVM_model.columns =['index','SVM_model']
SVM_model.index = np.arange(1, 64)
#grupa_testowa.index
Komitet modeli¶
Lekarz ma do wyboru cztery modele machine learning.
grupa_testow = pd.concat([grupa_testowa,LR_Grid_model,RFC_S_model,NBC_model,SVM_model],axis=1, sort=False)
grupa_testow[['Stroke','LR_Grid_model','RFC_S_model','NBC_model','SVM_model']].head(6)
Ocena końcowa modeli na podstawie grupy 62 nowych pacjentów¶
print("----------------------------------------------------------------------")
print("Recall LR_Grid_model: ", np.round(recall_score(y_gt, LR_Grid.predict(X_gt)), decimals=4))
print("Precision LR_Grid_model: ", np.round(precision_score(y_gt, LR_Grid.predict(X_gt)), decimals=4))
print("----------------------------------------------------------------------")
print("Recall RFC_S_model: ", np.round(recall_score(y_gt, RFC_S.predict(X_gt)), decimals=4))
print("Precision RFC_S_model: ", np.round(precision_score(y_gt, RFC_S.predict(X_gt)), decimals=4))
print("----------------------------------------------------------------------")
print("Recall NBC_model: ", np.round(recall_score(y_gt, NBC.predict(X_gt)), decimals=4))
print("Precision NBC_model: ", np.round(precision_score(y_gt, NBC.predict(X_gt)), decimals=4))
print("----------------------------------------------------------------------")
print("Recall SVM_model: ", np.round(recall_score(y_gt, SVM_S.predict(X_gt)), decimals=4))
print("Precision SVM_model: ", np.round(precision_score(y_gt, SVM_S.predict(X_gt)), decimals=4))
print("----------------------------------------------------------------------")
#print(classification_report(y_gt, LR_Grid.predict(X_gt)))
#print(classification_report(y_gt, LR_Grid.predict(X_gt)))
# LR_Grid
y_pred_proba = LR_Grid.predict_proba(X_gt)[::,1]
fpr, tpr, _ = metrics.roc_curve(y_gt, y_pred_LR_Grid)
auc = metrics.roc_auc_score(y_gt, y_pred_LR_Grid)
plt.plot(fpr, tpr, color='orange',label='Logistic Regression (auc = plt.xlabel('False Positive Rate',color='grey', fontsize = 13)
plt.ylabel('True Positive Rate',color='grey', fontsize = 13)
plt.title('Receiver operating characteristic')
plt.legend(loc="lower right")
plt.legend(loc=4)
plt.plot([0, 1], [0, 1],'r--')
plt.show()
#RFC_S
y_pred_proba = RFC_S.predict_proba(X_gt)[::,1]
fpr, tpr, _ = metrics.roc_curve(y_gt, y_pred_RFC_S)
auc = metrics.roc_auc_score(y_gt, y_pred_RFC_S)
plt.plot(fpr, tpr, color='red',label='RFC_S (auc = plt.xlabel('False Positive Rate',color='grey', fontsize = 13)
plt.ylabel('True Positive Rate',color='grey', fontsize = 13)
plt.title('Receiver operating characteristic')
plt.legend(loc="lower right")
plt.legend(loc=4)
plt.plot([0, 1], [0, 1],'r--')
plt.show()
#NBC
y_pred_proba = NBC.predict_proba(X_gt)[::,1]
fpr, tpr, _ = metrics.roc_curve(y_gt, y_pred_NBC)
auc = metrics.roc_auc_score(y_gt, y_pred_NBC)
plt.plot(fpr, tpr, color='green',label='NBC_S (auc = plt.xlabel('False Positive Rate',color='grey', fontsize = 13)
plt.ylabel('True Positive Rate',color='grey', fontsize = 13)
plt.title('Receiver operating characteristic')
plt.legend(loc="lower right")
plt.legend(loc=4)
plt.plot([0, 1], [0, 1],'r--')
plt.show()
#SVM
#y_pred_proba = SVM_S.predict_proba(X_gt)[::,1]
#fpr, tpr, _ = metrics.roc_curve(y_gt, y_pred_SVM)
#auc = metrics.roc_auc_score(y_gt, y_pred_SVM)
#plt.plot(fpr, tpr, color='green',label='SVM (auc =
#plt.xlabel('False Positive Rate',color='grey', fontsize = 13)
#plt.ylabel('True Positive Rate',color='grey', fontsize = 13)
#plt.title('Receiver operating characteristic')
#plt.legend(loc="lower right")
#plt.legend(loc=4)
#plt.plot([0, 1], [0, 1],'r--')
#plt.show()