diyabettahmin.py

# -*- coding: utf-8 -*-
"""DiyabetTahmin.ipynb

Automatically generated by Colab.

Original file is located at
    https://colab.research.google.com/drive/1R9oZdeLPWUDiGOqbz0XImtSFrsXH0YV_

# ***GEREKLİ KÜTÜPHANELER SAYFAYA DAHİL EDİLMESİ VE VERİ SETİNİN ÇAĞIRILMASI***
"""

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix, roc_auc_score, log_loss
import time
from sklearn.tree import DecisionTreeClassifier
from sklearn.neighbors import KNeighborsClassifier
import xgboost as xgb
from catboost import CatBoostClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
from sklearn.ensemble import AdaBoostClassifier
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import GridSearchCV
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score
from sklearn.cluster import AgglomerativeClustering
from sklearn.svm import SVC
from sklearn.naive_bayes import GaussianNB
from sklearn.ensemble import BaggingClassifier
import warnings
warnings.filterwarnings("ignore")

!pip install catboost

dfC = pd.read_csv("Healthcare-Diabetes.csv")

df = dfC.copy()

df.head(3)

df.tail(3)

"""# ***KEŞİFSEL VERİ ANALİZİNİN YAPILMASI (Exploratory Data Analysis - EDA)***"""

df.info()

df.shape

df.columns

df.describe().T

df.isnull().sum()

df.duplicated().sum()

df.Outcome.value_counts()*100/len(df)

plt.figure(figsize=(17,6))
sns.countplot(x= "Outcome", data = df, color= 'red')
plt.show()

pd.crosstab(df['Outcome'], df['Age'], margins=True)

"""# ***AYKIRI DEĞER İNCELEMESİ(Anomali Tespiti)***"""

plt.figure(figsize=(17,6))
sns.boxplot(data = df)                    #herhangi bir kütüphane kullanmadan
plt.title("Aykırı Değer Gösterimi")
plt.show()

q1 = df.quantile(0.25)
q2 = df.quantile(0.75)
q3 = q2 - q1

cıktı = df[((df < (q1 - 1.5 * q3)) | (df > (q2 + 1.5 * q3))).any(axis=1)]
print(cıktı)

"""# ***VERİLERİN GÖRSELLEŞTİRİLMESİ***"""

plt.figure(figsize= (17,6))
sns.histplot(data=df['Age'], color='red')
plt.tight_layout()
plt.show()

plt.figure(figsize= (17,6))
sns.barplot(x= "Pregnancies", y = "Outcome", data = df, color = "red")
plt.xlabel("Pregnancies")
plt.ylabel("Outcome")
plt.xticks(rotation = 50)

plt.tight_layout()
plt.show()

plt.figure(figsize= (17,6))
sns.scatterplot(x= "Pregnancies", y= "Insulin", data = df, hue = "Outcome")
plt.tight_layout()
plt.show()

plt.figure(figsize=(17,6))
sns.scatterplot(x= "Pregnancies", y = "Age", hue = "Outcome", data = df)
plt.tight_layout()
plt.show()

plt.figure(figsize=(17,6))
sns.scatterplot(x= "Glucose", y= "Age", hue= "Outcome", data = df)
plt.tight_layout()
plt.show()

korelasyon = df.corr()

print(korelasyon)

plt.figure(figsize=(17,6))
sns.heatmap(korelasyon, annot = True, cmap = "Set3", fmt= ".2f", linewidths=0.5, linecolor="gray")
plt.tight_layout()
plt.show()

plt.figure(figsize=(17,6))
sns.violinplot(x= "Outcome", y= "Pregnancies", data = df, palette='Set2')
plt.tight_layout()
plt.show()

plt.figure(figsize=(17,6))
sns.violinplot(x= "Outcome", y= "Age", data = df, palette='Set2')
plt.tight_layout()
plt.show()

plt.figure(figsize=(17,6))
sns.violinplot(x= "Outcome", y= "Glucose", data = df, palette= 'Set2')
plt.tight_layout()
plt.show()

plt.figure(figsize=(10,6))
sns.countplot(x='Pregnancies',data=df,hue='Outcome', palette='Set2')
plt.tight_layout()
plt.show()

deger = df.drop(columns=['Id'])
deger.hist(figsize=(22,20))
plt.tight_layout()
plt.show()

