def cria_matriz_confusao_geral_ensemble():
matrizes = {}
mat_boost = {}
mat_bagging = {}
tipos_voto = ['majority', 'weightedClassifiers']
tipos_erro = [
'nenhum', 'porcentagem', 'proporcao', 'proporcaoDiferenca', 'ativacao',
'porcentagem+ativacao', 'proporcao+ativacao',
'proporcaoDiferenca+ativacao'
]
tipos_intensidade = [
'nenhum', 'porcentagem', 'proporcao', 'proporcaoDiferenca', 'ativacao',
'porcentagem+ativacao', 'proporcao+ativacao',
'proporcaoDiferenca+ativacao'
]
for tipo_voto in tipos_voto:
for tipo_erro in tipos_erro:
if tipo_voto == 'majority' and tipo_erro != 'nenhum':
continue
else:
for tipo_intensidade in tipos_intensidade:
mat_boost[tipo_voto + tipo_erro +
tipo_intensidade] = util.ConfusionMatrix()
mat_bagging[tipo_voto + tipo_erro +
tipo_intensidade] = util.ConfusionMatrix()
matrizes['AdaBoost'] = mat_boost
matrizes['Bagging'] = mat_bagging
return matrizes
def __init__(self,
discriminador,
n_neurons,
bits_endereco,
rank_method,
n_folds,
confusion_matrix_geral,
classificador='wisard',
mapping_igual=False,
selected_features=None):
'''
classifier
label
rank_method
n_neurons
mat_confusao
mat_confusao_folds
selected tam_features
'''
self.param_classificador = classificador
self.param_discriminador = discriminador
self.classificador = cria_classificador(classificador, discriminador)
self.n_neurons = n_neurons
self.bits_endereco = bits_endereco
self.rank_method = rank_method
self.selected_features = selected_features
self.mat_confusao = util.ConfusionMatrix()
self.mat_confusao_geral = confusion_matrix_geral
self.mat_confusao_folds = []
for _ in xrange(n_folds):
self.mat_confusao_folds.append(util.ConfusionMatrix())
self.label = discriminador + " - neuronios= " + str(
n_neurons) + " - endereco= " + str(
bits_endereco
) + " - rank= " + rank_method + " - features= " + str(
selected_features)
self.mapping_igual = mapping_igual #necessario se quiser resetar o mapping estatico a cada fold
if mapping_igual:
if BaseLearner.static_encoder == None:
BaseLearner.static_encoder = BitStringEncoder(self.n_neurons)
self.encoder = BaseLearner.static_encoder
else:
self.encoder = BitStringEncoder(self.n_neurons)
def __init__(self, tipo_voto, n_folds, mat_confusao_geral, tipo_erro,
tipo_intensidade):
self.tipo_voto = tipo_voto
self.tipo_erro = tipo_erro
self.tipo_intensidade = tipo_intensidade
self.mat_confusao_geral = mat_confusao_geral
self.mat_confusao = util.ConfusionMatrix()
self.mat_confusao_folds = []
for _ in xrange(n_folds):
self.mat_confusao_folds.append(util.ConfusionMatrix())
self.combined_votes = None
self.votos = None
self.intensidades = None
self.pesos_learners = None
self.agregador = None
self.label = "Ensemble voting= " + tipo_voto + " tipo_erro= " + str(
self.tipo_erro) + " tipo_intensidade= " + str(
self.tipo_intensidade)
def le_parametros_OLD(arquivo):
configs_single_learners = []
configs_base_learners = []
with open(arquivo) as params:
for line in params:
learner, classificador, discriminador, neuronios, resposta, features = line.split(
',')
features = list(int(x) for x in features[:-1].split('-'))
config = (classificador, discriminador, int(neuronios), resposta,
features, util.ConfusionMatrix())
if learner == "single_learner":
configs_single_learners.append(config)
elif learner == "base_learner":
configs_base_learners.append(config)
return configs_single_learners, configs_base_learners
def inicializa_classificadores(classificadores,
fold_data_dict,
bagging=None,
percent=None):
confusion_mat = {}
times = {}
cv_gen = {}
# Itera em todas as opcoes de classificadores
for classifier, label, rank_method, nmbr_neurons, chave in classificadores:
confusion_mat[chave] = util.ConfusionMatrix()
time_alfa = time.time()
# cv_gen recebe um monte de (classificador, (observacao, classificacao, classe_real))
# aqui ele ja manda a wisard treinar as instancias de treino de cada fold
cv_gen[chave] = wann_xval.cross_validate(fold_data_dict[chave],
classifier, rank_method,
bagging, percent)
times[chave] = (time.time() - time_alfa)
return confusion_mat, times, cv_gen
def inicializa_matrizes_de_confusao(classificador):
confusion_mat = {}
# Itera em todas as opcoes de classificadores
for classifier, label, rank_method, nmbr_neurons, chave in classificador:
confusion_mat[chave] = util.ConfusionMatrix()
return confusion_mat
def main(nmbr_neurons_list=[16], data=None, bagging=None, percent=None):
# escolher parametros
n_folds = 8
nmbr_neurons_list = [8, 10, 16, 20]
bagging = None
percent = 0.5
tipos_classi = 3
features = 13
qnt_class_por_tipo = 4
print "Neuronios: ", nmbr_neurons_list
print "Folds: ", n_folds
print "Bagging: ", bagging
print "Percent: ", percent
# iniciar o vetor de selected features
selected_features = p_prcs.sorteia_features(
qnt_tipos_neuro=len(nmbr_neurons_list),
tipos_classi=tipos_classi,
qnt_por_classi=qnt_class_por_tipo,
total_feat=20,
qnt_feat=features)
# ler os dados
if data is not None:
data = "files/" + data
else:
data = "files/encoded_german.data"
print "DATA: ", data
data_names_dict = p_prcs.le_features(data, selected_features)
# Cria os classificadores
classificadores, _, labels = e_clss.cria_classificadores(
selected_features, nmbr_neurons_list, tipos_classi)
# Cria os folds
_, _, fold_data_dict = prtt.cria_folds(selected_features,
data_names_dict,
nmbr_neurons_list,
n_folds=n_folds)
#pprint.pprint("Fold Data Dict[0]:")
#pprint.pprint(fold_data_dict[str(0)])
'''
fold_data_dict possui:
pra cada classificador
pra cada fold
list features, classe
'''
# Inicializa e treina os classificadores, inicializa as matrizes e os cv_gen
confusion_mat, times, cv_gen = e_clss.inicializa_classificadores(
classificadores, fold_data_dict, bagging, percent)
confusion_mat_ensemble = util.ConfusionMatrix()
confusion_mat_ensemble_com_pesos = util.ConfusionMatrix()
# iterar nos folds
for _ in range(n_folds):
for _, _, _, _, chave in classificadores:
_ = cv_gen[chave].next()
# persistir os votos e scores de cada classificador em cada fold
votos = {}
scores = {}
classes = []
classes_preenchidas = False
# construir matrizes de confusao para os folds (pro ensemble com pesos por performance)
confusion_mat_fold = e_clss.inicializa_matrizes_de_confusao(
classificadores)
pesos_classif = []
# iterar nos classificadores
for _, _, _, _, chave in classificadores:
time_alfa = time.time()
respostas = []
pesos = []
for ax in cv_gen[chave]: # iterar nas instancias
if ax is None:
break
_, answers, clss = ax # ax eh um monte de tuplas (observation, respostaClassificador, respostaReal)
rank = util.ranked(
answers
) # rank recebe varias tuplas ordenadas ('classe', somaRespostasDosDiscriminadores)
# top_score recebe a maior soma dos discriminadores
try:
top_score = len(rank[0][1])
except TypeError:
top_score = rank[0][1]
# coloca na matriz de confusao a resposta e o valor da soma dos discriminadores
confusion_mat[chave].add(clss, rank[0][0], top_score)
confusion_mat_fold[chave].add(
clss, rank[0][0], top_score
) # essa sera usada pro ensemble com peso por performance
respostas.append(rank[0][0])
pesos.append(top_score)
# guardar a classificacao correta
if not classes_preenchidas:
classes.append(clss)
votos[chave] = respostas
scores[chave] = pesos
times[chave] += (time.time() - time_alfa)
classes_preenchidas = True
# definir o peso do classificador = performance
_, acuracia = confusion_mat[chave].stats()[2]
pesos_classif.append(acuracia)
# montar o array com os votos dos classificadores
votos_transposta = []
for i in range(len(classes)): # para cada instancia
row = []
#for j in range(len(chaves_classificadores)): # para cada classificador
for _, _, _, _, chave in classificadores: # Mais correto usar o chave, sempre tentar iterar as coisas com uma mesma ordenacao
row.append(votos[chave][i])
votos_transposta.append(row)
# fazer o ensemble dos classificadores
combinador = compo.VotingAggregator(votos_transposta,
len(votos_transposta),
len(votos_transposta[0]), 2)
combinador.predict()
votos_combinados = combinador.combined_votes
# fazer o ensemble com pesos de acordo com a performance
combinador_com_pesos = compo.VotingAggregator(
votos_transposta,
len(votos_transposta),
len(votos_transposta[0]),
2,
vote='weightedClassifiers',
weights=pesos_classif)
combinador_com_pesos.predict()
votos_combinados_com_pesos = combinador_com_pesos.combined_votes
#print pesos_classif
# avaliar o ensemble sem e com peso
for i in range(len(votos_combinados)):
confusion_mat_ensemble.add(int(classes[i]), votos_combinados[i], 0)
confusion_mat_ensemble_com_pesos.add(int(classes[i]),
votos_combinados_com_pesos[i],
0)
#for i in range(len(confusion_mat)):
for _, _, _, _, chave in classificadores:
print confusion_mat[chave]
print confusion_mat[chave].stats()
print labels[chave], 'time:', times[chave]
print confusion_mat_ensemble
print confusion_mat_ensemble.stats()
print 'Ensemble (majority)'
print confusion_mat_ensemble_com_pesos
print confusion_mat_ensemble_com_pesos.stats()
print 'Ensemble (pesos)'
def le_parametros(arquivo):
with open(arquivo) as params:
configs_single_learners = []
configs_base_learners = []
temp = params.readline()
temp = temp[:-1].split('=')
n_folds = int(temp[1])
temp = params.readline()
temp = temp[:-1].split('=')
n_execucoes = int(temp[1])
temp = params.readline()
while True:
temp = params.readline()
if (temp == 'params_ensemble:') or (temp[:-1]
== 'params_ensemble:'):
break
else:
classificador, discriminador, neuronios, resposta, features = temp.split(
',')
features = list(int(x) for x in features[:-1].split('-'))
config = (classificador, discriminador, int(neuronios),
resposta, features, util.ConfusionMatrix())
configs_single_learners.append(config)
temp = params.readline()
temp = temp[:-1].split('=')
tamanho_treino_bagging = float(temp[1])
temp = params.readline()
temp = temp[:-1].split('=')
tamanho_treino_boost = float(temp[1])
temp = params.readline()
temp = temp[:-1].split('=')
if temp[1] == 'true':
com_repeticao_bagging = True
else:
com_repeticao_bagging = False
temp = params.readline()
temp = temp[:-1].split('=')
if temp[1] == 'true':
com_repeticao_boost = True
else:
com_repeticao_boost = False
temp = params.readline()
temp = temp[:-1].split('=')
if temp[1] == 'true':
mesmo_mapping_bagging = True
else:
mesmo_mapping_bagging = False
temp = params.readline()
temp = temp[:-1].split('=')
if temp[1] == 'true':
mesmo_mapping_boost = True
else:
mesmo_mapping_boost = False
temp = params.readline()
temp = temp[:-1].split('=')
if temp[1] == 'explicito':
n_learners = None
while True:
temp = params.readline()
if (temp == 'fim') or (temp[:-1] == 'fim'):
break
else:
classificador, discriminador, neuronios, resposta, features = temp.split(
',')
features = list(int(x) for x in features[:-1].split('-'))
config = (classificador, discriminador, int(neuronios),
resposta, features, util.ConfusionMatrix())
configs_base_learners.append(config)
else:
# ler os parametros e depois sortear as configs dos base learners
temp = params.readline()
temp = temp[:-1].split('=')
temp = temp[1]
ranking_features = list(int(x) for x in temp.split(','))
temp = params.readline()
temp = temp[:-1].split('=')
features_fixas = int(temp[1])
temp = params.readline()
temp = temp[:-1].split('=')
features_opcionais = int(temp[1])
temp = params.readline()
temp = temp[:-1].split('=')
features_sorteadas = int(temp[1])
temp = params.readline()
temp = temp[:-1].split('=')
n_learners = int(temp[1])
temp = params.readline()
temp = temp[:-1].split('=')
classificador, discriminador, neuronios, resposta = temp[1].split(
',')
combinacoes_features = gera_combinacoes_features(
ranking_features, features_fixas, features_opcionais,
features_sorteadas)
for combinacao in combinacoes_features:
config = (classificador, discriminador, int(neuronios),
resposta, combinacao, util.ConfusionMatrix())
configs_base_learners.append(config)
return n_folds, n_execucoes, tamanho_treino_bagging, tamanho_treino_boost, com_repeticao_bagging, com_repeticao_boost, mesmo_mapping_bagging, mesmo_mapping_boost, configs_single_learners, configs_base_learners, n_learners