def _evaluate(self, x, out, *args, **kwargs):
if len(kwargs) == 0:
return
iteracao_max = max(list(self._solucoes.solucoes))
iteracao_atual = iteracao_max + 1
id = max(list(self._solucoes.solucoes[iteracao_max])) + 1
Loggin().log(arquivo=__name__, tipo=EnumLogStatus.INFO, texto=f"Inicializando o Calculo para geração [{iteracao_atual}]")
solucao_base: Solucao = self._contexto.get_atributo(EnumAtributo.SOLUCAO_BASE)
for ii in range(x.shape[0]):
solucao_nova = Solucao(id, iteracao_atual, solucao_base)
id += 1
variavies = solucao_base.get_variavies_by_tipo()
jj = 0
for variavel in variavies:
try:
solucao_nova.variaveis.get_variavel_by_nome(variavel).posicao = int(x[ii][jj])
except ValueError as ex:
Loggin().log(arquivo=__name__, texto="Valor for do limite", info_ex=str(ex))
jj += 1
solucao_nova.geral = f'[{self._otimizador}]'
self._solucoes.add_in_solucoes(solucao_nova)
self._contexto.set_atributo(EnumAtributo.SOLUCOES, self._solucoes, True)
self._contexto.set_atributo(EnumAtributo.AVALIACAO_ITERACAO_AVALIAR, [iteracao_atual], True)
Loggin().log(arquivo=__name__, tipo=EnumLogStatus.INFO, texto=f"Iniciando avaliação.")
avaliacao = self._contexto.get_modulo(EnumModulo.AVALIACAO)
self._contexto = avaliacao.run(self._contexto)
self._solucoes = self._contexto.get_atributo(EnumAtributo.SOLUCOES)
f1 = np.zeros((len(self._solucoes.solucoes[iteracao_atual]), self._n_obj))
g1 = np.zeros((len(self._solucoes.solucoes[iteracao_atual]), self._n_obj))
for ii in self._solucoes.solucoes[iteracao_atual]:
try:
posicao = ii - list(self._solucoes.solucoes[iteracao_atual])[0]
n_of = 0
for nome_of in sorted(self._nomes_direcoes_of):
# para minimizar precisa ser -1 o valor padrão.
direcao_of_valor = 1
if EnumValues.MIN.name in self._nomes_direcoes_of[nome_of][EnumValues.DIRECAO.name]:
direcao_of_valor = -1
if self._solucoes.solucoes[iteracao_atual][ii].has_erro is None:
f1[posicao][n_of] = -1 * self._solucoes.solucoes[iteracao_atual][ii].of[nome_of].valor * direcao_of_valor
g1[posicao][n_of] = -1 * self._solucoes.solucoes[iteracao_atual][ii].of[nome_of].valor * direcao_of_valor
else:
f1[posicao][n_of] = -1 * Solucao.of_padrao(self._nomes_direcoes_of[nome_of][EnumValues.DIRECAO.name])
g1[posicao][n_of] = -1 * Solucao.of_padrao(self._nomes_direcoes_of[nome_of][EnumValues.DIRECAO.name])
n_of += 1
except Exception as ex:
Loggin().log(arquivo=__name__, tipo=EnumLogStatus.ERRO, texto=f"Não foi possivel ler of da solucao [{ii}] geracao [{iteracao_atual}].")
out["F"] = f1
out["G"] = g1
self._salvar()
def _set_melhores(self):
direcao_of_valor = 1
if self._direcao_of in EnumValues.MIN.name:
direcao_of_valor = -1
for ii in range(self._tamanho_populacao):
id = self._populacao[ii]['id']
solucao: Solucao = self._solucoes.get_solucao_by_iteracao_id(
self._iteracao, id)
self._populacao[ii]['of'] = solucao.of[self._nome_of_mono].valor
if not solucao.of_valida():
for of_nome in solucao.of:
self._populacao[ii]['of'] = Solucao.of_padrao(
direcao=self._direcao_of)
self.log(
tipo=EnumLogStatus.WARN,
texto=
f'Solucao com itercao [{solucao.iteracao}] e id [{solucao.id}], esta com of {of_nome} nula. Será atribuido {Solucao.of_padrao(direcao=self._direcao_of)} para of'
)
if solucao.has_erro is not None:
self._populacao[ii]['of'] = Solucao.of_padrao(
direcao=self._direcao_of)
self.log(
tipo=EnumLogStatus.WARN,
texto=
f'Solucao com itercao [{solucao.iteracao}] e id [{solucao.id}], esta com erro [{solucao.has_erro}]. Será atribuido -inf para of'
)
if (direcao_of_valor * self._populacao[ii]['of']) > (
direcao_of_valor * self._populacao[ii]['best_of']):
self.log(
texto=
f"[Melhor LOCAL] [pop:{ii}][it:{self._iteracao}][id:{id}]: of -> [{self._populacao[ii]['best_of']}]>[{self._populacao[ii]['of']}]"
)
self._populacao[ii]['best_posicao'] = deepcopy(
self._populacao[ii]['posicao'])
self._populacao[ii]['best_of'] = deepcopy(
self._populacao[ii]['of'])
if (direcao_of_valor * self._populacao[ii]['of']) > (
direcao_of_valor * self._gbest['of']):
self.log(
texto=
f"[Melhor GLOBAL] [it:{self._iteracao}][id:{id}]: of -> [{self._gbest['of']}]>[{self._populacao[ii]['of']}]"
)
self._gbest['posicao'] = deepcopy(
self._populacao[ii]['posicao'])
self._gbest['variavel'] = deepcopy(
self._populacao[ii]['variavel'])
self._gbest['of'] = deepcopy(self._populacao[ii]['of'])
def _gerar_solucoes_avalia(self):
self._iteracao += 1
self.log(texto="Calculando nova populacao.")
for ii in range(self._tamanho_populacao):
self._id += 1
solucao = Solucao(id=self._id,
iteracao=self._iteracao,
solucao=self._solucao_base)
for jj in range(len(self._populacao[ii]['posicao'])):
nome = self._populacao[ii]['variavel'][jj]['nome']
posicao = self._populacao[ii]['variavel'][jj]['posicao']
try:
solucao.variaveis.set_variavel_posicao_by_nome(
nome, posicao)
except Exception as ex:
self.log(tipo=EnumLogStatus.ERRO,
texto="Erro ao setar variavel",
info_ex=str(ex))
solucao.variaveis.set_variavel_posicao_by_nome(nome, 0)
solucao.geral = "[PSO] "
self._solucoes.add_in_solucoes(solucao)
self._populacao[ii]['id'] = solucao.id
self._populacao[ii]['of'] = Solucao.of_padrao(
direcao=self._direcao_of)
self._contexto.set_atributo(EnumAtributo.SOLUCOES, self._solucoes,
True)
self._contexto.set_atributo(EnumAtributo.AVALIACAO_ITERACAO_AVALIAR,
[self._iteracao], True)
def _iteracao_um(self, avaliacao, exportacao):
empty_particle = {
'posicao': None,
'velocidade': None,
'of': None,
'best_posicao': None,
'best_of': -1 * float('inf'),
'variavel': None,
'id': None,
}
if len(self._populacao) == 0:
self._populacao = []
for ii in range(self._tamanho_populacao):
self._populacao.append(empty_particle.copy())
self._populacao[ii]['of'] = Solucao.of_padrao(
direcao=self._direcao_of
) # ofFunction(self._populacao[ii]['posicao'])
self._populacao[ii]['velocidade'] = np.full(
len(self._variaveis), self._w)
self._populacao[ii]['posicao'] = np.zeros(len(self._variaveis))
self._populacao[ii]['variavel'] = [None] * (len(
self._variaveis))
self._populacao[ii]['best_posicao'] = deepcopy(
self._populacao[ii]['posicao'])
self._populacao[ii]['best_of'] = deepcopy(
self._populacao[ii]['of'])
if len(self._solucoes_historico) > 0:
self._obtem_variaveis_solucao_historico()
else:
self._obtem_variavies_aleatoriamente()
self._gerar_solucoes_avalia()
self._avaliar_solucoes(avaliacao)
self._set_melhores()
self._para_resume()
exportacao.csv(self._contexto)
exportacao.obejto(self._contexto)
LogarMemoria(self._contexto)
else:
self._gbest['posicao'] = deepcopy(self._populacao[0]['posicao'])
self._gbest['variavel'] = deepcopy(self._populacao[0]['variavel'])
self._gbest['of'] = deepcopy(self._populacao[0]['of'])
for ii in range(1, len(self._populacao)):
if self._populacao[ii]['of'] > self._gbest['of']:
self._gbest['posicao'] = deepcopy(
self._populacao[ii]['posicao'])
self._gbest['variavel'] = deepcopy(
self._populacao[ii]['variavel'])
self._gbest['of'] = deepcopy(self._populacao[ii]['of'])
self._set_melhores()
def run(self):
"""
Metodo responsavel por utilizar avaliadores em arquivos externos python.
O arquivo deve possuir o metodo getResult(dict_variaveis)
"""
if self._nome_of_mono is None:
return
super(MultiObjetivo, self).run()
if EnumValues.MULTIOBJETIVO.name in self._nome_of_mono:
iteracoes = self._contexto.get_atributo(
EnumAtributo.AVALIACAO_ITERACAO_AVALIAR)
self._solucoes: Solucoes = self._contexto.get_atributo(
EnumAtributo.SOLUCOES).get_solucoes_by_iteracao(iteracoes)
for it in self._solucoes:
for id in self._solucoes[it]:
try:
for of_nome in self._nomes_direcoes_of:
if EnumValues.MULTIOBJETIVO.name not in of_nome:
exec(
f'{of_nome} = {self._solucoes[it][id].of[of_nome].valor}'
)
funcao_of = self._nome_of_mono.replace(
EnumValues.MULTIOBJETIVO.name,
"").replace('[', '').replace(']', '').replace(
EnumValues.MAX.name,
"").replace(EnumValues.MIN.name,
"").replace("_", "")
valor_funcao_of = eval(f'{funcao_of}')
self._solucoes[it][id].of[
self._nome_of_mono].valor = valor_funcao_of
except Exception as ex:
self.log(f"Erro ao calcular função.")
self._solucoes[it][id].of[
self._nome_of_mono].valor = Solucao.of_padrao(
self._solucoes[it][id].of[
self._nome_of_mono].direcao)
def _set_of(self, iteracao, id, file_unipro, nome_of):
try:
tempo, valor_of = self._ler_serie_field_unipro(
file_unipro, nome_of)
self.log(
texto=
f'Solucao iteracao [{iteracao}], e id [{id}] tem OF [{nome_of}] no valor de [{valor_of}] e tempo [{tempo}]'
)
self._solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao, id=id).of[nome_of].valor = valor_of
self._solucoes.get_solucao_by_iteracao_id(iteracao=iteracao,
id=id).set_avaliada()
except Exception as ex:
self.log(
tipo=EnumLogStatus.ERRO,
texto=
f'Erro ao obter dados de {nome_of} da solucao iteracao [{iteracao}], e id [{id}]',
info_ex=str(ex))
self._solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao, id=id).has_erro = f'OBTER_{nome_of}'
self._solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao,
id=id).of[nome_of].valor = Solucao.of_padrao(
self._nomes_direcoes_of[nome_of][EnumValues.DIRECAO.name])
def _ler_dados_producao(self, buffer):
unipro = buffer['unipro']
if len(unipro) == 0:
return
keys = deepcopy(list(unipro.keys()))
self.log(texto=f'Ler dados producao')
try:
keys = deepcopy(list(unipro.keys()))
for ii in range(len(keys)):
prefixo = keys[ii]
iteracao = unipro[prefixo]['iteracao']
id = unipro[prefixo]['id']
path = unipro[prefixo]['path']
path_file = InOut.ajuste_path(f'{path}.unipro')
file_unipro = h5py.File(path_file)
if EnumValues.WP.name in self._nomes_direcoes_of:
self._set_of(iteracao=iteracao,
id=id,
file_unipro=file_unipro,
nome_of=EnumValues.WP.name)
if EnumValues.NP.name in self._nomes_direcoes_of:
self._set_of(iteracao=iteracao,
id=id,
file_unipro=file_unipro,
nome_of=EnumValues.NP.name)
if EnumValues.WI.name in self._nomes_direcoes_of:
self._set_of(iteracao=iteracao,
id=id,
file_unipro=file_unipro,
nome_of=EnumValues.WI.name)
if EnumValues.GI.name in self._nomes_direcoes_of:
self._set_of(iteracao=iteracao,
id=id,
file_unipro=file_unipro,
nome_of=EnumValues.GI.name)
except Exception as ex:
for ii in range(len(keys)):
prefixo = keys[ii]
iteracao = unipro[prefixo]['iteracao']
id = unipro[prefixo]['id']
self.log(
tipo=EnumLogStatus.ERRO,
texto=
f'Erro ao obter dados de produção da solucao iteracao [{iteracao}], e id [{id}]',
info_ex=str(ex))
self._solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao, id=id).has_erro = f'OBTER_OF_PROD'
self._solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao,
id=id).of[EnumValues.NP.name].valor = Solucao.of_padrao(
self._nomes_direcoes_of[EnumValues.NP.name][
EnumValues.DIRECAO.name])
self._solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao,
id=id).of[EnumValues.WP.name].valor = Solucao.of_padrao(
self._nomes_direcoes_of[EnumValues.WP.name][
EnumValues.DIRECAO.name])
self._solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao,
id=id).of[EnumValues.WP.name].valor = Solucao.of_padrao(
self._nomes_direcoes_of[EnumValues.WI.name][
EnumValues.DIRECAO.name])
self._solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao,
id=id).of[EnumValues.WP.name].valor = Solucao.of_padrao(
self._nomes_direcoes_of[EnumValues.GI.name][
EnumValues.DIRECAO.name])
def run(self):
"""
Executa o PSO
:param Contexto contexto: contexto com todas as informações necessárias
:return: Devolve o contexto atualizado
:rtype: Contexto
"""
super(PSO, self).run()
exportacao = Exportacao()
avaliacao = self._contexto.get_modulo(EnumModulo.AVALIACAO)
criterio = self._contexto.get_modulo(EnumModulo.CRITERIOPARADA)
self._iteracao_um(avaliacao, exportacao)
while not criterio.run(self._contexto):
self.log(texto=f"Nova iteracao do método")
for ii in range(self._tamanho_populacao):
rp = np.random.rand(1)
rg = np.random.rand(1)
ld = np.zeros(len(self._variaveis))
lu = np.zeros(len(self._variaveis))
for jj in range(len(self._variaveis)):
ld[jj] = 0
lu[jj] = self._populacao[ii]['variavel'][jj]['lu'] - 1
termo_inercia = self._w * self._populacao[ii]['velocidade']
termo_cognitivo = self._cp * rp * (
self._populacao[ii]['best_posicao'] -
self._populacao[ii]['posicao'])
termo_social = self._cg * rg * (self._gbest['posicao'] -
self._populacao[ii]['posicao'])
self._populacao[ii][
'velocidade'] = termo_inercia + termo_cognitivo + termo_social
posicao_atualizada = self._populacao[ii][
'posicao'] + self._populacao[ii]['velocidade']
posicao_atualizada = np.round(posicao_atualizada,
0).astype(int)
posicao_atualizada = np.maximum(posicao_atualizada, ld)
posicao_atualizada = np.minimum(posicao_atualizada, lu)
self._populacao[ii]['posicao'] = np.round(
posicao_atualizada, 0).astype(int)
for vv in range(len(self._populacao[ii]['variavel'])):
self._populacao[ii]['variavel'][vv][
'posicao'] = self._populacao[ii]['posicao'][vv]
self._populacao[ii]['of'] = Solucao.of_padrao(
direcao=self._direcao_of)
self._populacao[ii]['id'] = None
self._w *= self._wdamp
self._gerar_solucoes_avalia()
self._avaliar_solucoes(avaliacao)
self._set_melhores()
self._para_resume()
exportacao.csv(self._contexto)
exportacao.obejto(self._contexto)
LogarMemoria(self._contexto)
self.log(texto=f'Fim da execução do {self._name}')
def _ler_dados_economicos(self, solucoes, path, ler_resultados, nome_of):
keys = deepcopy(list(ler_resultados.keys()))
direcao_of = self._nomes_direcoes_of[nome_of][EnumValues.DIRECAO.name]
if len(keys) == 0:
return solucoes
self.log(texto=f'Ler dados economicos de {path}')
try:
df_lido_correto = True
df = CSV().ler(f'{path}', lines_ignore=3, sep=";", index_col=False)
if df is None or df.shape[1] <= 1:
df = CSV().ler(f'{path}',
lines_ignore=3,
sep=",",
index_col=False)
if df is None or df.shape[1] <= 1:
df_lido_correto = False
if df_lido_correto:
df.sort_values(by='MODEL', inplace=True)
df.index = df.MODEL
for ii in range(len(keys)):
prefixo = keys[ii]
iteracao = ler_resultados[prefixo]['iteracao']
id = ler_resultados[prefixo]['id']
df_aux = {'dataframe': df[df.index == prefixo]}
if len(df_aux) > 0:
try:
valor_of = Solucao.of_padrao(direcao_of)
if nome_of == EnumValues.VPL.name:
if 'OF' in list(df_aux['dataframe'].columns):
df_npvf = df_aux['dataframe'][
df_aux['dataframe'].OF == 'NPVF']
valor_of = df_npvf.VALUE.iloc[0]
if nome_of == EnumValues.VME.name:
if 'EMV' in list(df_aux['dataframe'].columns):
valor_of = df_aux["dataframe"].EMV.iloc[0]
self.log(
texto=
f'Solucao iteracao [{iteracao}], e id [{id}] tem OF no valor de [{valor_of}]'
)
solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao,
id=id).of[nome_of].valor = valor_of
solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao, id=id).set_avaliada()
except Exception as ex:
self.log(
tipo=EnumLogStatus.ERRO,
texto=
f'Erro ao ler dados economicos da solucao iteracao [{iteracao}], e id [{id}]',
info_ex=str(ex))
solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao,
id=id).has_erro = f'LER_CVS_{nome_of}'
solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao,
id=id).of[nome_of].valor = Solucao.of_padrao(
direcao_of)
else:
self.log(
tipo=EnumLogStatus.ERRO,
texto=
f'Erro ao ler dados economicos da solucao iteracao [{iteracao}], e id [{id}]'
)
solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao,
id=id).has_erro = f'LER_CVS_{nome_of}'
solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao,
id=id).of[nome_of].valor = Solucao.of_padrao(
direcao_of)
else:
for ii in range(len(keys)):
prefixo = keys[ii]
iteracao = ler_resultados[prefixo]['iteracao']
id = ler_resultados[prefixo]['id']
self.log(
tipo=EnumLogStatus.ERRO,
texto=
f'Erro ao abrir dados economicos da solucao iteracao [{iteracao}], e id [{id}]'
)
solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao,
id=id).has_erro = f'ABRIR_CVS_{nome_of}'
solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao,
id=id).of[nome_of].valor = Solucao.of_padrao(
direcao_of)
except Exception as ex:
for ii in range(len(keys)):
prefixo = keys[ii]
iteracao = ler_resultados[prefixo]['iteracao']
id = ler_resultados[prefixo]['id']
self.log(
tipo=EnumLogStatus.ERRO,
texto=
f'Erro ao obter dados economicos da solucao iteracao [{iteracao}], e id [{id}]',
info_ex=str(ex))
solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao, id=id).has_erro = f'OBTER_{nome_of}'
solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao,
id=id).of[nome_of].valor = Solucao.of_padrao(direcao_of)
return solucoes