plt.figure(figsize= (17,6))
sns.displot(df['Outcome'])
plt.tight_layout()
plt.show()

plt.figure(figsize=(17,6))
sns.pairplot(df, hue='Outcome', diag_kind='hist')
plt.tight_layout()
plt.show()

"""# ***VERİ ÖN İŞLEME***"""

y= df[["Outcome"]]
x= df.drop(["Outcome", "Id"], axis = 1)

x_train, x_test, y_train, y_test = train_test_split(x,y, random_state=42, train_size=0.70)

standart = StandardScaler()

x_train_scaler = standart.fit_transform(x_train)
x_test_scaler = standart.transform(x_test)

"""# ***GÖZETİMLİ ÖĞRENME ve MODEL DEĞERLENDİRME***"""

start_train_time = time.time()
lr = LogisticRegression()
model = lr.fit(x_train_scaler, y_train)
end_train_time = time.time()
total_train_time = end_train_time - start_train_time            #LogisticRegression 1

y_train_pred = lr.predict(x_train_scaler)
y_train_proba = lr.predict_proba(x_train_scaler)[:, 1]
train_accuracy = accuracy_score(y_train, y_train_pred)
train_precision = precision_score(y_train, y_train_pred)
train_recall = recall_score(y_train, y_train_pred)
train_f1 = f1_score(y_train, y_train_pred)
train_confusion = confusion_matrix(y_train, y_train_pred)
train_roc_auc = roc_auc_score(y_train, y_train_proba)
train_log_loss = log_loss(y_train, y_train_proba)

start_test_time = time.time()
y_test_pred = lr.predict(x_test_scaler)
y_test_proba = lr.predict_proba(x_test_scaler)[:, 1]
end_test_time = time.time()
total_test_time = end_test_time - start_test_time

test_accuracy = accuracy_score(y_test, y_test_pred)
test_precision = precision_score(y_test, y_test_pred)
test_recall = recall_score(y_test, y_test_pred)
test_f1 = f1_score(y_test, y_test_pred)
test_confusion = confusion_matrix(y_test, y_test_pred)
test_roc_auc = roc_auc_score(y_test, y_test_proba)
test_log_loss = log_loss(y_test, y_test_proba)


print(f"Train Time : {total_train_time}")
print(f"Train Accuracy Score: {train_accuracy}")
print(f"Train Precision Score: {train_precision}")
print(f"Train Recall Score : {train_recall}")
print(f"Train F1 Score : {train_f1}")
print(f"Train Confusion Matrix : {train_confusion}")
print(f"Train Log Loss : {train_log_loss}")
print(f"Train ROC AUC Score : {train_roc_auc}")
print("---------------------------------------------------------")
print(f"Test Time : {total_test_time}")
print(f"Test Accuracy Score: {test_accuracy}")
print(f"Test Precision Score: {test_precision}")
print(f"Test Recall Score: {test_recall}")
print(f"Test F1 Score: {test_f1}")
print(f"Test Confusion Matrix: {test_confusion}")
print(f"Test Log Loss : {test_log_loss}")
print(f"Test ROC AUC Score: {test_roc_auc}")

start_train_time = time.time()
dc = DecisionTreeClassifier()
model = dc.fit(x_train_scaler, y_train)                         #DecisionTreeClassifier 2
end_train_time = time.time()
total_train_time = end_train_time - start_train_time

y_train_pred = dc.predict(x_train_scaler)
y_train_proba = dc.predict_proba(x_train_scaler)[:, 1]
train_accuracy = accuracy_score(y_train, y_train_pred)
train_precision = precision_score(y_train, y_train_pred)
train_recall = recall_score(y_train, y_train_pred)
train_f1 = f1_score(y_train, y_train_pred)
train_confusion = confusion_matrix(y_train, y_train_pred)
train_roc_auc = roc_auc_score(y_train, y_train_proba)
train_log_loss = log_loss(y_train, y_train_proba)

start_test_time = time.time()
y_test_pred = dc.predict(x_test_scaler)
y_test_proba = dc.predict_proba(x_test_scaler)[:, 1]
end_test_time = time.time()
total_test_time = end_test_time - start_test_time

