# lỗi ngày hôm nay : gọi sai đối tượng k_fold dẫn đến không chạy được
                    # plt.legend phải có dấu ngoặc vuông vì nó chỉ nhận 1 đến 2 thuộc tính thôi , k quá 3, như mảng 1 chiều ấy
                    # gọi sai tên hàm trong thư viện logisticRegression




import  numpy as np
import  pandas as pd
import  matplotlib.pyplot as plt
from sklearn import  preprocessing

from sklearn.model_selection import train_test_split, KFold
from sklearn.metrics import accuracy_score,precision_recall_fscore_support
from sklearn.naive_bayes import  GaussianNB
from sklearn import  svm
from sklearn.linear_model import  LinearRegression, LogisticRegression, Perceptron
from sklearn.neighbors import  KNeighborsClassifier
# đọc dữ liệu

duongdan = "data_iris.csv"
dulieu = pd.read_csv(duongdan)
dulieu = dulieu.values
print(dulieu)
x = dulieu[:,:-1]
y =dulieu[:,-1]

#chuẩn hóa
dieuchinh_x = preprocessing.MinMaxScaler(feature_range=(0,1))
X = dieuchinh_x.fit_transform(x)

dieuchinh_y = preprocessing.LabelEncoder()
Y = dieuchinh_y.fit_transform(y)

# chia dữ liệu test và train

x_train,x_test ,y_train,y_test = train_test_split(X,Y,test_size=0.4,random_state=24)
print(" kich thước dữ liệu của train là :",x_train.shape)
print("kích thươc dữ liệu của test là :",x_test.shape)

#Kfold
k_fold = KFold(n_splits=5,shuffle=True,random_state=24)

# mô hình naive_bayes

naive_bayes_model = GaussianNB()
accuracy = []
precision = []
recall = []

for train_idx, val_idx in k_fold.split(x_train):
    # truyền mô hình vào tệp dữ liệu để huấn luyện
    naive_bayes_model.fit(x_train[train_idx], y_train[train_idx])

    # dự đoán nhãn trên tập dữ liệu kiểm tra
    y_pred = naive_bayes_model.predict(x_train[val_idx])

    # tính toán các chỉ số cần tìm
    p,r,f,s = precision_recall_fscore_support(y_train[val_idx] , y_pred,zero_division=1,average="macro") # so sánh nhãn thực tế với nhãn dự đoán để tính các chỉ số
    a = accuracy_score(y_train[val_idx],y_pred)

    accuracy.append(a)
    precision.append(p)
    recall.append(r)

print("kết quả của naive_bayes")
print(f"accuracy : {accuracy}:{sum(accuracy)/len(accuracy)}")
print(f"precision : {precision}:{sum(precision) / len(precision)}")
print(f"recall : {recall}:{sum(recall) / len(recall)}")

plt.subplot(1,5,1)
plt.title("naive_bayes")
plt.plot(accuracy)
plt.plot(precision)
plt.plot(recall)
plt.legend(["accuracy","precision","recall"])
plt.grid()

# mô hình svm
svm_model = svm.SVC()
accuracy = []
precision = []
recall = []
for train_idx , val_idx in k_fold.split(x_train):
    # huấn luyện mô hình trên tập dữ liệu huấn luyện
    svm_model.fit(x_train[train_idx],y_train[train_idx])

    # dự đoán nhãn trên tập kiểm tra
    y_pred = svm_model.predict(x_train[val_idx])

    # tính toán các chỉ số
    p,r,f,s = precision_recall_fscore_support(y_train[val_idx],y_pred,zero_division=1,average="macro")
    a = accuracy_score(y_train[val_idx],y_pred)

    accuracy.append(a)
    precision.append(p)
    recall.append(r)
print("kết quả của svm ")
print(f"accuracy: {accuracy}: {sum(accuracy)/len(accuracy)}")
print(f"precision: {precision}: {sum(precision)/len(precision)}")
print(f"recall: {recall}: {sum(recall)/len(recall)}")

