ml l04

import cv2
import numpy as np
from Lista02 import FuncoesML as fun
import pandas as pd
from sklearn.model_selection import KFold
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC
import time
from sklearn.linear_model import LogisticRegression
from scipy.stats import friedmanchisquare
from scipy.stats import kruskal
from sklearn.neural_network import MLPClassifier

# Carregando as imagens de cada tipo das pastas e salvando em vetores
circles = []
circles = fun.loadFiles('C:/Users/Auricelia/Desktop/2d_geometric_shapes_dataset/circles/*.jpg', circles)

ellipsis = []
ellipsis = fun.loadFiles('C:/Users/Auricelia/Desktop/2d_geometric_shapes_dataset/ellipses/*.jpg', ellipsis)

hexagons = []
hexagons = fun.loadFiles('C:/Users/Auricelia/Desktop/2d_geometric_shapes_dataset/hexagons/*.jpg', hexagons)

lines = []
lines = fun.loadFiles('C:/Users/Auricelia/Desktop/2d_geometric_shapes_dataset/lines/*.jpg', lines)

rectangles = []
rectangles = fun.loadFiles('C:/Users/Auricelia/Desktop/2d_geometric_shapes_dataset/rectangles/*.jpg', rectangles)

rhombuses = []
rhombuses = fun.loadFiles('C:/Users/Auricelia/Desktop/2d_geometric_shapes_dataset/rhombuses/*.jpg', rhombuses)

squares = []
squares = fun.loadFiles('C:/Users/Auricelia/Desktop/2d_geometric_shapes_dataset/squares/*.jpg', squares)

trapezia = []
trapezia = fun.loadFiles('C:/Users/Auricelia/Desktop/2d_geometric_shapes_dataset/trapezia/*.jpg', trapezia)

triangles = []
triangles = fun.loadFiles('C:/Users/Auricelia/Desktop/2d_geometric_shapes_dataset/triangles/*.jpg', triangles)

# Pré-processamento das imagens

# Conversão de RGB para tons de cinza
circles = fun.grayConversion(circles)

# Aplicando o blur
circles = fun.blurConversion(circles, 5, 0)

# Aplicando a binarização
circles = fun.binaryConversion(circles, 255, 31)

# Invertendo as imagens
circles = fun.invertConversion(circles)

# Imagens de elipse
ellipsis = fun.grayConversion(ellipsis)
ellipsis = fun.blurConversion(ellipsis, 5, 0)
ellipsis = fun.binaryConversion(ellipsis, 255, 31)
ellipsis = fun.invertConversion(ellipsis)

#Imagens de hexagonos
hexagons = fun.grayConversion(hexagons)
hexagons = fun.blurConversion(hexagons, 5, 0)
hexagons = fun.binaryConversion(hexagons, 255, 31)
hexagons = fun.invertConversion(hexagons)

#Imagens de linhas
lines = fun.grayConversion(lines)
lines = fun.blurConversion(lines, 5, 0)
lines = fun.binaryConversion(lines, 255, 31)
lines = fun.invertConversion(lines)

#Imagens de retangulos
rectangles = fun.grayConversion(rectangles)
rectangles = fun.blurConversion(rectangles, 5, 0)
rectangles = fun.binaryConversion(rectangles, 255, 31)
rectangles = fun.invertConversion(rectangles)

#Imagens de losangos
rhombuses = fun.grayConversion(rhombuses)
rhombuses = fun.blurConversion(rhombuses, 5, 0)
rhombuses = fun.binaryConversion(rhombuses, 255, 31)
rhombuses = fun.invertConversion(rhombuses)

#Imagens de quadrados
squares = fun.grayConversion(squares)
squares = fun.blurConversion(squares, 5, 0)
squares = fun.binaryConversion(squares, 255, 31)
squares = fun.invertConversion(squares)

#Imagens de trapezios
trapezia = fun.grayConversion(trapezia)
trapezia = fun.blurConversion(trapezia, 5, 0)
trapezia = fun.binaryConversion(trapezia,255,31)
trapezia = fun.invertConversion(trapezia)