test_accuracy = accuracy_score(y_test, y_test_pred)
test_precision = precision_score(y_test, y_test_pred)
test_recall = recall_score(y_test, y_test_pred)
test_f1 = f1_score(y_test, y_test_pred)
test_confusion = confusion_matrix(y_test, y_test_pred)
test_roc_auc = roc_auc_score(y_test, y_test_proba)
test_log_loss = log_loss(y_test, y_test_proba)


print(f"Train Time : {total_train_time}")
print(f"Train Accuracy Score: {train_accuracy}")
print(f"Train Precision Score: {train_precision}")
print(f"Train Recall Score : {train_recall}")
print(f"Train F1 Score : {train_f1}")
print(f"Train Confusion Matrix : {train_confusion}")
print(f"Train Log Loss : {train_log_loss}")
print(f"Train ROC AUC Score : {train_roc_auc}")
print("---------------------------------------------------------")
print(f"Test Time : {total_test_time}")
print(f"Test Accuracy Score: {test_accuracy}")
print(f"Test Precision Score: {test_precision}")
print(f"Test Recall Score: {test_recall}")
print(f"Test F1 Score: {test_f1}")
print(f"Test Confusion Matrix: {test_confusion}")
print(f"Test Log Loss : {test_log_loss}")
print(f"Test ROC AUC Score: {test_roc_auc}")

start_train_time = time.time()
kn = KNeighborsClassifier(n_neighbors=5)
model = kn.fit(x_train_scaler, y_train)                           #KNeighborsClassifier 3
end_train_time = time.time()
total_train_time = end_train_time - start_train_time

y_train_pred = kn.predict(x_train_scaler)
y_train_proba = kn.predict_proba(x_train_scaler)[:, 1]
train_accuracy = accuracy_score(y_train, y_train_pred)
train_precision = precision_score(y_train, y_train_pred)
train_recall = recall_score(y_train, y_train_pred)
train_f1 = f1_score(y_train, y_train_pred)
train_confusion = confusion_matrix(y_train, y_train_pred)
train_roc_auc = roc_auc_score(y_train, y_train_proba)
train_log_loss = log_loss(y_train, y_train_proba)

start_test_time = time.time()
y_test_pred = kn.predict(x_test_scaler)
y_test_proba = kn.predict_proba(x_test_scaler)[:, 1]
end_test_time = time.time()
total_test_time = end_test_time - start_test_time

test_accuracy = accuracy_score(y_test, y_test_pred)
test_precision = precision_score(y_test, y_test_pred)
test_recall = recall_score(y_test, y_test_pred)
test_f1 = f1_score(y_test, y_test_pred)
test_confusion = confusion_matrix(y_test, y_test_pred)
test_roc_auc = roc_auc_score(y_test, y_test_proba)
test_log_loss = log_loss(y_test, y_test_proba)


print(f"Train Time : {total_train_time}")
print(f"Train Accuracy Score: {train_accuracy}")
print(f"Train Precision Score: {train_precision}")
print(f"Train Recall Score : {train_recall}")
print(f"Train F1 Score : {train_f1}")
print(f"Train Confusion Matrix : {train_confusion}")
print(f"Train Log Loss : {train_log_loss}")
print(f"Train ROC AUC Score : {train_roc_auc}")
print("---------------------------------------------------------")
print(f"Test Time : {total_test_time}")
print(f"Test Accuracy Score: {test_accuracy}")
print(f"Test Precision Score: {test_precision}")
print(f"Test Recall Score: {test_recall}")
print(f"Test F1 Score: {test_f1}")
print(f"Test Confusion Matrix: {test_confusion}")
print(f"Test Log Loss : {test_log_loss}")
print(f"Test ROC AUC Score: {test_roc_auc}")

start_train_time = time.time()
xg = xgb.XGBClassifier()
model = xg.fit(x_train_scaler, y_train)                            #XGBClassifier 4
end_train_time = time.time()
total_train_time = end_train_time - start_train_time

y_train_pred = xg.predict(x_train_scaler)
y_train_proba = xg.predict_proba(x_train_scaler)[:, 1]
train_accuracy = accuracy_score(y_train, y_train_pred)
train_precision = precision_score(y_train, y_train_pred)
train_recall = recall_score(y_train, y_train_pred)
train_f1 = f1_score(y_train, y_train_pred)
train_confusion = confusion_matrix(y_train, y_train_pred)
train_roc_auc = roc_auc_score(y_train, y_train_proba)
train_log_loss = log_loss(y_train, y_train_proba)

start_test_time = time.time()
y_test_pred = xg.predict(x_test_scaler)
y_test_proba = xg.predict_proba(x_test_scaler)[:, 1]
end_test_time = time.time()
total_test_time = end_test_time - start_test_time

test_accuracy = accuracy_score(y_test, y_test_pred)
test_precision = precision_score(y_test, y_test_pred)
test_recall = recall_score(y_test, y_test_pred)
test_f1 = f1_score(y_test, y_test_pred)
test_confusion = confusion_matrix(y_test, y_test_pred)
test_roc_auc = roc_auc_score(y_test, y_test_proba)
test_log_loss = log_loss(y_test, y_test_proba)


print(f"Train Time : {total_train_time}")
print(f"Train Accuracy Score: {train_accuracy}")
print(f"Train Precision Score: {train_precision}")
print(f"Train Recall Score : {train_recall}")
print(f"Train F1 Score : {train_f1}")
print(f"Train Confusion Matrix : {train_confusion}")
print(f"Train Log Loss : {train_log_loss}")
print(f"Train ROC AUC Score : {train_roc_auc}")
print("---------------------------------------------------------")
print(f"Test Time : {total_test_time}")
print(f"Test Accuracy Score: {test_accuracy}")
print(f"Test Precision Score: {test_precision}")
print(f"Test Recall Score: {test_recall}")
print(f"Test F1 Score: {test_f1}")
print(f"Test Confusion Matrix: {test_confusion}")
print(f"Test Log Loss : {test_log_loss}")
print(f"Test ROC AUC Score: {test_roc_auc}")

start_train_time = time.time()
ct = CatBoostClassifier(iterations=1000, learning_rate=0.1, depth=6, verbose=0)
model = ct.fit(x_train_scaler, y_train)                                             #CatBoostClassifier 5
end_train_time = time.time()
total_train_time = end_train_time - start_train_time

y_train_pred = ct.predict(x_train_scaler)
y_train_proba = ct.predict_proba(x_train_scaler)[:, 1]
train_accuracy = accuracy_score(y_train, y_train_pred)
train_precision = precision_score(y_train, y_train_pred)
train_recall = recall_score(y_train, y_train_pred)
train_f1 = f1_score(y_train, y_train_pred)
train_confusion = confusion_matrix(y_train, y_train_pred)
train_roc_auc = roc_auc_score(y_train, y_train_proba)
train_log_loss = log_loss(y_train, y_train_proba)

start_test_time = time.time()
y_test_pred = ct.predict(x_test_scaler)
y_test_proba = ct.predict_proba(x_test_scaler)[:, 1]
end_test_time = time.time()
total_test_time = end_test_time - start_test_time

test_accuracy = accuracy_score(y_test, y_test_pred)
test_precision = precision_score(y_test, y_test_pred)
test_recall = recall_score(y_test, y_test_pred)
test_f1 = f1_score(y_test, y_test_pred)
test_confusion = confusion_matrix(y_test, y_test_pred)
test_roc_auc = roc_auc_score(y_test, y_test_proba)
test_log_loss = log_loss(y_test, y_test_proba)


print(f"Train Time : {total_train_time}")
print(f"Train Accuracy Score: {train_accuracy}")
print(f"Train Precision Score: {train_precision}")
print(f"Train Recall Score : {train_recall}")
print(f"Train F1 Score : {train_f1}")
print(f"Train Confusion Matrix : {train_confusion}")
print(f"Train Log Loss : {train_log_loss}")
print(f"Train ROC AUC Score : {train_roc_auc}")
print("---------------------------------------------------------")
print(f"Test Time : {total_test_time}")
print(f"Test Accuracy Score: {test_accuracy}")
print(f"Test Precision Score: {test_precision}")
print(f"Test Recall Score: {test_recall}")
print(f"Test F1 Score: {test_f1}")
print(f"Test Confusion Matrix: {test_confusion}")
print(f"Test Log Loss : {test_log_loss}")
print(f"Test ROC AUC Score: {test_roc_auc}")

start_train_time = time.time()
rf = RandomForestClassifier(n_estimators=100, random_state=42)
model = rf.fit(x_train_scaler, y_train)                                             #RandomForestClassifier 6
end_train_time = time.time()
total_train_time = end_train_time - start_train_time

y_train_pred = rf.predict(x_train_scaler)
y_train_proba = rf.predict_proba(x_train_scaler)[:, 1]
train_accuracy = accuracy_score(y_train, y_train_pred)
train_precision = precision_score(y_train, y_train_pred)
train_recall = recall_score(y_train, y_train_pred)
train_f1 = f1_score(y_train, y_train_pred)
train_confusion = confusion_matrix(y_train, y_train_pred)
train_roc_auc = roc_auc_score(y_train, y_train_proba)
train_log_loss = log_loss(y_train, y_train_proba)

start_test_time = time.time()
y_test_pred = rf.predict(x_test_scaler)
y_test_proba = rf.predict_proba(x_test_scaler)[:, 1]
end_test_time = time.time()
total_test_time = end_test_time - start_test_time

test_accuracy = accuracy_score(y_test, y_test_pred)
test_precision = precision_score(y_test, y_test_pred)
test_recall = recall_score(y_test, y_test_pred)
test_f1 = f1_score(y_test, y_test_pred)
test_confusion = confusion_matrix(y_test, y_test_pred)
test_roc_auc = roc_auc_score(y_test, y_test_proba)
test_log_loss = log_loss(y_test, y_test_proba)


print(f"Train Time : {total_train_time}")
print(f"Train Accuracy Score: {train_accuracy}")
print(f"Train Precision Score: {train_precision}")
print(f"Train Recall Score : {train_recall}")
print(f"Train F1 Score : {train_f1}")
print(f"Train Confusion Matrix : {train_confusion}")
print(f"Train Log Loss : {train_log_loss}")
print(f"Train ROC AUC Score : {train_roc_auc}")
print("---------------------------------------------------------")
print(f"Test Time : {total_test_time}")
print(f"Test Accuracy Score: {test_accuracy}")
print(f"Test Precision Score: {test_precision}")
print(f"Test Recall Score: {test_recall}")
print(f"Test F1 Score: {test_f1}")
print(f"Test Confusion Matrix: {test_confusion}")
print(f"Test Log Loss : {test_log_loss}")
print(f"Test ROC AUC Score: {test_roc_auc}")

start_train_time = time.time()
sv = SVC(probability=True, random_state=42)
model = sv.fit(x_train_scaler, y_train)                                             #SVC 7
end_train_time = time.time()
total_train_time = end_train_time - start_train_time

y_train_pred = sv.predict(x_train_scaler)
y_train_proba = sv.predict_proba(x_train_scaler)[:, 1]
train_accuracy = accuracy_score(y_train, y_train_pred)
train_precision = precision_score(y_train, y_train_pred)
train_recall = recall_score(y_train, y_train_pred)
train_f1 = f1_score(y_train, y_train_pred)
train_confusion = confusion_matrix(y_train, y_train_pred)
train_roc_auc = roc_auc_score(y_train, y_train_proba)
train_log_loss = log_loss(y_train, y_train_proba)

start_test_time = time.time()
y_test_pred = sv.predict(x_test_scaler)
y_test_proba = sv.predict_proba(x_test_scaler)[:, 1]
end_test_time = time.time()
total_test_time = end_test_time - start_test_time

test_accuracy = accuracy_score(y_test, y_test_pred)
test_precision = precision_score(y_test, y_test_pred)
test_recall = recall_score(y_test, y_test_pred)
test_f1 = f1_score(y_test, y_test_pred)
test_confusion = confusion_matrix(y_test, y_test_pred)
test_roc_auc = roc_auc_score(y_test, y_test_proba)
test_log_loss = log_loss(y_test, y_test_proba)


print(f"Train Time : {total_train_time}")
print(f"Train Accuracy Score: {train_accuracy}")
print(f"Train Precision Score: {train_precision}")
print(f"Train Recall Score : {train_recall}")
print(f"Train F1 Score : {train_f1}")
print(f"Train Confusion Matrix : {train_confusion}")
print(f"Train Log Loss : {train_log_loss}")
print(f"Train ROC AUC Score : {train_roc_auc}")
print("---------------------------------------------------------")
print(f"Test Time : {total_test_time}")
print(f"Test Accuracy Score: {test_accuracy}")
print(f"Test Precision Score: {test_precision}")
print(f"Test Recall Score: {test_recall}")
print(f"Test F1 Score: {test_f1}")
print(f"Test Confusion Matrix: {test_confusion}")
print(f"Test Log Loss : {test_log_loss}")
print(f"Test ROC AUC Score: {test_roc_auc}")

