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,