#Imagens de triangulos
triangles = fun.grayConversion(triangles)
triangles = fun.blurConversion(triangles, 5, 0)
triangles = fun.binaryConversion(triangles, 255, 31)
triangles = fun.invertConversion(triangles)

# Extraindo características

sqaresVetorC = fun.extractCarac(squares)
trianglesVetorC = fun.extractCarac(triangles)
trapeziaVetorC = fun.extractCarac(trapezia)
rhombusesVetorC = fun.extractCarac(rhombuses)
rectanglesVetorC = fun.extractCarac(rectangles)
linesVetorC = fun.extractCarac(lines)
hexagonsVetorC = fun.extractCarac(hexagons)
ellipsisVetorC = fun.extractCarac(ellipsis)
circlesVetorC = fun.extractCarac(circles)

# Transformando em DataFrames

sqaresVetorC = pd.DataFrame(sqaresVetorC)
circlesVetorC = pd.DataFrame(circlesVetorC)
trianglesVetorC = pd.DataFrame(trianglesVetorC)
trapeziaVetorC = pd.DataFrame(trapeziaVetorC)
rhombusesVetorC = pd.DataFrame(rhombusesVetorC)
rectanglesVetorC = pd.DataFrame(rectanglesVetorC)
linesVetorC = pd.DataFrame(linesVetorC)
hexagonsVetorC = pd.DataFrame(hexagonsVetorC)
ellipsisVetorC = pd.DataFrame(ellipsisVetorC)

sqaresVetorC['Classe'] = 'square'
circlesVetorC['Classe'] = 'circle'
trianglesVetorC['Classe'] = 'triangle'
trapeziaVetorC['Classe'] = 'trapezia'
rhombusesVetorC['Classe'] = 'rhombuse'
rectanglesVetorC['Classe'] = 'rectangle'
linesVetorC['Classe'] = 'line'
hexagonsVetorC['Classe'] = 'hexagon'
ellipsisVetorC['Classe'] = 'ellipsis'

dfs =[sqaresVetorC,circlesVetorC,trianglesVetorC,trapeziaVetorC,rhombusesVetorC,rectanglesVetorC,linesVetorC,
                      hexagonsVetorC,ellipsisVetorC]
dataFrame = pd.concat(dfs, ignore_index=True)

dataFrame2 = dataFrame.copy()
del dataFrame['Classe']
dataFrame = fun.normalizar(dataFrame)
print(dataFrame)
dataFrame['Classe'] = dataFrame2['Classe']
print(dataFrame)

kfold = KFold(10, True, 1)

knn1 = KNeighborsClassifier(n_neighbors=1, metric='euclidean')
knn3 = KNeighborsClassifier(n_neighbors=3, metric='euclidean')
knn5 = KNeighborsClassifier(n_neighbors=5, metric='euclidean')
knnpounded1 = KNeighborsClassifier(n_neighbors=1, weights='distance',metric='euclidean')
knnpounded3 = KNeighborsClassifier(n_neighbors=3, weights='distance', metric='euclidean')
knnpounded5 = KNeighborsClassifier(n_neighbors=5, weights='distance', metric='euclidean')
naive = GaussianNB()
tree = DecisionTreeClassifier()
svmlinear = SVC(kernel='linear')  # ESCOLHENDO OS KERNELS DA SVM
svmrbf = SVC(kernel='rbf', gamma='scale')
logRegre = LogisticRegression(solver='lbfgs')
neuralnetwork = MLPClassifier()

knn1array = []  # INSTANCIANDO OS ARRAYS QUE IRAO ARMAZENAR AS MEDIAS DE ACERTO/ACURACIA DE CADA PREDIÇÃO
knn3array = []
knn5array = []
naivearray = []
treearray = []
knnpounded1array = []
knnpounded3array = []
knnpounded5array = []
svmlineararray = []
svmrbfarray = []
logRegrearray = []
nnarray = []

