def gustavo_method(self, x_train, y_train, X_test, Y_test, dsel): neigh = KNeighborsClassifier(n_neighbors=self.kNeighbors) neigh.fit(self.x[dsel], self.y[dsel]) pool_classifiers = BaggingClassifier(linear_model.Perceptron(max_iter=5), self.pool_size) pool_classifiers.fit(x_train, y_train) knorau = KNORAU(pool_classifiers) knorau.fit(x_train[dsel], y_train[dsel]) knn = KNeighborsClassifier(n_neighbors=5) knn.fit(x_train, y_train) score = [] for i in range(len(Y_test)): kdn = sum(self.y[neigh.kneighbors([self.x[dsel]], return_distance=False)[0]]!=self.y[i])/self.kNeighbors if (kdn > self.threshold): score.append(knorau.predict(self.x[i])) else: score.append(knn.predict(self.x[i])) return (score, ) + self.calc_metrics(X_test, Y_test) # dependendo da base formato nao suportado
class Arquitetura: def __init__(self, n_vizinhos): ''' :n_vizinhos: quantidade de vizinhos mais proximos que serao utilizados para regiao de competencia ''' self.n_vizinhos = n_vizinhos def kDN(self, x, y): ''' Metodo para computar o grau de dificuldade de cada observacao em um conjunto de dados :param: x: padroes dos dados :param: y: respectivos rotulos :return: dificuldades: vetor com a probabilidade de cada instancia ''' # instanciando os vizinhos mais proximos nbrs = NearestNeighbors(n_neighbors=self.n_vizinhos + 1, algorithm='ball_tree').fit(x) # variavel para salvar as probabilidades dificuldades = [] # for para cada instancia do dataset for i in range(len(x)): # computando os vizinhos mais proximos para cada instancia _, indices = nbrs.kneighbors([x[i]]) # verificando o rotulo dos vizinhos cont = 0 for j in indices[0]: if (j != i and y[j] != y[i]): cont += 1 # computando a porcentagem dificuldades.append(cont / (self.n_vizinhos + 1)) return dificuldades def neighbors(self, dsel, x_query): ''' metodo para retornar apenas os indices dos vizinhos ''' # instanciando os vizinhos mais proximos nbrs = NearestNeighbors(n_neighbors=self.n_vizinhos + 1, algorithm='ball_tree').fit(dsel) # computando os vizinhos mais proximos para cada instancia _, indices = nbrs.kneighbors([x_query]) return indices def hardInstances(self, x, y, limiar): ''' Metodo para retornar um subconjunto de validacao apenas com as instacias faceis :param: x: padroes dos dados :param: y: respectivos rotulos :return: x_new, y_new: ''' # computando as dificulades para cada instancia dificuldades = self.kDN(x, y) # variaveis para salvar as novas instancias x_new = [] y_new = [] # salvando apenas as instancias faceis for i in range(len(dificuldades)): if (dificuldades[i] > limiar): x_new.append(x[i]) y_new.append(y[i]) return np.asarray(x_new), np.asarray(y_new) def neighborhoodDifficulty(self, dsel, x_query, H): ''' metodo para calcular o grau de dificuldade da vizinhanca :dsel: dataset para pesquisar os vizinhos :x_query: instancia a ser pesquisada :H: dificuldade do dataset dsel ''' # obtendo a vizinhanca do exemplo indices = self.neighbors(dsel, x_query)[0] # dificuldade da regiao dificuldades = [H[i] for i in indices] # media da dificuldadde da regiao return np.min(dificuldades) def defineThreshold(self, indices): ''' Metodo para definir o threshold :indices: os indices das instancias que foram classificadas incorretamente ''' # obtendo a vizinhanca do exemplo lista = [] for i in indices: lista.append( self.neighborhoodDifficulty(self.x_train, self.x_train[i], self.H)) return np.mean(lista) def fit(self, x, y): ''' metodo para treinar a arquitetura de dois niveis :x: dados para treinamento :y: rotulo dos dados :dsel_x: padroes da janela de validacao :dsel_y: rotulos da janela de validacao ''' # salvando os dados de trainamento self.x_train = x self.y_train = y # salvando as dificuldades das instancias self.H = self.kDN(x, y) # treinando o nivel 1 ######################################### self.levelone = KNeighborsClassifier(self.n_vizinhos) self.levelone.fit(x, y) # realizando a previsao para o conjunto de treinamento y_pred = self.levelone.predict(x) # salvando os indices das instancias que foram classificadas erradas indices = [i for i in range(len(y)) if y_pred[i] != y[i]] # obtendo o limiar de dificuldade do problema self.limiar = self.defineThreshold(indices) ############################################################### # treinando o nivel 2 ######################################### # obtendo as instancias dificeis x_dificeis, y_dificeis = self.hardInstances(x, y, self.limiar) # criando o ensemble self.ensemble = BaggingClassifier(base_estimator=Perceptron(), max_samples=0.9, max_features=1.0, n_estimators=100) self.ensemble.fit(x_dificeis, y_dificeis) # treinando o modelo 2 self.leveltwo = KNORAU(self.ensemble.estimators_, self.n_vizinhos) self.leveltwo.fit(x_dificeis, y_dificeis) # verificando se o ola acerta os exemplos errados pelo svm ############################################################### def predict_svm(self, x): # to predict multiple examples if (len(x.shape) > 1): # returning all labels return [ self.levelone.predict(np.array([pattern]))[0] for pattern in x ] # to predict only one example else: return self.levelone.predict(np.array([x]))[0] def predict_ola(self, x): # to predict multiple examples if (len(x.shape) > 1): # returning all labels return [ self.leveltwo.predict(np.array([pattern]))[0] for pattern in x ] # to predict only one example else: return self.leveltwo.predict(np.array([x]))[0] def predict_one(self, x): ''' metodo para computar a previsao de um exemplo :x: padrao a ser predito ''' # media da dificuldadde da regiao media = self.neighborhoodDifficulty(self.x_train, x, self.H) # verificando a dificuldade da instancia if (media >= self.limiar): return self.leveltwo.predict(np.array([x]))[0] else: return self.levelone.predict(np.array([x]))[0] def predict(self, x): ''' metodo para computar a previsao de um exemplo :x: padrao a ser predito ''' # to predict multiple examples if (len(x.shape) > 1): # returning all labels return [self.predict_one(pattern) for pattern in x] # to predict only one example else: return self.predict_one(x)
y_mdes_pred = meta.predict(X_test) accuracy_mdes = accuracy_score(Y_test, y_mdes_pred) # print('accuracy = ', accuracy_mdes) micro_f1_mdes = f1_score(Y_test - 1, y_mdes_pred - 1, average='micro') # print('micro_f1 =', micro_f1_mdes) # print('support_macro:',precision_recall_fscore_support(Y_test, y_mdes_pred, average='macro')) macro_f1_mdes = f1_score(Y_test - 1, y_mdes_pred - 1, average='macro') # print('macro_f1 =', macro_f1_mdes) # print('micro:', precision_recall_fscore_support(Y_test, y_mdes_pred, average='micro')) test_time_mdes_end = time.time() #---------------------- Test KNU Pharse -------------------------- test_time_knu_start = time.time() y_knu_pred = knu.predict(X_test) accuracy_knu = accuracy_score(Y_test, y_knu_pred) # print('accuracy = ', accuracy_knu) micro_f1_knu = f1_score(Y_test - 1, y_knu_pred - 1, average='micro') # print('micro_f1 =', micro_f1_knu) macro_f1_knu = f1_score(Y_test - 1, y_knu_pred - 1, average='macro') # print('macro_f1 =', macro_f1_knu) test_time_knu_end = time.time() #-------------------------------------- WRITE OUTPUT --------------------------------------------- result_kne = { 'data': file_name, 'n_classes': n_classes, 'train_time': train_time_kne_end - train_time_kne_start,