Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- import pandas as pd
- from numpy import ndarray
- from sklearn import preprocessing
- from sklearn.neighbors import KNeighborsClassifier
- from scipy import stats
- from sklearn.naive_bayes import GaussianNB
- import statistics
- from sklearn.metrics import pairwise_distances_argmin_min
- import numpy as np
- from random import randint
- import matplotlib.pyplot as plt
- import cv2
- from sklearn.decomposition import PCA
- import glob
- from sklearn.metrics import pairwise_distances_argmin_min
- from sklearn.ensemble import RandomForestClassifier
- from sklearn.metrics import accuracy_score
- from operator import itemgetter
- import math
- import os
- # 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 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 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 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
- def geneticlabels(dataframe,centers):
- return pairwise_distances_argmin_min(dataframe,centers,metric='minkowski')
- 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 accuracy_majority_vote(base, predict_labels, real_labels, n_clusters):
- classes = real_labels.unique()
- majority = []
- groups = []
- k = 0
- for i in range(n_clusters):
- group = []
- for a in range(len(base)):
- if predict_labels[a] == i:
- group.append(real_labels[a])
- groups.append(group)
- majority.append(initialize_dic_majority(classes))
- for real_label in group:
- majority[k][real_label] += 1
- k += 1
- label_groups = []
- for m in majority:
- label_groups.append(max(m.items(), key=itemgetter(1))[0])
- pred_labels = []
- true_labels = []
- for g in range(len(groups)):
- pred_labels = pred_labels + ([label_groups[g]]*len(groups[g]))
- true_labels = true_labels + [a for a in groups[g]]
- return accuracy_score(pred_labels, true_labels)
- 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
- def WCSSgenetic(x, population):
- arrayint = []
- for a in x:
- arrayint.append(int(a))
- print(arrayint)
- soma = 0
- for b in arrayint:
- labels, distances = pairwise_distances_argmin_min(population[b],population, metric='minkowski')
- for x in distances:
- soma += x**2
- return soma
- def generatepopulation(X,numberpopu, K, rng):
- population = []
- for x in range(numberpopu):
- first = rng.permutation(X.shape[0])[:K]
- print(first)
- population.append(np.concatenate(X[first]))
- return population
- 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
- #FUNÇÃO DE NORMALIZAÇÃO
- def imgtoarray(arrayphotos):
- size = len(arrayphotos)
- for x in range (0,size):
- arrayphotos[x] = np.array(arrayphotos[x] , dtype=float)
- return arrayphotos
- def gethumoments(arrayphotos):
- for x in range(len(arrayphotos)):
- arrayphotos[x] = cv2.HuMoments(cv2.moments(arrayphotos[x]), True).flatten()
- return arrayphotos
- def WCSS2(distance):
- soma = 0
- for x in distance:
- soma += x ** 2
- return soma
- def initialize_dic_majority(classes):
- majority = {}
- for c in classes:
- majority[c] = 0
- return majority
- def extratorCaracteristicas(arrayimgs):
- squarescarac = []
- for x in arrayimgs:
- aux = []
- im2, countours, hierachy = cv2.findContours(x, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
- if len(countours) == 0:
- for b in range(0,45):
- aux.append(0)
- elif len(countours) > 0:
- momentum = cv2.moments(x)
- momentum = list(dict.values(momentum)) # momentos
- for i in momentum:
- aux.append(i)
- moments = cv2.HuMoments(momentum, True).flatten() # Hu moments
- for i in moments:
- aux.append(i)
- area = cv2.contourArea(countours[0]) # area
- aux.append(area)
- peri = cv2.arcLength(countours[0], True) # perimetro
- aux.append(peri)
- if peri > 0:
- compactness = (4 * math.pi * area) / (peri ** 2) # compacidade
- aux.append(compactness)
- elif peri == 0:
- aux.append(0)
- aproxx = cv2.approxPolyDP(countours[0], 0.04 * peri, True) # vertices
- vertc = len(aproxx)
- aux.append(vertc)
- histogram = get_histogram(aproxx) # Frequencia de angulos
- for h in histogram:
- aux.append(h)
- squarescarac.append(aux)
- return squarescarac
- def niveisCinza(image):
- gray = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
- return gray
- def filtroGaussiano(image):
- gaussianb = cv2.GaussianBlur(image,(5,5),0)
- return gaussianb
- def turnToBinary(image):
- binary = cv2.adaptiveThreshold(image,255,cv2.ADAPTIVE_THRESH_MEAN_C,cv2.THRESH_BINARY,31,10)
- return binary
- def inverterCores(image):
- invert = cv2.bitwise_not(image)
- return invert
- def resizeImages(images,width,height):
- i = len(images)
- for x in range(0,i):
- images[x] = cv2.resize(images[x],(width,height))
- return images
- def angle3pt(a, b, c):
- """Counterclockwise angle in degrees by turning from a to c around b
- Returns a float between 0.0 and 360.0"""
- ang = math.degrees(
- math.atan2(c[1] - b[1], c[0] - b[0]) - math.atan2(a[1] - b[1], a[0] - b[0]))
- return ang + 360 if ang < 0 else ang
- def get_vertices(imagem):
- im2, countours, hierachy = cv2.findContours(imagem, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
- peri = cv2.arcLength(countours[0], True) # perimetro
- aproxx = cv2.approxPolyDP(countours[0], 0.04 * peri, True) # vertices
- return aproxx
- def get_angle(p0, p1, p2):
- v0 = np.array(p0) - np.array(p1)
- v1 = np.array(p2) - np.array(p1)
- angle = np.math.atan2(np.linalg.det([v0, v1]), np.dot(v0, v1))
- return np.degrees(angle)
- def get_histogram(aproxx):
- zero = []
- zero.append(0)
- zero.append(0)
- zero.append(0)
- zero.append(0)
- zero.append(0)
- zero.append(0)
- zero.append(0)
- zero.append(0)
- zero.append(0)
- zero.append(0)
- zero.append(0)
- #transformando em um array bidimensional
- retornopollyDP = np.reshape(aproxx, (aproxx.shape[0], (aproxx.shape[1] * aproxx.shape[2])))
- #checando se não é uma linha
- if (len(retornopollyDP) < 3):
- return zero
- arraysdeangulo = []
- for x in range(len(retornopollyDP)):
- # caso especial : quando a primeira posição do array for o angulo central
- if x == 0:
- bla3 = get_angle(retornopollyDP[x + 1], retornopollyDP[x], retornopollyDP[len(retornopollyDP) - 1])
- arraysdeangulo.append(math.fabs(bla3))
- # caso especial : quando a última posição do array for o ângulo central
- if x == len(retornopollyDP) - 1:
- bla4 = get_angle(retornopollyDP[x - 1], retornopollyDP[x], retornopollyDP[0])
- arraysdeangulo.append(math.fabs(bla4))
- if x > 0 and x < len(retornopollyDP) - 1:
- bla5 = get_angle(retornopollyDP[x + 1], retornopollyDP[x], retornopollyDP[x - 1])
- arraysdeangulo.append(math.fabs(bla5))
- hist, bins = np.histogram(arraysdeangulo, bins=[15, 30, 45, 60, 75, 90, 105, 120, 135, 150, 165, 180])
- return hist
- # 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édia = ', np.mean(vetorTempo))
- print('Tempo Desvio padrão = ', statistics.pstdev(vetorTempo))
- print('Tempo Moda = ', stats.mode(vetorTempo, axis=None))
- print('Tempo Mediana =', np.median(vetorTempo))
- print('----------------------------------------------')
- print('Acurácia Média = ', np.mean(vetorAcerto))
- print('Acurácia Desvio padrão = ', statistics.pstdev(vetorAcerto))
- print('Acurácia Moda = ', stats.mode(vetorAcerto, axis=None))
- print('Acurácia Mediana = ', np.median(vetorAcerto))
- print('________________________________________________\n')
- # funcão que seleciona num quantidade de imagens aleatoriamente
- # em um vetor e retorna um vetor auxiliar apenas com as imagens
- # selecionadas
- def seleciona_imagens (arrayImgs, num):
- tamanho = len(arrayImgs)
- selecionadas = []
- nao_selecionadas = []
- aux = []
- var = 0
- for x in range(0, num):
- if x == 0:
- var = randint(0, tamanho - 1)
- aux.append(var)
- selecionadas.append(arrayImgs[var])
- elif x > 0:
- var = randint(0, tamanho - 1)
- while np.isin(var ,aux):
- var = randint(0, tamanho - 1)
- selecionadas.append(arrayImgs[var])
- aux.append(var)
- for x in range(0, tamanho):
- if np.isin(x,aux):
- continue
- else:
- nao_selecionadas.append(arrayImgs[x])
- return selecionadas, nao_selecionadas
- def is_similar(image1, image2):
- retorno = image1.shape == image2.shape and not(np.bitwise_xor(image1,image2).any())
- return retorno
- def create_folder(path):
- x = 0
- try:
- os.mkdir(path)
- except OSError:
- x = -1
- else:
- x = 1
- return x
- def save_images(images, path):
- cont = 0
- for i in images:
- y = str(cont)
- cv2.imwrite(path + y + '.jpg', i)
- cont += 1
- return 0
- # checa se o elemento escolhido já existe no array aux para
- # evitar elementos duplicados
- # var = randint(0, tamanho)
- #
- # for i in range(0, len(aux)):
- # if is_similar(arrayImgs[var], aux[i]):
- # duplicate = 1
- #
- # while duplicate == 1:
- def delete_folder (path):
- x = 0
- try:
- os.rmdir(path)
- except OSError:
- x = -1
- else:
- x = 1
- return x
- # função que retorna população de cromossomos e tem como parametros
- # tamanho da população (número de cromossomos) e tamanho dos cromossomos
- def create_population(size_population, size_chromossome):
- population = []
- for y in range(0, size_population):
- aux = []
- for i in range(0, size_chromossome):
- x = randint(0, 200)
- if x % 2 == 0:
- aux.append(0)
- elif x % 2 != 0:
- aux.append(1)
- population.append(aux)
- return population
- # função que identifica o tamanho do cromossomo e retorna o vetor de características correspondente
- def decode_chromossome(chromossome):
- images = []
- images_class = []
- if chromossome[0] == 0 and chromossome[1] == 0:
- images = pd.read_csv('C:/Users/Auricelia/Desktop/DataSetsML/Images_16_s_NOCLASS.csv')
- images = pd.DataFrame(images)
- images_class = pd.read_csv('C:/Users/Auricelia/Desktop/DataSetsML/Images_16_s.csv')
- images_class = pd.DataFrame(images_class)
- elif chromossome[0] == 0 and chromossome[1] == 1:
- images = pd.read_csv('C:/Users/Auricelia/Desktop/DataSetsML/Images_32_sNOCLASS.csv')
- images = pd.DataFrame(images)
- images_class = pd.read_csv('C:/Users/Auricelia/Desktop/DataSetsML/Images_32_s.csv')
- images_class = pd.DataFrame(images_class)
- elif chromossome[0] == 1 and chromossome[1] == 0:
- images = pd.read_csv('C:/Users/Auricelia/Desktop/DataSetsML/Images_64_sNOCLASS.csv')
- images = pd.DataFrame(images)
- images_class = pd.read_csv('C:/Users/Auricelia/Desktop/DataSetsML/Images_64_s.csv')
- images_class = pd.DataFrame(images_class)
- elif chromossome[0] == 1 and chromossome[1] == 1:
- images = pd.read_csv('C:/Users/Auricelia/Desktop/DataSetsML/Images_128_sNOCLASS.csv')
- images = pd.DataFrame(images)
- images_class = pd.read_csv('C:/Users/Auricelia/Desktop/DataSetsML/Images_128_s.csv')
- images_class = pd.DataFrame(images_class)
- return images, images_class
- #fucção que retorna as posições do array que
- #são usadas pelo cromossomo para a classificação
- def positions_chromossome(chromossome):
- selected_pos = []
- for c in range(2,len(chromossome)):
- aux = []
- if chromossome[c] == 1:
- selected_pos.append(c)
- elif chromossome[c] == 0:
- continue
- return selected_pos
- # função que retorna o array com características selecionadas
- # pelo cromossomo passando as posicoes selecionadas
- # e o vetor com as características
- def caracteristicas_2(selected_pos,images):
- arrayzao = []
- for x in images:
- aux = []
- for y in selected_pos:
- aux.append(x[y-1])
- arrayzao.append(aux)
- return arrayzao
- def carac_imagens(selected_position,array_images):
- arrayzao = []
- z = 0
- for j in range(0,len(array_images)):
- aux = []
- for i in range(0,len(selected_position)):
- z = selected_position[i]
- aux.append(array_images[j][z])
- arrayzao.append(aux)
- return arrayzao
- # funcao que retorna o array de acurácias dos cromossomos
- def fitness(cromossomos):
- acuracias = []
- for cromo in cromossomos:
- positions = positions_chromossome(cromo)
- imagens = decode_chromossome(cromo)
- imagens = np.array(imagens)
- caracteristicas = carac_imagens(positions,imagens)
- return 0
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement