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