Lista 04 ml update

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 elipses
ellipsis = fun.grayConversion(ellipsis)
ellipsis = fun.blurConversion(ellipsis, 5, 0)
ellipsis = fun.binaryConversion(ellipsis, 255, 31)
ellipsis = fun.invertConversion(ellipsis)

#Imagens de hexágonos
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 retângulos
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)

# Incluindo o nome de cada classe no Dataframe

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)


# Criando o objeto do tipo k-folds com 10 folds
kfold = KFold(10, True, 1)

# Instanciando os algoritmos e seus vetores de tempo e acurácia

# SVM com função de kernel linear
SVMachine_L = SVC(kernel='linear')
SVMachine_L_acerto = []
SVMachine_L_tempo = []

#SVM com função de kernel RBF
SVMachine_RBF = SVC(kernel='rbf', gamma='scale')
SVMachine_RBF_acerto = []
SVMachine_RBF_tempo = []

# KNN com k = 3, 5, 7
KNN_3 = KNeighborsClassifier(n_neighbors=3, metric='euclidean')
KNN_3_acerto = []
KNN_3_tempo = []

KNN_5 = KNeighborsClassifier(n_neighbors=5, metric='euclidean')
KNN_5_acerto = []
KNN_5_tempo = []

KNN_7 =  KNeighborsClassifier(n_neighbors=7, metric='euclidean')
KNN_7_acerto = []
KNN_7_tempo = []

# KNN Ponderado com k = 3, 5, 7
KNNP_3 = KNeighborsClassifier(n_neighbors=3, weights='distance',metric='euclidean')
KNNP_3_acerto = []
KNNP_3_tempo = []

KNNP_5 = KNeighborsClassifier(n_neighbors=5, weights='distance', metric='euclidean')
KNNP_5_acerto = []
KNNP_5_tempo = []

KNNP_7 = KNeighborsClassifier(n_neighbors=7, weights='distance', metric='euclidean')
KNNP_7_acerto = []
KNNP_7_tempo = []

# Naïve Bayes
NaiveBayes = GaussianNB()
NaiveBayes_acerto = []
NaiveBayes_tempo = []

# Árvore de decisão
DecisionTree = DecisionTreeClassifier()
DecisionTree_acerto = []
DecisionTree_tempo = []

# MultiLayer Perceptron
MLP = MLPClassifier()
MLP_acerto = []
MLP_tempo = []

# Regressão Logística
RegrLogistica = LogisticRegression(solver='lbfgs')
RegrLogistica_acerto = []
RegrLogistica_tempo = []


tempoinicial = time.time()

for x in range(0, 5):

    tempo1 = time.time()
    cols = list(dataFrame.columns)
    cols.remove('Classe')
    df_images_noclass = dataFrame[cols]
    df_images_class = dataFrame['Classe']
    c = kfold.split(dataFrame)

    for train_index, test_index in c:

        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]

        KNN3_inicio = time.time()
        KNN_3.fit(noclass_train, class_train)
        KNN_3_acerto.append(KNN_3.score(noclass_test, class_test))
        KNN3_fim = time.time()
        KNN_3_tempo.append(KNN3_fim - KNN3_inicio)

        KNN5_inicio = time.time()
        KNN_5.fit(noclass_train, class_train)
        KNN_5_acerto.append(KNN_5.score(noclass_test, class_test))
        KNN5_fim = time.time()
        KNN_5_tempo.append(KNN5_fim - KNN5_inicio)

        KNN7_inicio = time.time()
        KNN_7.fit(noclass_train, class_train)
        KNN_7_acerto.append(KNN_3.score(noclass_test, class_test))
        KNN7_fim = time.time()
        KNN_7_tempo.append(KNN3_fim - KNN3_inicio)

        KNNP3_inicio = time.time()
        KNNP_3.fit(noclass_train, class_train)
        KNNP_3_acerto.append(KNNP_3.score(noclass_test, class_test))
        KNNP3_fim = time.time()
        KNNP_3_tempo.append(KNNP3_fim - KNNP3_inicio)

        KNNP5_inicio = time.time()
        KNNP_5.fit(noclass_train, class_train)
        KNNP_5_acerto.append(KNNP_5.score(noclass_test, class_test))
        KNNP5_fim = time.time()
        KNNP_5_tempo.append(KNNP5_fim - KNNP5_inicio)

        KNNP7_inicio = time.time()
        KNNP_7.fit(noclass_train, class_train)
        KNNP_7_acerto.append(KNNP_7.score(noclass_test, class_test))
        KNNP7_fim = time.time()
        KNNP_7_tempo.append(KNNP7_fim - KNNP7_inicio)

        NaiveBayes_inicio = time.time()
        NaiveBayes.fit(noclass_train, class_train)
        NaiveBayes_acerto.append(NaiveBayes.score(noclass_test, class_test))
        NaiveBayes_fim = time.time()
        NaiveBayes_tempo.append(NaiveBayes_fim - NaiveBayes_inicio)

        DecisionTree_inicio = time.time()
        DecisionTree.fit(noclass_train, class_train)
        DecisionTree_acerto.append(DecisionTree.score(noclass_test, class_test))
        DecisionTree_fim = time.time()
        DecisionTree_tempo.append(DecisionTree_fim - DecisionTree_inicio)

        SVMachine_L_inicio = time.time()
        SVMachine_L.fit(noclass_train, class_train)
        SVMachine_L_acerto.append(SVMachine_L.score(noclass_test, class_test))
        SVMachine_L_fim = time.time()
        SVMachine_L_tempo.append(SVMachine_L_fim - SVMachine_L_inicio)

        SVMachine_RBF_inicio = time.time()
        SVMachine_RBF.fit(noclass_train, class_train)
        SVMachine_RBF_acerto.append(SVMachine_RBF.score(noclass_test, class_test))
        SVMachine_RBF_fim = time.time()
        SVMachine_RBF_tempo.append(SVMachine_RBF_fim - SVMachine_RBF_inicio)

        RegrLogistica_inicio = time.time()
        RegrLogistica.fit(noclass_train, class_train)
        RegrLogistica_acerto.append(RegrLogistica.score(noclass_test, class_test))
        RegrLogistica_fim = time.time()
        RegrLogistica_tempo.append(RegrLogistica_fim - RegrLogistica_inicio)

        MLP_inicio = time.time()
        MLP.fit(noclass_train, class_train)
        MLP_acerto.append(MLP.score(noclass_test, class_test))
        MLP_fim = time.time()
        MLP_tempo.append(MLP_fim - MLP_inicio)

    dataFrame = dataFrame.sample(frac=1)
    print("Terminou a ", x)
    tempo2 = time.time()
    print("Tempo da rodada ", x, (tempo2 - tempo1) / 60)