start_train_time = time.time()
ad = AdaBoostClassifier(n_estimators=50, random_state=42)
model = ad.fit(x_train_scaler, y_train)                                             #AdaBoostClassifier 8
end_train_time = time.time()
total_train_time = end_train_time - start_train_time

y_train_pred = ad.predict(x_train_scaler)
y_train_proba = ad.predict_proba(x_train_scaler)[:, 1]
train_accuracy = accuracy_score(y_train, y_train_pred)
train_precision = precision_score(y_train, y_train_pred)
train_recall = recall_score(y_train, y_train_pred)
train_f1 = f1_score(y_train, y_train_pred)
train_confusion = confusion_matrix(y_train, y_train_pred)
train_roc_auc = roc_auc_score(y_train, y_train_proba)
train_log_loss = log_loss(y_train, y_train_proba)

start_test_time = time.time()
y_test_pred = ad.predict(x_test_scaler)
y_test_proba = ad.predict_proba(x_test_scaler)[:, 1]
end_test_time = time.time()
total_test_time = end_test_time - start_test_time

test_accuracy = accuracy_score(y_test, y_test_pred)
test_precision = precision_score(y_test, y_test_pred)
test_recall = recall_score(y_test, y_test_pred)
test_f1 = f1_score(y_test, y_test_pred)
test_confusion = confusion_matrix(y_test, y_test_pred)
test_roc_auc = roc_auc_score(y_test, y_test_proba)
test_log_loss = log_loss(y_test, y_test_proba)


print(f"Train Time : {total_train_time}")
print(f"Train Accuracy Score: {train_accuracy}")
print(f"Train Precision Score: {train_precision}")
print(f"Train Recall Score : {train_recall}")
print(f"Train F1 Score : {train_f1}")
print(f"Train Confusion Matrix : {train_confusion}")
print(f"Train Log Loss : {train_log_loss}")
print(f"Train ROC AUC Score : {train_roc_auc}")
print("---------------------------------------------------------")
print(f"Test Time : {total_test_time}")
print(f"Test Accuracy Score: {test_accuracy}")
print(f"Test Precision Score: {test_precision}")
print(f"Test Recall Score: {test_recall}")
print(f"Test F1 Score: {test_f1}")
print(f"Test Confusion Matrix: {test_confusion}")
print(f"Test Log Loss : {test_log_loss}")
print(f"Test ROC AUC Score: {test_roc_auc}")

start_train_time = time.time()
gn = GaussianNB()
model = gn.fit(x_train_scaler, y_train)                                             #GaussianNB 9
end_train_time = time.time()
total_train_time = end_train_time - start_train_time

y_train_pred = gn.predict(x_train_scaler)
y_train_proba = gn.predict_proba(x_train_scaler)[:, 1]
train_accuracy = accuracy_score(y_train, y_train_pred)
train_precision = precision_score(y_train, y_train_pred)
train_recall = recall_score(y_train, y_train_pred)
train_f1 = f1_score(y_train, y_train_pred)
train_confusion = confusion_matrix(y_train, y_train_pred)
train_roc_auc = roc_auc_score(y_train, y_train_proba)
train_log_loss = log_loss(y_train, y_train_proba)

start_test_time = time.time()
y_test_pred = gn.predict(x_test_scaler)
y_test_proba = gn.predict_proba(x_test_scaler)[:, 1]
end_test_time = time.time()
total_test_time = end_test_time - start_test_time

test_accuracy = accuracy_score(y_test, y_test_pred)
test_precision = precision_score(y_test, y_test_pred)
test_recall = recall_score(y_test, y_test_pred)
test_f1 = f1_score(y_test, y_test_pred)
test_confusion = confusion_matrix(y_test, y_test_pred)
test_roc_auc = roc_auc_score(y_test, y_test_proba)
test_log_loss = log_loss(y_test, y_test_proba)


