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 _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 run(self, contexto: Contexto):
"""
Metodo responsavel por simular de forma total as melhores simulacoes ao ser utilizado
redutor com simulacao parcial
:param Contexto contexto: contexto com todas as informações necessárias
"""
super(SimulacaoTotal, self).run(contexto)
n_melhores = 10
solucoes = self._contexto.get_atributo(EnumAtributo.SOLUCOES)
iteracao_sim_total = max(map(int, solucoes.solucoes)) + 1
melhores_solucoes = solucoes.conjunto_melhores_solucoes(
n_melhores).solucoes
for it in melhores_solucoes:
for id in melhores_solucoes[it]:
solucao_sim_total = melhores_solucoes[it][id]
solucao = Solucao(id=id,
iteracao=iteracao_sim_total,
solucao=solucao_sim_total)
self.log(
arquivo=__name__,
texto=
f'Solucao de it={it}, id={id} sera simulado de forma total'
)
solucao.geral = f'SIMULACAO TOTAL do it = {it} id = {id}'
solucoes.add_in_solucoes(solucao)
self._contexto.set_atributo(EnumAtributo.SOLUCOES, solucoes, True)
self._contexto.set_atributo(EnumAtributo.AVALIACAO_ITERACAO_AVALIAR,
[iteracao_sim_total], True)
gevts_templates = self._contexto.get_gevts_templates(
self._contexto.get_atributo(
EnumAtributo.AVALIACAO_MERO_GEVT_TEMPLATE))
self._contexto.set_atributo(
EnumAtributo.AVALIACAO_MERO_GEVTS_TEMPLATES_EXECUTAR,
gevts_templates, True)
self._contexto.set_atributo(EnumAtributo.AVALIACAO_QUALIFICADOR,
EnumValues.TOTAL.name, True)
avaliacao = self._contexto.get_modulo(EnumModulo.AVALIACAO)
self._contexto = avaliacao.run(self._contexto)
Exportacao().csv(self._contexto)
Exportacao().obejto(self._contexto)
def _nova_solucao_aleatoria(self, index_fc, iteracao, id, prefixo):
solucao = copy.deepcopy(
self._solucoes.get_solucao_by_iteracao_id(
self._fontes_alimento[index_fc].iteracao,
self._fontes_alimento[index_fc].id))
variaveis = copy.deepcopy(solucao.get_variavies_by_tipo())
for nome_var in variaveis:
lim_inferior = 0
lim_superior = len(variaveis[nome_var].dominio.niveis) - 1
posicao = random.randint(
lim_inferior,
lim_superior) # ajuste para inteiro, equação [ref:2].5
variaveis[nome_var].posicao = posicao
solucao.variaveis.set_variavel_posicao_by_nome(
variaveis[nome_var].nome, variaveis[nome_var].posicao)
solucao_nova = Solucao(iteracao=iteracao, id=id, solucao=solucao)
solucao_nova.geral = f'[ABC][Aleatoria][{prefixo}]'
return solucao_nova
def _nova_solucao(self, index_fc_selecionada, iteracao, id,
prefixo) -> Solucao:
solucao_fonte = copy.deepcopy(
self._solucoes.get_solucao_by_iteracao_id(
self._fontes_alimento[index_fc_selecionada].iteracao,
self._fontes_alimento[index_fc_selecionada].id))
solucao_nova = Solucao(iteracao=iteracao, id=id, solucao=solucao_fonte)
solucao_nova.geral = f'[ABC][Vizinhanca][{prefixo}]'
try:
from random import sample
index_variaveis_sorteio = sample(
range(0, len(self._lista_variaveis)),
len(self._lista_variaveis))
index_fonte_alimento_sorteio = sample(
range(0, len(self._fontes_alimento)),
len(self._fontes_alimento))
fonte_vizinha_index = index_fonte_alimento_sorteio.pop(0)
while fonte_vizinha_index == index_fc_selecionada:
fonte_vizinha_index = index_fonte_alimento_sorteio.pop(0)
fonte_vizinha = self._fontes_alimento[fonte_vizinha_index]
contador_existem = 0
limites_random = 1
while self._solucoes.existe_solucao(solucao_nova):
contador_existem += 1
variavel_modificar = self._lista_variaveis[
index_variaveis_sorteio.pop(0)]
dominio_niveis = len(solucao_nova.get_variavies_by_tipo()
[variavel_modificar].dominio.niveis)
posicao_fonte = solucao_nova.get_variavies_by_tipo(
)[variavel_modificar].posicao
posicao_vizinha = self._solucoes.get_solucao_by_iteracao_id(
fonte_vizinha.iteracao, fonte_vizinha.id
).get_variavies_by_tipo()[variavel_modificar].posicao
r = random.uniform(-1 * limites_random, limites_random)
# gera valores entre -1 e 1, equacao [ref:2].6 | estamos gerando entre -2 e 2 para aumentar variabilidade visto que são inteiros
posicao_nova = max(
min(
dominio_niveis - 1,
math.ceil(posicao_fonte +
(posicao_fonte - posicao_vizinha) * r)), 0)
posicao_antiga = solucao_nova.get_variavies_by_tipo(
)[variavel_modificar].posicao
if posicao_antiga == posicao_nova:
if posicao_nova == dominio_niveis - 1:
posicao_nova += -1
elif posicao_nova == 0:
posicao_nova += 1
else:
posicao_nova += random.sample([-1, 1], 1)[0]
self.log(
texto=
f'[{variavel_modificar} | {posicao_antiga} > {posicao_nova}]'
)
solucao_nova.get_variavies_by_tipo(
)[variavel_modificar].posicao = posicao_nova
if limites_random >= 10:
break
if len(index_variaveis_sorteio) <= 0:
limites_random += 0.1
index_variaveis_sorteio = sample(
range(0, len(self._lista_variaveis)),
len(self._lista_variaveis))
if len(index_fonte_alimento_sorteio) <= 0:
index_fonte_alimento_sorteio = sample(
range(0, len(self._fontes_alimento)),
len(self._fontes_alimento))
fonte_vizinha_index = index_fonte_alimento_sorteio.pop(0)
while fonte_vizinha_index == index_fc_selecionada:
if len(index_fonte_alimento_sorteio) <= 0:
index_fonte_alimento_sorteio = sample(
range(0, len(self._fontes_alimento)),
len(self._fontes_alimento))
fonte_vizinha_index = index_fonte_alimento_sorteio.pop(
0)
fonte_vizinha = self._fontes_alimento[fonte_vizinha_index]
self.log(
texto=
f'Tentativas para nova solucao [{contador_existem}] e Limite em [{limites_random:.2f}].'
)
except Exception as ex:
self.log(tipo=EnumLogStatus.ERRO_FATAL,
texto="Erro para obter nova solucao.",
info_ex=str(ex))
return solucao_nova
def _iniciar_fonte_alimento(self):
self.log(tipo=EnumLogStatus.INFO,
texto='Iniciando as fonte de alimento.')
self._existe_solucao_avaliar = False
# resume de um otimizador diferente
if self._iteracao > 1 and self._iteracao != self._ultima_iteracao:
self._fontes_alimento = []
solucoes_melhores = self._solucoes.conjunto_melhores_solucoes(
quantidade=self._qtd_fonte_alimento,
nome_of_mono=self._nome_of_mono).solucoes
for iteracao in solucoes_melhores:
for id in solucoes_melhores[iteracao]:
fonte_alimento = FonteAlimento(
iteracao, id, solucoes_melhores[iteracao][id].of[
self._nome_of_mono].direcao)
fonte_alimento.of = solucoes_melhores[iteracao][id].of[
self._nome_of_mono].valor
self._fontes_alimento.append(fonte_alimento)
# resume do ABC
if self._iteracao > 1 and self._iteracao == self._ultima_iteracao:
qtd_solucoes_melhores = self._qtd_fonte_alimento - len(
self._fontes_alimento)
solucoes_melhores = self._solucoes.conjunto_melhores_solucoes(
quantidade=qtd_solucoes_melhores,
nome_of_mono=self._nome_of_mono).solucoes
for iteracao in solucoes_melhores:
for id in solucoes_melhores[iteracao]:
fonte_alimento = FonteAlimento(
iteracao, id, solucoes_melhores[iteracao][id].of[
self._nome_of_mono].direcao)
fonte_alimento.of = solucoes_melhores[iteracao][id].of[
self._nome_of_mono].valor
self._fontes_alimento.append(fonte_alimento)
# default
if self._qtd_fonte_alimento != len(self._fontes_alimento):
self._iteracao += 1
while self._qtd_fonte_alimento > len(self._fontes_alimento):
self._id += 1
solucao = Solucao(iteracao=self._iteracao,
id=self._id,
solucao=self._solucao_base)
solucao.geral = '[ABC][Aleatorio][Inicio]'
variaveis = copy.deepcopy(solucao.get_variavies_by_tipo())
for nome_var in variaveis:
lim_inferior = 0
lim_superior = len(variaveis[nome_var].dominio.niveis) - 1
posicao = random.randint(
lim_inferior,
lim_superior) # ajuste para inteiro, equação [ref:2].5
variaveis[nome_var].posicao = posicao
solucao.variaveis.set_variavel_posicao_by_nome(
variaveis[nome_var].nome, variaveis[nome_var].posicao)
if self._solucoes.existe_solucao(solucao):
self._id -= 1
else:
self._solucoes.add_in_solucoes(solucao)
self._fontes_alimento.append(
FonteAlimento(solucao.iteracao, solucao.id,
solucao.of[self._nome_of_mono].direcao))
self._existe_solucao_avaliar = True
# self.log(tipo=EnumLogStatus.INFO, texto=solucao.to_string())
self._avaliar()