plt.subplot(1,5,2)
plt.title("mô hình svm")
plt.plot(accuracy)
plt.plot(precision)
plt.plot(recall)
plt.legend(["accuracy","precision","recall"])
plt.grid()


# mô hình KNN

KNN_model = KNeighborsClassifier()
accuracy = []
precision = []
recall = []
for train_idx , val_idx in k_fold.split(x_train):
    # huấn luyện mô hình trên tập dữ liệu huấn luyện
    KNN_model.fit(x_train[train_idx],y_train[train_idx])

    # dự đoán nhãn trên tập kiểm tra
    y_pred = KNN_model.predict(x_train[val_idx])

    # tính toán các chỉ số
    p,r,f,s = precision_recall_fscore_support(y_train[val_idx],y_pred,zero_division=1,average="macro")
    a = accuracy_score(y_train[val_idx],y_pred)

    accuracy.append(a)
    precision.append(p)
    recall.append(r)
print("kết quả của KNN ")
print(f"accuracy: {accuracy}: {sum(accuracy)/len(accuracy)}")
print(f"precision: {precision}: {sum(precision)/len(precision)}")
print(f"recall: {recall}: {sum(recall)/len(recall)}")

plt.subplot(1,5,3)
plt.title("mô hình KNN")
plt.plot(accuracy)
plt.plot(precision)
plt.plot(recall)
plt.legend(["accuracy","precision","recall"])
plt.grid()

# mô hình logistic
logistic_model = LogisticRegression()

accuracy = []
precision = []
recall = []
for train_idx , val_idx in k_fold.split(x_train):
    # huấn luyện mô hình trên tập dữ liệu
    logistic_model.fit(x_train[train_idx],y_train[train_idx])

    # dự đoán nhãn trên tập kiểm tra
    y_pred = logistic_model.predict(x_train[val_idx])

    # tính toán các chỉ số
    p,r,f,s = precision_recall_fscore_support(y_train[val_idx],y_pred,zero_division=1,average="macro")
    a = accuracy_score(y_train[val_idx],y_pred)

    accuracy.append(a)
    precision.append(p)
    recall.append(r)
print("kết quả của logistic ")
print(f"accuracy: {accuracy}: {sum(accuracy)/len(accuracy)}")
print(f"precision: {precision}: {sum(precision)/len(precision)}")
print(f"recall: {recall}: {sum(recall)/len(recall)}")

plt.subplot(1,5,4)
plt.title("mô hình logistic")
plt.plot(accuracy)
plt.plot(precision)
plt.plot(recall)
plt.legend(["accuracy","precision","recall"])
plt.grid()

# mô hình Perceptron
perceptron_model = Perceptron()
accuracy = []
precision = []
recall = []
for train_idx , val_idx in k_fold.split(x_train):
    # huấn luyện mô hình trên tập dữ liệu
    perceptron_model.fit(x_train[train_idx],y_train[train_idx])

    # dự đoán nhãn trên tập kiểm tra
    y_pred = perceptron_model.predict(x_train[val_idx])

    # tính toán các chỉ số
    p,r,f,s = precision_recall_fscore_support(y_train[val_idx],y_pred,zero_division=1,average="macro")
    a = accuracy_score(y_train[val_idx],y_pred)

    accuracy.append(a)
    precision.append(p)
    recall.append(r)
print("kết quả của perceptron ")
print(f"accuracy: {accuracy}: {sum(accuracy)/len(accuracy)}")
print(f"precision: {precision}: {sum(precision)/len(precision)}")
print(f"recall: {recall}: {sum(recall)/len(recall)}")

plt.subplot(1,5,5)
plt.title("mô hình perceptron_model")
plt.plot(accuracy)
plt.plot(precision,linewidth = 3)
plt.plot(recall)
plt.legend(["accuracy","precision","recall"])
plt.grid()

plt.show()