print(f"Train Time : {total_train_time}")
print(f"Train Accuracy Score: {train_accuracy}")
print(f"Train Precision Score: {train_precision}")
print(f"Train Recall Score : {train_recall}")
print(f"Train F1 Score : {train_f1}")
print(f"Train Confusion Matrix : {train_confusion}")
print(f"Train Log Loss : {train_log_loss}")
print(f"Train ROC AUC Score : {train_roc_auc}")
print("---------------------------------------------------------")
print(f"Test Time : {total_test_time}")
print(f"Test Accuracy Score: {test_accuracy}")
print(f"Test Precision Score: {test_precision}")
print(f"Test Recall Score: {test_recall}")
print(f"Test F1 Score: {test_f1}")
print(f"Test Confusion Matrix: {test_confusion}")
print(f"Test Log Loss : {test_log_loss}")
print(f"Test ROC AUC Score: {test_roc_auc}")

start_bagging_train_time = time.time()
bagging = BaggingClassifier(estimator=RandomForestClassifier(n_estimators=100, random_state=42),
                            n_estimators=10, random_state=42)                                     #BaggingClassifier 10
bagging_model = bagging.fit(x_train_scaler, y_train)
end_bagging_train_time = time.time()
total_bagging_train_time = end_bagging_train_time - start_bagging_train_time

y_bagging_train_pred = bagging.predict(x_train_scaler)
y_bagging_train_proba = bagging.predict_proba(x_train_scaler)[:, 1]

train_bagging_accuracy = accuracy_score(y_train, y_bagging_train_pred)
train_bagging_precision = precision_score(y_train, y_bagging_train_pred)
train_bagging_recall = recall_score(y_train, y_bagging_train_pred)
train_bagging_f1 = f1_score(y_train, y_bagging_train_pred)
train_bagging_confusion = confusion_matrix(y_train, y_bagging_train_pred)
train_bagging_roc_auc = roc_auc_score(y_train, y_bagging_train_proba)
train_bagging_log_loss = log_loss(y_train, y_bagging_train_proba)

start_bagging_test_time = time.time()
y_bagging_test_pred = bagging.predict(x_test_scaler)
y_bagging_test_proba = bagging.predict_proba(x_test_scaler)[:, 1]
end_bagging_test_time = time.time()
total_bagging_test_time = end_bagging_test_time - start_bagging_test_time

test_bagging_accuracy = accuracy_score(y_test, y_bagging_test_pred)
test_bagging_precision = precision_score(y_test, y_bagging_test_pred)
test_bagging_recall = recall_score(y_test, y_bagging_test_pred)
test_bagging_f1 = f1_score(y_test, y_bagging_test_pred)
test_bagging_confusion = confusion_matrix(y_test, y_bagging_test_pred)
test_bagging_roc_auc = roc_auc_score(y_test, y_bagging_test_proba)
test_bagging_log_loss = log_loss(y_test, y_bagging_test_proba)

print(f"Bagging Train Time: {total_bagging_train_time}")
print(f"Bagging Train Accuracy: {train_bagging_accuracy}")
print(f"Bagging Train Precision: {train_bagging_precision}")
print(f"Bagging Train Recall: {train_bagging_recall}")
print(f"Bagging Train F1: {train_bagging_f1}")
print(f"Bagging Train Confusion Matrix: \n{train_bagging_confusion}")
print(f"Bagging Train ROC AUC: {train_bagging_roc_auc}")
print(f"Bagging Train Log Loss: {train_bagging_log_loss}")
print("---------------------------------------------------------")
print(f"Bagging Test Time: {total_bagging_test_time}")
print(f"Bagging Test Accuracy: {test_bagging_accuracy}")
print(f"Bagging Test Precision: {test_bagging_precision}")
print(f"Bagging Test Recall: {test_bagging_recall}")
print(f"Bagging Test F1: {test_bagging_f1}")
print(f"Bagging Test Confusion Matrix: \n{test_bagging_confusion}")
print(f"Bagging Test ROC AUC: {test_bagging_roc_auc}")
print(f"Bagging Test Log Loss: {test_bagging_log_loss}")

"""# ***XGBClassifier MODEL OPTİMİZASYONU***"""

cv_scores = cross_val_score(xg, x_train_scaler, y_train, cv=7, scoring='roc_auc')
print(f"Çapraz Doğrulama Skorları: {cv_scores}")
print(f"En Düşük CV Skoru: {cv_scores.min()}")
print(f"En Yüksek CV Skoru: {cv_scores.max()}")
print(f"Ortalama CV Skoru: {cv_scores.mean()}")

