def k_fold(self, k):
"""Calcula a acurácia sobre os erros encontrados em k iterações.
O método de validação cruzada denominado k-fold consiste em dividir o
conjunto total de dados em k subconjuntos mutuamente exclusivos do
mesmo tamanho e, a partir disto, um subconjunto é utilizado para teste
e os k-1 restantes são utilizados para estimação dos parâmetros e
calcula-se a acurácia do modelo.
Atributos:
fold (dict): Variável de chave-valor que armazena as k divisões do
arquivo. Onde chave é o número da divisão, que vai de 1 à k, e
o valor é uma matriz (i por j), o i são as linhas do arquivo e
j é as colunas.
line_qtty (int): Calcula a quantidade total de linhas no arquivo.
hits (dict): Estrutura de dados chave-valor usado para calcular a
quantidade de acertos em cada uma k rodadas.
test_fold (list): Armazena o conjunto de dados, 1/k, usado para a
rodada de teste da vez.
trainning (list): ...
Args:
k (int): Quantidade de sublistas a ser dividido.
No Longer Returned:
"""
self.fold = {}
line_qtty = sum(1 for row in self.data_set)
# print(row_qtty) # colocando com parentesis pra mantes a compatibilidade com outras versoes do python
aux = 1
for index in range(0, line_qtty):
if aux == k + 1:
aux = 1
if str(aux) not in self.fold:
self.fold[str(aux)] = []
self.fold[str(aux)].append(self.data_set[index])
aux += 1
aux = 0
hits = {}
test_fold = None
erro_amostral = []
for index in range(1, 11):
test_fold = self.fold[str(index)]
trainning = []
file_lenght = 0
self.classes = []
for key, sublist in self.fold.iteritems():
if int(key) == index:
continue
else:
for line in sublist:
trainning.append(line)
file_lenght += 1
if line[self.metric_column] not in self.classes:
self.classes.append(line[self.metric_column])
if self.method == 'kNN':
knn_obj = KNN(
self.__get_neighbour_qtd(self.iter_count, file_lenght),
trainning)
elif self.method == 'LVQ':
lvq_obj = LVQ(trainning, self.file_obj.get('classes_qtd'), 1,
self.file_obj.get('attr_qtd'),
self.file_obj.get('skippable') or [],
self.file_obj.get('metric') or -1)
matrix = lvq_obj.train()
for jndex, test in enumerate(test_fold):
if self.method == 'kNN':
knn_obj.find_knn(test,
metric=self.metric_column,
skippable_indexes=self.skippable_indexes)
test_predict = knn_obj.get_prediction()
elif self.method == 'LVQ':
help_obj = KNN(1, matrix)
help_obj.find_knn(test,
metric=self.metric_column,
skippable_indexes=self.skippable_indexes)
test_predict = help_obj.get_prediction()
if str(index) not in hits:
length = len(self.classes)
hits[str(index)] = [[0 for x in range(length)]
for y in range(length)]
else:
predicted_class = self.get_class_int_value(
test_predict['class'])
real_class = self.get_class_int_value(
float(test_fold[jndex][self.metric_column]))
hits[str(index)][real_class][predicted_class] += 1
aux += 1
qtty_test = len(test_fold)
qtty_correct = 0
for i in range(
len(self.classes)
): # sempre a matriz vai ter self.classes x self.classes
# os acertos sao sempre os valores onde os indices da matriz sao iguais
qtty_correct += hits[str(index)][i][i]
# Erro amostral = qnt de erros / pela qnt de instancias de teste
erro_amostral.append(
(qtty_test - qtty_correct) / round(qtty_test, 5))
print(hits)
self.matrix = hits
return erro_amostral # array de erro amostral por fold
for col in range(1, num_cols):
col_values.append(input_sheet.col_values(col)[1:])
x = np.array(col_values, dtype='|S4')
y = x.astype(np.float)
maxs = [max(y[col]) for col in range(0, num_cols - 1)]
mins = [min(y[col]) for col in range(0, num_cols - 1)]
data_points = []
for row in range(1, num_rows):
values = []
for col in range(1, num_cols):
values.append(
(float(input_sheet.cell(row, col).value) - mins[col - 1]) /
(maxs[col - 1] - mins[col - 1]))
d = DataPoint(values, int(output_sheet.cell(row, 0).value))
data_points.append(d)
print(num_rows - 1, " points with dimesion=", num_cols - 1, " are added")
return data_points
data_points = load_data("722.xlsx")
s = SOM(2, 8, 27)
s.load_input_data(data_points)
s.fit(2, 0.1)
v = LVQ(2, 6, 5)
v.load_data(data_points)
v.train(5, 0.01, 2)
s.predict(data_points)
v.predict(data_points)