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 _criar_solucoes_em_contexto(self):
conteudo_sorteio_txt = self._carregar_saida_HLDG()
nomes_variaveis = conteudo_sorteio_txt[0].split('\t')[1:-1]
lista_serializado = self._solucoes.serializacao()
for solucao_txt in conteudo_sorteio_txt[1:]:
nome_solucao_val_vars = solucao_txt.split('\t')
[iteracao_solucao,
id_solucao] = nome_solucao_val_vars[0].split('_')
solucao = Solucao(id=int(id_solucao) + self._ultimo_id,
iteracao=int(iteracao_solucao),
solucao=self._solucao_pdf_atualizada)
val_vars = [
InOut().ajusta_entrada(val_var)
for val_var in nome_solucao_val_vars[1:-1]
]
for variavel, valor in zip(nomes_variaveis, val_vars):
solucao.variaveis.get_variavel_by_nome(variavel).valor = valor
if solucao.variaveis.serializacao() not in lista_serializado:
self._solucoes.add_in_solucoes(solucao)
self._contexto.set_atributo(EnumAtributo.SOLUCOES, self._solucoes,
True)
self._contexto.set_atributo(EnumAtributo.AVALIACAO_ITERACAO_AVALIAR,
[int(iteracao_solucao)], True)
def solucoes_it_para_menos1(self, it):
solucoes = self.get_solucoes_by_iteracao(it)
if solucoes:
if self.get_solucoes_by_iteracao(-1):
self.remove_iteracao(-1)
for id, solucao in solucoes[it].items():
new_solucao = Solucao(solucao=solucao, iteracao=-1, id=id)
new_solucao.of = solucao.of
new_solucao.economico = solucao.economico
self.add_in_solucoes(new_solucao)
self.remove_iteracao(it)
def _evoluindo_variavel(self, passo: int,
variavel_in: Variavel) -> Solucao:
solucao_aux = None
variavel = None
while True:
variavel = copy.deepcopy(variavel_in)
if abs(passo) > len(variavel.dominio.niveis):
solucao_aux = None
self.log(
texto=
f'Não existe niveis para mais um na variavel [{variavel.nome}], com posicao [{abs(passo)}].'
)
break
elif variavel.posicao + passo < 0:
solucao_aux = None
self.log(
texto=
f'Não existe niveis para mais um na variavel [{variavel.nome}], com posicao [{variavel.posicao + passo}].'
)
break
elif variavel.posicao + passo >= len(variavel.dominio.niveis):
solucao_aux = None
self.log(
texto=
f'Não existe niveis para mais um na variavel [{variavel.nome}], com posicao [{variavel.posicao + passo}].'
)
break
valor_antigo = variavel.valor
try:
variavel.posicao += passo
except ValueError as ex:
self.log(texto="Valor for do limite", info_ex=str(ex))
return None
#self.log(texto=f'Passo igual [{passo}] para evolução da variavel [{variavel.nome}], valor antigo [{valor_antigo}], valor novo [{variavel.valor}]')
solucao_aux = Solucao(iteracao=self._iteracao,
id=self._id + 1,
solucao=self._solucao_melhor)
solucao_aux.variaveis.set_variavel_posicao_by_nome(
variavel.nome, variavel.posicao)
solucao_aux.geral += f'[MCC][{variavel.nome}|{valor_antigo}>{variavel.valor}]'
if self._solucoes.existe_solucao(solucao_aux):
passo += int(passo / abs(passo))
#self.log(texto=f'Já existe solucao com esses valores nas variaveis. Passo será [{passo}].')
else:
self._id += 1
break
del variavel
variavel = None
return solucao_aux
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 run(self, contexto):
"""
Executa a inicizalicao default
:param Contexto contexto: contexto com todas as informações necessárias
:return: Devolve o contexto atualizado
:rtype: Contexto
"""
super(Default, self).run(contexto)
caminho_dominio = TXT().ajuste_path(
f'{self._contexto.get_atributo(EnumAtributo.PATH_PROJETO)}/{self._contexto.get_atributo(EnumAtributo.INICIALIZACAO_DOMINIO)}'
)
iteracao = 0
identificador = 0
self._solucao = Solucao(id=identificador, iteracao=iteracao)
for nome_of in self._nomes_direcoes_of:
direcao = self._nomes_direcoes_of[nome_of][EnumValues.DIRECAO.name]
self._solucao.of = Of(nome_of, direcao=direcao)
dominio = TXT().ler(caminho_dominio)
for ii in range(1, len(dominio)):
try:
if str(dominio[ii]).strip() == "":
continue
dom = self._linha_2_dominio(dominio[ii])
self.log(texto=f'Criando variavel {dom.to_string()}')
variavel = Variavel(dom)
self._solucao.add_in_variaveis(variavel)
except Exception as ex:
self.log(tipo=EnumLogStatus.WARN,
texto=f'Erro para adicionar variavel',
info_ex=str(ex))
self._contexto.set_atributo(EnumAtributo.SOLUCAO_BASE, self._solucao)
self._contexto.set_atributo(EnumAtributo.AVALIACAO_ITERACAO_AVALIAR,
[0], True)
solucoes = Solucoes()
solucoes.add_in_solucoes(self._solucao)
self._contexto.set_atributo(EnumAtributo.SOLUCOES, solucoes, True)
if self._contexto.get_atributo(EnumAtributo.INICIALIZACAO_SIMULA_BASE):
avaliacao = self._contexto.get_modulo(EnumModulo.AVALIACAO)
self._contexto = avaliacao.run(self._contexto)
Exportacao().csv(self._contexto)
Exportacao().obejto(self._contexto)
def __init__(self):
"""
Construtor da solucoes
"""
super().__init__()
self._name = __name__
"""
Variavel com o nome do arquivo
"""
self._solucoes = {}
"""
Variavel que armazena a coleção de solucoes
"""
self._melhor_solucao = Solucao(0, 0)
self._solucoes_serializado = {}
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 _run_neighbors(self, neighbors: list):
"""
Metodo responsavel por simular as estratégias vizinhas
:param neighbors:
"""
avaliacao = self._contexto.get_modulo(EnumModulo.AVALIACAO)
for candidatestrategy in neighbors:
self._id += 1
solucao = Solucao(id=int(self._id),
iteracao=int(self._iteracao),
solucao=candidatestrategy)
solucao.geral += "[TS]"
self._solucoes.add_in_solucoes(solucao)
self._contexto.set_atributo(EnumAtributo.AVALIACAO_ITERACAO_AVALIAR,
[self._iteracao],
sobrescreve=True)
self._contexto = avaliacao.run(self._contexto)
def _gera_solucoes(self):
"""
Gera as solucoes e salva na variavel de classe
"""
self.log(texto="Gerando Soluções")
self._solucoes = Solucoes()
nome_variaveis = self._solucao_referencia.variaveis.get_variaveis_by_tipo(
EnumTipoVariaveis.VARIAVEL)
amostras = []
for nome_variavel in nome_variaveis:
probabilidade = self._solucao_referencia.variaveis.get_variavel_by_nome(
nome_variavel).dominio.probabilidade
niveis = self._solucao_referencia.variaveis.get_variavel_by_nome(
nome_variavel).dominio.niveis
if round(sum(probabilidade), 3) != round(1, 3):
self.log(tipo=EnumLogStatus.ERRO_FATAL,
texto='Somatorio das probabilidades diferente de 1')
amostra = self._gera_amostragem_variaveis(probabilidade, niveis,
self._tamanho_populacao)
amostras.append(amostra)
amostras = np.array(amostras).T
amostras = self._checa_duplicidade(amostras)
solucoes_df = pd.DataFrame(amostras, columns=nome_variaveis.keys())
for i in range(solucoes_df.shape[0]):
self._ultimo_id += 1
solucao = Solucao(id=int(self._ultimo_id),
iteracao=int(self._iteracao),
solucao=self._solucao_referencia)
for variavel, valor in zip(solucoes_df.columns,
solucoes_df.iloc[i, :]):
solucao.variaveis.get_variavel_by_nome(
variavel).valor = InOut.ajusta_entrada(str(valor))
#Caso a simulacao ja tenha sido simulada, o avaliador sera responsavel por reutilizar o valor ja simulado
#Caso nao queira solucoes repetidas, deve ser tratado fora da classe de sorteio
self._solucoes.add_in_solucoes(solucao)
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()