param_grid = {
    'n_estimators': [100, 200, 300],
    'learning_rate': [0.01, 0.1, 0.2],
    'max_depth': [3, 4, 5],
    'subsample': [0.5, 0.7, 1],
    'colsample_bytree': [0.5, 0.7, 1],
    'gamma': [0, 1, 5]
}
xg = xgb.XGBClassifier(use_label_encoder=False, eval_metric='logloss')

grid_search = GridSearchCV(estimator=xg, param_grid=param_grid, scoring='roc_auc', cv=5, verbose=1)

grid_search.fit(x_train_scaler, y_train)

print("En iyi parametreler:", grid_search.best_params_)
print("En iyi CV skoru:", grid_search.best_score_)

"""# ***BULUNAN EN İYİ PARAMETRELER İLE MODELİ TEKRARDAN EĞİTME***"""

start_train_time = time.time()
xg = xgb.XGBClassifier(colsample_bytree= 0.7, gamma =  1, learning_rate = 0.2, max_depth = 5, n_estimators = 200, subsample = 1)
model = xg.fit(x_train_scaler, y_train)                                                                                               #XGBClassifier
end_train_time = time.time()
total_train_time = end_train_time - start_train_time

y_train_pred = xg.predict(x_train_scaler)
y_train_proba = xg.predict_proba(x_train_scaler)[:, 1]
train_accuracy = accuracy_score(y_train, y_train_pred)
train_precision = precision_score(y_train, y_train_pred)
train_recall = recall_score(y_train, y_train_pred)
train_f1 = f1_score(y_train, y_train_pred)
train_confusion = confusion_matrix(y_train, y_train_pred)
train_roc_auc = roc_auc_score(y_train, y_train_proba)
train_log_loss = log_loss(y_train, y_train_proba)

start_test_time = time.time()
y_test_pred = xg.predict(x_test_scaler)
y_test_proba = xg.predict_proba(x_test_scaler)[:, 1]
end_test_time = time.time()
total_test_time = end_test_time - start_test_time

test_accuracy = accuracy_score(y_test, y_test_pred)
test_precision = precision_score(y_test, y_test_pred)
test_recall = recall_score(y_test, y_test_pred)
test_f1 = f1_score(y_test, y_test_pred)
test_confusion = confusion_matrix(y_test, y_test_pred)
test_roc_auc = roc_auc_score(y_test, y_test_proba)
test_log_loss = log_loss(y_test, y_test_proba)


print(f"Train Time : {total_train_time}")
print(f"Train Accuracy Score: {train_accuracy}")
print(f"Train Precision Score: {train_precision}")
print(f"Train Recall Score : {train_recall}")
print(f"Train F1 Score : {train_f1}")
print(f"Train Confusion Matrix : {train_confusion}")
print(f"Train Log Loss : {train_log_loss}")
print(f"Train ROC AUC Score : {train_roc_auc}")
print("---------------------------------------------------------")
print(f"Test Time : {total_test_time}")
print(f"Test Accuracy Score: {test_accuracy}")
print(f"Test Precision Score: {test_precision}")
print(f"Test Recall Score: {test_recall}")
print(f"Test F1 Score: {test_f1}")
print(f"Test Confusion Matrix: {test_confusion}")
print(f"Test Log Loss : {test_log_loss}")
print(f"Test ROC AUC Score: {test_roc_auc}")

"""# ***GÖZETİMSİZ ÖĞRENME ve MODEL DEĞERLENDİRME***"""

kmeans = KMeans(n_clusters=4, random_state=42)                  #KMeans

start_train_time = time.time()
model = kmeans.fit(x_train_scaler)
end_train_time = time.time()
total_train_time = end_train_time - start_train_time

y_kmeans_pred = kmeans.predict(x_train_scaler)

silhouette_avg = silhouette_score(x_train_scaler, y_kmeans_pred)

print(f"Toplam Eğitim Süresi: {total_train_time}")
print(f"Silhouette Skoru: {silhouette_avg}")

n_clusters = 4
hierarchical = AgglomerativeClustering(n_clusters=n_clusters)                      #AgglomerativeClustering

start_train_time = time.time()
model = hierarchical.fit(x_train_scaler)
end_train_time = time.time()
total_train_time = end_train_time - start_train_time

labels = hierarchical.labels_

silhouette_avg = silhouette_score(x_train_scaler, labels)

print(f"Toplam Eğitim Süresi: {total_train_time}")
print(f"Silhouette Skoru: {silhouette_avg}")