tempofinal = time.time()

fun.tendencia_central('KNN k = 3', KNN_3_acerto, KNN_3_tempo)
fun.tendencia_central('KNN k = 5', KNN_5_acerto, KNN_5_tempo)
fun.tendencia_central('KNN k = 7', KNN_7_acerto, KNN_7_tempo)
fun.tendencia_central('KNN Ponderado k = 3', KNNP_3_acerto, KNNP_3_tempo)
fun.tendencia_central('KNN Ponderado k = 5', KNNP_5_acerto, KNNP_5_tempo)
fun.tendencia_central('KNN Ponderado k = 7', KNNP_7_acerto, KNNP_7_tempo)
fun.tendencia_central('Naïve Bayes', NaiveBayes_acerto, NaiveBayes_tempo)
fun.tendencia_central('Árvore de decisão', DecisionTree_acerto, DecisionTree_tempo)
fun.tendencia_central('MLP', MLP_acerto, MLP_tempo)
fun.tendencia_central('Regressão Logística', RegrLogistica_acerto, RegrLogistica_tempo)
fun.tendencia_central('SVM linear', SVMachine_L_acerto, SVMachine_L_tempo)
fun.tendencia_central('SVM RBF', SVMachine_RBF_acerto, SVMachine_RBF_tempo)

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

    "KNN k = 3": np.mean(KNN_3_acerto),
    "KNN k = 5": np.mean(KNN_5_acerto),
    "KNN k = 7": np.mean(KNN_7_acerto),
    "KNN Ponderado k = 3": np.mean(KNNP_3_acerto),
    "KNN Ponderado k = 5": np.mean(KNNP_5_acerto),
    "KNN Ponderado k = 7": np.mean(KNNP_7_acerto),
    "Naive Bayes": np.mean(NaiveBayes_acerto),
    "Decision Tree": np.mean(DecisionTree_acerto),
    "SVM Linear": np.mean(SVMachine_L_acerto),
    "SVM RBF": np.mean(SVMachine_RBF_acerto),
    "Regressao Logistica": np.mean(RegrLogistica_acerto),
    "MLP": np.mean(MLP_acerto)
}

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(KNN_3_acerto, KNN_5_acerto, KNN_7_acerto, KNNP_3_acerto, KNNP_5_acerto, KNNP_7_acerto,
                  NaiveBayes_acerto,DecisionTree_acerto,MLP_acerto,RegrLogistica_acerto,SVMachine_RBF_acerto,
                  SVMachine_L_acerto)

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

stat, p = kruskal(KNN_3_acerto, KNN_5_acerto, KNN_7_acerto, KNNP_3_acerto, KNNP_5_acerto, KNNP_7_acerto,
                  NaiveBayes_acerto,DecisionTree_acerto,MLP_acerto,RegrLogistica_acerto,SVMachine_RBF_acerto,
                  SVMachine_L_acerto)

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