knn1time = []  # INSTANCIANDO OS ARRAYS QUE IRAO ARMAZENAR AS MEDIAS DE ACERTO/ACURACIA DE CADA PREDIÇÃO
knn3time = []
knn5time = []
naivetime = []
treetime = []
knnpounded1time = []
knnpounded3time = []
knnpounded5time = []
svmlineartime = []
svmrbftime = []
logRegretime = []
nntime = []

tempoinicial = time.time()
for x in range(0, 5):  # FOR QUE VAI REALIZAR O KFOLD DE 10 5 VEZES

    tempo1 = time.time()
    cols = list(dataFrame.columns)
    cols.remove('Classe')
    df_images_noclass = dataFrame[cols]  # SEPARANDO EM DOIS DATAFRAMES UM COM A CLASSE E OUTRO SEM
    df_images_class = dataFrame['Classe']
    c = kfold.split(dataFrame)  # REALIZANDO O KFOLD DO MEU DATAFRAME NORMALIZADO

    for train_index, test_index in c:
        # ARMAZENANDO OS DADOS DE TREINO E TEST EM NOVOS DATAFRAMES
        noclass_train, noclass_test = df_images_noclass.iloc[train_index], df_images_noclass.iloc[test_index]
        class_train, class_test = df_images_class.iloc[train_index], df_images_class.iloc[test_index]

        knn1start = time.time()
        knn1.fit(noclass_train, class_train)
        knn1array.append(knn1.score(noclass_test, class_test))
        knn1end = time.time()
        knn1time.append(knn1end - knn1start)

        knn3start = time.time()
        knn3.fit(noclass_train, class_train)
        knn3array.append(knn3.score(noclass_test, class_test))
        knn3end = time.time()
        knn3time.append(knn3end - knn3start)

        knn5start = time.time()
        knn5.fit(noclass_train, class_train)
        knn5array.append(knn5.score(noclass_test, class_test))
        knn5end = time.time()
        knn5time.append(knn5end - knn5start)

        naivestart = time.time()
        naive.fit(noclass_train, class_train)
        naivearray.append(naive.score(noclass_test, class_test))
        naiveend = time.time()
        naivetime.append(naiveend - naivestart)

        treestart = time.time()
        tree.fit(noclass_train, class_train)
        treearray.append(tree.score(noclass_test, class_test))
        treeend = time.time()
        treetime.append(treeend - treestart)

        wknn1start = time.time()
        knnpounded1.fit(noclass_train, class_train)
        knnpounded1array.append(knnpounded1.score(noclass_test, class_test))
        wknn1end = time.time()
        knnpounded1time.append(wknn1end - wknn1start)

        wknn3start = time.time()
        knnpounded3.fit(noclass_train, class_train)
        knnpounded3array.append(knnpounded3.score(noclass_test, class_test))
        wknn3end = time.time()
        knnpounded3time.append(wknn3end - wknn3start)

        wknn5start = time.time()
        knnpounded5.fit(noclass_train, class_train)
        knnpounded5array.append(knnpounded5.score(noclass_test, class_test))
        wknn5end = time.time()
        knnpounded5time.append(wknn5end - wknn5start)

        svmlinearstart = time.time()
        svmlinear.fit(noclass_train, class_train)
        svmlineararray.append(svmlinear.score(noclass_test, class_test))
        svmlinearend = time.time()
        svmlineartime.append(svmlinearend - svmlinearstart)

        svmrbfstart = time.time()
        svmrbf.fit(noclass_train, class_train)
        svmrbfarray.append(svmrbf.score(noclass_test, class_test))
        svmrbfend = time.time()
        svmrbftime.append(svmrbfend - svmrbfstart)

        logRegrestart = time.time()
        logRegre.fit(noclass_train, class_train)
        logRegrearray.append(logRegre.score(noclass_test, class_test))
        logRegreend = time.time()
        logRegretime.append(logRegreend - logRegrestart)

        nnstart = time.time()
        neuralnetwork.fit(noclass_train, class_train)
        nnarray.append(neuralnetwork.score(noclass_test, class_test))
        nnend = time.time()
        nntime.append(nnend - nnstart)

    dataFrame = dataFrame.sample(
        frac=1)  # FUNÇÃO QUE FAZ O SHUFFLE DO DATAFRAME PARA O PROXIMO K FOLD PEGAR VALORES DIFERENTES
    print("Terminou a ", x)
    tempo2 = time.time()
    print("Tempo da rodada ", x, (tempo2 - tempo1) / 60)

