def create_output(self):
"""Funcion que crea el objeto con la estrusctura de datos leible y luego
crea el objeto resultado que posee una estructura mas leible para ser introducido
en el output.txt ademas de guardarlo en lista a los valores
"""
f = open("Output.txt", "w")
dt = DataStructure(self.input)
dt.open_fill()
for i in dt.get_all():
p = Resultado(i)
if type(p.get_id()) == (int):
self.output.append(p.get_all())
f.write("{}\n\n".format(p.get_all()))
f.close()
def eval(self,
df_treino: pd.DataFrame,
df_data_to_predict: pd.DataFrame,
col_classe: str,
seed: int = 1) -> Resultado:
#Atividade 2: Implementação da classe eval - veja passo a passo
#a partir de self.df_treino, separe os atributos da classe
#x_treino deverá ser um dataframe que possua apenas as colunas dos atributos (use o método drop com o parametro axis)
#y_treino deverá possuir apenas os valores coluna da classe
x_treino = df_treino.drop(col_classe, 1)
y_treino = df_treino[col_classe]
#execute o método fit de ml_method e crie o modelo
model = self.ml_method.fit(x_treino, y_treino)
#faça a mesma separação que fizemos em x_treino e y_treino nos dados a serem previstos
x_to_predict = df_data_to_predict.drop(col_classe, 1)
y_to_predict = df_data_to_predict[col_classe]
#Impressao do x e y para testes
#print("X_treino: "+str(x_treino))
#print("y_treino: "+str(y_treino))
#print("X_to_predict: "+str(x_to_predict))
#print("y_to_predict: "+str(y_to_predict))
#retorne o resultado por meio do método predict
y_predictions = self.ml_method.predict(x_to_predict)
return Resultado(y_to_predict, y_predictions)
def agrupa_resultados_por_sessao(self):
resultado_list = {}
self.total = self.response['hits']['total']
for hits in self.response['hits']['hits']:
payload = hits['_source']['payload']
time = hits['_source']['time']
# Caso exista adiciona novo elemento
if (hits['_source']['sessao'] in resultado_list.keys()):
resultado_list[hits['_source']['sessao']].payload.append(payload)
resultado_list[hits['_source']['sessao']].time = time
# Senao inclui novo elemento
else:
resultado = Resultado()
resultado.payload.append(payload)
resultado.time = time
resultado_list[hits['_source']['sessao']] = resultado
return resultado_list
def test_macro_f1(self):
resultado = Resultado(TestResultado.y,TestResultado.predict_y)
prec = [1/2,1/5,4/6]
rev = [1/2,1/3,4/8]
f1_esp = [2*(prec[i]*rev[i])/(prec[i]+rev[i]) for i in range(len(prec))]
macro_f1 = np.average(f1_esp)
self.assertAlmostEqual(resultado.macro_f1,macro_f1,msg="Macro F1 não está com o valor esperado")
def execucaoAGCanonico(objetos, penalizar, pc, pm):
melhoresIndividuos = []
execucao = 1
while execucao < MAX_EXECUCOES:
individuos = []
individuos = iniciaPopulacao([])
individuos = calculaFitness(objetos, individuos)
geracao = 1
while geracao < MAX_GENERATIONS:
#Caso não haja mais que um indivíduo com o fitness positivo para o cruzamento
#então paro a execução e salvo o valor gerado
numIndFitnessPositivo = 0
for individuo in individuos:
if individuo.fitness >= 0:
numIndFitnessPositivo += 1
#Caso haja menos de 2 individuos com fitness positivo entao salvo o melhor fitness
# e vou para a proxima execucao
if numIndFitnessPositivo < 2:
# melhorInd = Resultado(geracao, individuos[0], individuos[0].fitness, execucao)
# melhoresIndividuos.append(melhorInd)
break
else:
sorteioPrimeiro = selecionaRoleta(individuos)
sorteioSegundo = selecionaRoleta(individuos)
#Caso os individuos sejam os mesmos vou sorteando ate serem diferentes
while sorteioPrimeiro == sorteioSegundo:
sorteioSegundo = selecionaRoleta(individuos)
# print("Primeiro sorteado foi: "+ str(sorteioPrimeiro))
# print("Segundo sorteado foi: "+ str(sorteioSegundo))
individuos = cruzamento(individuos, sorteioPrimeiro,
sorteioSegundo, pc, pm)
individuos = calculaFitness(objetos, individuos)
# Faco a reparacao ou penalizacao
individuos = checaPesoMochila(objetos, individuos, penalizar)
individuos.sort(key=ordenaPorFitness, reverse=True)
if len(individuos) > NP:
# Caso tenha sofrido mutacao
del individuos[11]
del individuos[10]
melhorInd = Resultado(geracao, individuos[0],
individuos[0].fitness, execucao)
melhoresIndividuos.append(melhorInd)
geracao += 1
execucao += 1
return melhoresIndividuos
def executar(self):
self.listaDadosIniciais = Configuracao.gerarDadosIniciais(
self.configuracao)
resultado = Resultado(self.configuracao.problema)
for a in range(4):
algoritmo = None
if (a == 0):
algoritmo = Algoritmo(Configuracao.algoritmos[a],
HillClimbing(self.configuracao))
elif (a == 1):
algoritmo = Algoritmo(Configuracao.algoritmos[a],
HillClimbingRestart(self.configuracao))
elif (a == 2):
algoritmo = Algoritmo(Configuracao.algoritmos[a],
SimulatedAnnealing(self.configuracao))
else:
algoritmo = Algoritmo(Configuracao.algoritmos[a],
GeneticAlgorithm(self.configuracao))
for iteracao in range(10):
algoritmo.executar(self.listaDadosIniciais[iteracao], iteracao)
algoritmo.gerarEstatisticas()
Graficos.gerarGraficoFuncaoObjetivo(algoritmo, self.configuracao)
resultado.adicionar(algoritmo)
inicioComparativo = time.perf_counter()
self.finalizar(resultado)
terminoComparativo = time.perf_counter()
print(
f"Geração da tabela/gráfico de comparativo de performance em {terminoComparativo - inicioComparativo:0.4f} segundos"
)
def test_otimizacao(self):
fold = Fold(Dados.df_treino,
Dados.df_teste,
"realClass",
num_folds_validacao=3,
num_repeticoes_validacao=2)
otimiza_fold = OtimizacaoObjetivoRandomForest(fold)
tpe_sampler = TPESampler(n_startup_trials=10, seed=1)
study_TP = optuna.create_study(sampler=tpe_sampler,
direction="maximize")
study_TP.optimize(otimiza_fold, n_trials=30)
for trial in study_TP.trials:
print(trial.params)
arr_params_to_test = [
"min_samples_split", "max_features", "num_arvores"
]
for param_name in arr_params_to_test:
self.assertTrue(
param_name in study_TP.best_trial.params,
f"Não foi encontrado o parametro '{param_name}' certifique-se se você nomeou o parametro devidamente"
)
self.assertAlmostEqual(study_TP.best_trial.params["min_samples_split"],
0.19829036364801306,
places=5,
msg="Otimização não deu resultado esperado")
self.assertAlmostEqual(study_TP.best_trial.params["max_features"],
0.1939553705810037,
places=5,
msg="Otimização não deu resultado esperado")
self.assertAlmostEqual(study_TP.best_trial.params["num_arvores"],
5,
msg="Otimização não deu resultado esperado")
print(f"Melhor execução: {study_TP.best_trial.params}")
result = Resultado(np.array([1, 1, 1, 1, 0, 0, 0, 0]),
np.array([1, 1, 0, 0, 1, 1, 1, 0]))
result_metrica = otimiza_fold.resultado_metrica_otimizacao(result)
print(f"Resultado: {result_metrica}")
self.assertAlmostEqual(
result_metrica,
0.3650793650793651,
places=5,
msg="Resultado da metrica de otimização não deu resultado esperado"
)
def test_acuracia(self):
resultado = Resultado(TestResultado.y, TestResultado.predict_y)
self.assertAlmostEqual(resultado.acuracia,
6 / 13,
msg="Acuracia não está com o valor esperado")
def gerar(self):
# ['1|2|1|1']
# v1 | a | v2 | peso
resList = []
if self.checkDirecionado.isChecked():
self.grafo.setDirecionado(True)
else:
self.grafo.setDirecionado(False)
if self.checkExisteLaco.isChecked():
if self.grafo.existeLaco():
resList.append("- Existem os seguintes laços:\n" + "\n".join(self.grafo.getLaco()))
else:
resList.append("- Nao existem lacos no grafo.")
if self.checkExisteParalela.isChecked():
if self.grafo.existeArestaParalela():
resList.append("- Existem arestas paralelas")
else:
resList.append("- Nao existem arestas paralelas")
if self.checkExisteIsolado.isChecked():
if self.grafo.existeVerticeIsolado():
resList.append("- Existem vertices isolados")
else:
resList.append("- Nao existem vertices isolados")
if self.checkOrdem.isChecked():
resList.append("- Ordem do grafo: " + str(self.grafo.getOrdem()))
if self.checkExisteCiclo.isChecked():
ciclos = self.grafo.getCiclos()
if ciclos:
resList.append("- Existe(m) ciclo(s) para o(s) vértice(s): " + ", ".join(ciclos))
else:
resList.append("- Nao existem ciclos no grafo")
if self.checkConexo.isChecked():
if self.grafo.isConexo():
resList.append("- Grafo é conexo")
else:
resList.append("- Grafo não é conexo")
if self.checkCaminhoCurto.isChecked():
v1 = self.comboCaminhoInicio.currentText()
v2 = self.comboCaminhoFim.currentText()
if self.grafo.existeCaminho(v1, v2, []):
resList.append("- Existe caminho entre o vértice '" + v1 + "' e '" + v2 +"'")
else:
resList.append("- Nao existe caminho entre o vértice '" + v1 + "' e '" + v2 +"'")
if self.checkGrau.isChecked():
graus = self.grafo.getTodosGraus()
if self.grafo.isDirecionado:
resList.append("- Grau de cada vértice (emissão, recepção):")
else:
resList.append("- Grau de cada vértice:")
for v in graus.keys():
if self.grafo.isDirecionado:
resList.append(" '" + v + "': " + str(graus[v][0]) + ", " + str(graus[v][1]))
else:
resList.append(" '" + v + "': " + str(graus[v]))
resList.append("")
if self.checkAdjacencia.isChecked():
adjacencias = self.grafo.getTodasAdjacencias()
resList.append("- Adjacências de cada vértice:")
for v in adjacencias.keys():
strAdj = "" + v + ": "
verticesAdj = []
for arestaAdj, vertAdj in adjacencias[v]:
verticesAdj.append(vertAdj)
if verticesAdj:
resList.append(strAdj + ", ".join(verticesAdj))
else:
resList.append(strAdj + "Nenhum")
resultado = Resultado("\n".join(resList), self)
resultado.centerToMainWindow()
self.resultados.append(resultado)