Funcoes ML update

import pandas as pd
import cv2
from sklearn import preprocessing
from sklearn.neighbors import KNeighborsClassifier
from scipy import stats
from sklearn.naive_bayes import GaussianNB
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
import statistics
from sklearn.metrics import pairwise_distances_argmin_min
import numpy as np
from random import randint
import glob


# função que calcula a quantidade de elementos por classe
# a partir do data frame original, o nome da classe e a classificação

def quantidade_por_classe (dados, nome_classe, classe):
    cont = 0
    for x in range(len(dados.index)):
        if (dados[nome_classe].iloc[x] == classe):
            cont += 1
    return cont
# função de inicialização do algoritmo KNN , recebe o k
# e a distância que vai ser usada como referência

def inicializacao_KNN (k):

    knn = KNeighborsClassifier(n_neighbors=k, metric='euclidean')
    return knn


# função de normalização dos dados usando o modelo de
# normalização por reescala

def normalizar(dados):
    x = dados.values
    min_max_scaler = preprocessing.MinMaxScaler()
    x_scaled = min_max_scaler.fit_transform(x)
    dados_norm = pd.DataFrame(x_scaled)
    return dados_norm

# função que calcula os valores de média, moda , mediana e desvio padrão
# para os vetores de acerto de um algoritmo, recebe como parâmetro o vetor
# de acerto e o nome do algoritmo

def tendencia_central (nomeAlgoritmo, vetorAcerto, vetorTempo):
    print('________________________________________________\n')
    print(nomeAlgoritmo)
    print('Tempo médio = ', np.mean(vetorTempo))
    print('Média = ', np.mean(vetorAcerto))
    print('Mediana = ', np.median(vetorAcerto))
    print('Moda = ', stats.mode(vetorAcerto, axis=None))
    print('Desvio padrão = ', statistics.pstdev(vetorAcerto))
    print('________________________________________________\n')

# função que cria amostras estratificadas a partir
# dos Data frame, o tamanho desejado para a amostra
# e a classe dos dados

def amostra_estrat(dados, tamanho_amostra, classe):
    classes = dados[classe].unique()
    qtde_por_classe = round(tamanho_amostra / len(classes))
    amostras_por_classe = []
    for c in classes:
        indices_c = dados[classe] == c
        obs_c = dados[indices_c]
        amostra_c = obs_c.sample(qtde_por_classe)
        amostras_por_classe.append(amostra_c)

    amostra_estratificada = pd.concat(amostras_por_classe)
    return amostra_estratificada

# função que realiza o treinamento dos algoritmos usados na base de dados

def treinaralgoritmos(noclass_train, class_train , tree, knnp1 , knnp2 , knnp3, knn1 , knn2 , knn3, naive, svmlinear , svmrbf):

    knn1.fit(noclass_train, class_train)
    knn2.fit(noclass_train, class_train)
    knn3.fit(noclass_train, class_train)
    naive.fit(noclass_train, class_train)
    tree.fit(noclass_train, class_train)
    knnp1.fit(noclass_train, class_train)
    knnp2.fit(noclass_train, class_train)
    knnp3.fit(noclass_train, class_train)
    svmlinear.fit(noclass_train, class_train)
    svmrbf.fit(noclass_train, class_train)

# função de inicialização do algoritmo KNN Ponderado
# recebe como parâmentro o valor do k

def inicializando_KNNW (k):

    knnp = KNeighborsClassifier(n_neighbors=k, weights='distance', metric='euclidean')
    return knnp


def find_clusters(X, n_clusters, rng, max_it):

    i = rng.permutation(X.shape[0])[:n_clusters]
    centers = X[i]

    max_iterator = 0
    distances = []
    while True:

        labels,distance = pairwise_distances_argmin_min(X,centers,metric='minkowski')
        distances.append(distance)

        new_centers = np.array([X[labels == i].mean(0)
                                for i in range(n_clusters)])


        if np.all(centers == new_centers) or max_iterator > max_it:
            break
        centers = new_centers
        max_iterator += 1

    return centers, labels, distances


def find_clustersGENETIC(X, n_clusters, max_it, array):

    centers = array

    max_iterator = 0
    distances = []
    while True:

        labels,distance = pairwise_distances_argmin_min(X,centers,metric='minkowski')
        distances.append(distance)

        new_centers = np.array([X[labels == i].mean(0)
                                for i in range(n_clusters)])


        if np.all(centers == new_centers) or max_iterator > max_it:
            break
        centers = new_centers
        max_iterator += 1

    return centers, labels, distances

# Carregando fotos da pasta
def loadFiles(path, array):

    for i in glob.glob(path):

        img = cv2.imread(i)
        array.append(img)

    return array

# Função que aplic o filtro blur nas fotos do array
def blurConversion(arrayphotos ,val1, val2):

    for x in range(len(arrayphotos)):
        arrayphotos[x] = cv2.GaussianBlur(arrayphotos[x],(val1,val1), val2)

    return arrayphotos

#Função que faz a binarização das fotos
def binaryConversion(arrayphotos,threshold,val1):

    for x in range(len(arrayphotos)):
        arrayphotos[x] = cv2.adaptiveThreshold(arrayphotos[x],threshold,cv2.ADAPTIVE_THRESH_MEAN_C,cv2.THRESH_BINARY,val1,10)

    return arrayphotos

#Função que inverte as fotos binárias
def invertConversion(arrayphotos):

    for x in range(len(arrayphotos)):
        arrayphotos[x] = cv2.bitwise_not(arrayphotos[x])

    return arrayphotos

# Função que faz o filtro cinza nas fotos
def grayConversion(arrayphotos):

    size = len(arrayphotos)
    for x in range (0,size):
        arrayphotos[x] = cv2.cvtColor(arrayphotos[x], cv2.COLOR_BGR2GRAY)

    return arrayphotos

# Função de extração de características
def extractCarac (imagensVector):
    shapesTotal = []
    for i in imagensVector:
        shape1 = []
        im2, contours, hierarchy = cv2.findContours(i, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)

        perimeter = cv2.arcLength(contours[0], True)

        approx = cv2.approxPolyDP(contours[0], 0.04*perimeter, True)

        # area = cv2.contourArea(contours[0])
        #
        # shape1.append(area)
        shape1.append(perimeter)
        shape1.append(len(approx))

        m = cv2.moments(i)
        cX = int((m['m10']/m['m00']))
        cY = int((m['m01']/m['m00']))

        shape1.append(cX)
        shape1.append(cY)

        moments = cv2.HuMoments(m, True).flatten()

        for x in moments:
            shape1.append(x)

        shapesTotal.append(shape1)

    return shapesTotal