tempofinal = time.time()

mediaknn1 = np.mean(knn1array)  # FUNÇÕES QUE FAZEM A MEDIA, MODA E MEDIANA DO KNN DE K 1 K3 E K5
medianaknn1 = np.median(knn1array)
stdknn1 = np.std(knn1array)
timeknn1 = np.mean(knn1time)
mediaknn3 = np.mean(knn3array)  # MEDIA
medianaknn3 = np.median(knn3array)  # MEDIANA
stdknn3 = np.std(knn3array)
timeknn3 = np.mean(knn3time)
mediaknn5 = np.mean(knn5array)
medianaknn5 = np.median(knn5array)
stdknn5 = np.std(knn5array)
timeknn5 = np.mean(knn5time)

print("-------------- KNN ---------------")  # PRINT DOS DADOS PARA FICAR VISIVEL
print("Media:\nK = 1: ", mediaknn1, " K = 3: ", mediaknn3, " K = 5: ", mediaknn5)
print("Mediana:\nK = 1: ", medianaknn1, " K = 3: ", medianaknn3, " K = 5: ", medianaknn5)
print("Desvio Padrão:\nK = 1: ", stdknn1, " K = 3: ", stdknn3, " K = 5: ", stdknn5)
print("Tempo médio:\nK = 1: ", timeknn1, " K = 3: ", timeknn3, " K = 5: ", timeknn5)

mediaknnpounded1 = np.mean(knnpounded1array)  # FUNÇÕES QUE REALIZAM MEDIA MODA E MEDIANA DO KNN PONDERADO
medianaknnpounded1 = np.median(knnpounded1array)
stdknnpounded1 = np.std(knnpounded1array)
timewknn1 = np.mean(knnpounded1time)
mediaknnpounded3 = np.mean(knnpounded3array)
medianaknnpounded3 = np.median(knnpounded3array)
stdknnpounded3 = np.std(knnpounded3array)
timewknn3 = np.mean(knnpounded3time)
mediaknnpounded5 = np.mean(knnpounded5array)
medianaknnpounded5 = np.median(knnpounded5array)
stdknnpounded5 = np.std(knnpounded5array)
timewknn5 = np.mean(knnpounded5time)

print("\n\n-------------- KNN PONDERADO---------------")
print("Media:\nK = 1: ", mediaknnpounded1, " K = 3: ", mediaknnpounded3, " K = 5: ", mediaknnpounded5)
print("Mediana:\nK = 1: ", medianaknnpounded1, " K = 3: ", medianaknnpounded3, " K = 5: ", medianaknnpounded5)
print("Desvio padrão:\nK = 1: ", stdknnpounded1, " K = 3: ", stdknnpounded3, " K = 5: ", stdknnpounded5)
print("Tempo médio:\nK = 1: ", timewknn1, " K = 3: ", timewknn3, " K = 5: ", timewknn5)

medianaive = np.mean(naivearray)  # FUNÇÕES QUE REALIZAM MEDIA MODA E MEDIANA DO NAIVE BAYES
mediananaive = np.median(naivearray)
stdnaive = np.std(naivearray)
timenaive = np.mean(naivetime)

print("\n\n-------------- NAIVE BAYES ---------------")
print("Media: ", medianaive)
print("Mediana: ", mediananaive)
print("Desvio padrão: ", stdnaive)
print("Tempo médio: ", timenaive)

mediatree = np.mean(treearray)  # FUNÇÕES QUE REALIZAM A MEDIA MODA E MEDIANA DA ARVORE DE DECISAO
medianatree = np.median(treearray)
stdtree = np.std(treearray)
timetree = np.mean(treetime)

print("\n\n-------------- DECISION TREE ---------------")
print("Media: ", mediatree)
print("Mediana: ", medianatree)
print("Desvio padrão: ", stdtree)
print("Tempo médio: ", timetree)

mediasvmlinear = np.mean(svmlineararray)  # FUNÇÕES QUE REALIZAM A MODA MEDIA E MEDIANA DA SVM LINEAR
medianasvmlinear = np.median(svmlineararray)
stdsvmlinear = np.std(svmlineararray)
timesvmlinear = np.mean(svmlineartime)

print("\n\n-------------- SVM LINEAR ---------------")
print("Media: ", mediasvmlinear)
print("Mediana: ", medianasvmlinear)
print("Desvio padrão: ", stdsvmlinear)
print("Tempo médio: ", timesvmlinear)

mediasvmrbf = np.mean(svmrbfarray)  # FUNÇÕES QUE REALIZAM A MODA MEDIA E MEDIANA DA SVM RBF
medianasvmrbf = np.median(svmrbfarray)
stdsvmrbf = np.std(svmrbfarray)
timesvmrbf = np.mean(svmrbftime)

print("\n\n-------------- SVM RBF ---------------")
print("Media: ", mediasvmrbf)
print("Mediana: ", medianasvmrbf)
print("Desvio padrão: ", stdsvmrbf)
print("Tempo médio: ", timesvmrbf)

medialogregre = np.mean(logRegrearray)
medianalogregre = np.median(logRegrearray)
stdlogregre = np.std(logRegrearray)
timelogregre = np.mean(logRegretime)

print("\n\n-------------- REGRESSAO LOGISTICA ---------------")
print("Media: ", medialogregre)
print("Mediana: ", medianalogregre)
print("Desvio padrão: ", stdlogregre)
print("Tempo médio: ", timelogregre)

mediann = np.mean(nnarray)
medianann = np.median(nnarray)
stdnn = np.std(nnarray)
timenn = np.median(nntime)

print("\n\n-------------- MLP ---------------")
print("Media: ", mediann)
print("Mediana: ", medianann)
print("Desvio padrão: ", stdnn)
print("Tempo médio: ", timenn)

mediasacuracias = {  # CRIANDO UM DICIONARIO QUE VAI TER AS MEDIAS DE CADA ALGORITMO

    "KNN K = 1": mediaknn1,
    "KNN K = 3": mediaknn3,
    "KNN K = 5": mediaknn5,
    "KNN PONDERADO K = 1": mediaknnpounded1,
    "KNN PONDERADO K = 3": mediaknnpounded3,
    "KNN PONDERADO K = 5": mediaknnpounded5,
    "NAIVE BAYES": medianaive,
    "DECISION TREE": mediatree,
    "SVM LINEAR": mediasvmlinear,
    "SVM RBF": mediasvmrbf,
    "REGRESSAO LOGISTICA": medialogregre,
    "MLP": mediann
}

mediasacuracias = sorted(mediasacuracias.items(),
                         key=lambda x: x[1])  # ORDENANDO EM ORDEM CRESCENTE PARA SABER OS MELHORES
print(mediasacuracias)  # PRINTANDO A ORDEM CRESCENTE DOS DADOS
print("Tempo total: ", (tempofinal - tempoinicial) / 60)

stat, p = friedmanchisquare(knn1array, knn3array, knn5array, knnpounded1array, knnpounded3array,
                            knnpounded5array, naivearray, treearray, svmlineararray, svmrbfarray, logRegrearray,
                            nnarray)

print("Friendman:")
print("Stat = ", stat, "P = ", p)

stat, p = kruskal(knn1array, knn3array, knn5array, knnpounded1array, knnpounded3array,
                  knnpounded5array, naivearray, treearray, svmlineararray, svmrbfarray, logRegrearray, nnarray)

print("Kruskal: ")
print("Stat = ", stat, "P = ", p)