def run(self):
"""
Executa a otimizacao usando o método MCC.
"""
super(MCC, self).run()
avaliacao = self._contexto.get_modulo(EnumModulo.AVALIACAO)
criterio = self._contexto.get_modulo(EnumModulo.CRITERIOPARADA)
while not criterio.run(self._contexto):
self.log(texto=f"Nova iteracao do método")
self._iteracao += 1
if self._proximo_conjuto():
self._contexto.set_atributo(
EnumAtributo.AVALIACAO_ITERACAO_AVALIAR, [self._iteracao],
True)
self._contexto = avaliacao.run(self._contexto)
self._selecionar_melhor()
self._para_resume()
Exportacao().csv(self._contexto)
Exportacao().obejto(self._contexto)
LogarMemoria(self._contexto)
else:
self.log(texto=f'Fim da execução do {self._name}')
return
self.log(texto=f'Fim da execução do {self._name}')
def run(self):
"""
Executa a otimizacao usando o método MCC.
"""
super(Acoplado, self).run()
criterio = self._contexto.get_modulo(EnumModulo.CRITERIOPARADA)
while not criterio.run(self._contexto):
self._ajusta_criterio_parada()
otimizador = self._seleciona_otimizador()
self._contexto = otimizador.run(self._contexto)
self._iteracao = max(
self._contexto.get_atributo(
EnumAtributo.SOLUCOES).solucoes) + 1
self._para_resume()
Exportacao().csv(self._contexto)
Exportacao().obejto(self._contexto)
LogarMemoria(self._contexto)
self._contexto.set_atributo(EnumAtributo.CRITERIO_PARADA,
self._criterio_parada, True)
self._contexto.set_atributo(
EnumAtributo.CRITERIO_PARADA_SIMULACOES_MAX,
self._criterio_parada_simulacoes_max, True)
self.log(texto=f'Fim da execução do {__name__}')
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 run(self):
"""
Executa a otimizacao usando o método Tabu Search.
:param Contexto contexto: contexto com todas as informações necessárias
"""
super(Tabuseach, self).run()
criterio = self._contexto.get_modulo(EnumModulo.CRITERIOPARADA)
while not criterio.run(self._contexto):
self._iteracao += 1
neighbors = self._get_neighbors()
self._run_neighbors(neighbors)
solucoes_ultima_iteracao = self._contexto.get_atributo(
EnumAtributo.SOLUCOES).get_solucoes_by_iteracao(
[self._iteracao])
beststrategy_of = self._direcao_of * float('-inf')
for id_solucao in solucoes_ultima_iteracao[self._iteracao]:
candidatestrategy = solucoes_ultima_iteracao[
self._iteracao][id_solucao]
if candidatestrategy.has_erro == "" or candidatestrategy.has_erro is None:
if candidatestrategy.of_valida():
if (self._direcao_of *
candidatestrategy.of[self._nome_of_mono].valor
) > (self._direcao_of * beststrategy_of):
beststrategy = candidatestrategy
beststrategy_of = beststrategy.of[
self._nome_of_mono].valor
beststrategy.geral = ''.join([beststrategy.geral] + ['[Melhor]'])
self._tabulist.append(beststrategy.serializacao())
if self._tamanho_tabu_list <= len(self._tabulist):
self._tabulist = self._tabulist[1:]
self._beststrategy = beststrategy
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 run(self):
"""
Executa a otimizacao usando o método IDLHC.
:param Contexto contexto: contexto com todas as informações necessárias
"""
super(IDLHC, self).run()
avaliacao = self._contexto.get_modulo(EnumModulo.AVALIACAO)
criterio = self._contexto.get_modulo(EnumModulo.CRITERIOPARADA)
modulo_sorteio: Sorteio = self._contexto.get_modulo(EnumModulo.SORTEIO)
modulo_sorteio.sorteio.tamanho_populacao = self._tamanho_populacao
primeira_iteracao_idlhc = True
while not criterio.run(self._contexto):
self.log(texto=f"Nova iteracao do método")
self._atualiza_probabilidades(primeira_iteracao_idlhc)
primeira_iteracao_idlhc = False
self._iteracao += 1
modulo_sorteio.sorteio.iteracao = self._iteracao
modulo_sorteio.sorteio.ultimo_id = self._id
modulo_sorteio.sorteio.solucao_referencia = self._solucao_referencia
modulo_sorteio.sorteio.contexto = self._contexto
try:
modulo_sorteio.sorteio.run()
except:
traceback.print_exc()
self._id = modulo_sorteio.sorteio.ultimo_id
solucoes_novas: Solucoes.solucoes = modulo_sorteio.sorteio.solucoes.solucoes
qtd_solucoes_sorteio = 0
for iteracao in solucoes_novas:
for id in solucoes_novas[iteracao]:
qtd_solucoes_sorteio += 1
solucoes_novas[iteracao][id].geral += "[IDHLC] "
self._solucoes.add_in_solucoes(
solucoes_novas[iteracao][id])
"""avaliamos se pelo menos uma das solucoes sorteadas se tratam de solucao nova e se a quantidade de amostras geradas no sorteio
e maior que o numero de amostras utilziadas para atualizacao da PDF"""
if qtd_solucoes_sorteio < self._contexto.get_atributo(
EnumAtributo.OTIMIZACAO_IDLHC_AMOSTRAS_PDF):
self.log(
texto=
f'Convergencia foi atingida por perda de variabilidade da amostra.'
)
break
self._contexto.set_atributo(EnumAtributo.SORTEIO_SOLUCOES_NOVAS,
self._solucoes, True)
self._contexto.set_atributo(
EnumAtributo.AVALIACAO_ITERACAO_AVALIAR, [self._iteracao],
True)
self._contexto = avaliacao.run(self._contexto)
for id in self._solucoes.solucoes[self._iteracao]:
self._solucoes_historico.add_in_solucoes(
self._solucoes.solucoes[self._iteracao][id])
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 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 _salvar(self):
exportacao = Exportacao()
exportacao.csv(self._contexto)
exportacao.obejto(self._contexto)
LogarMemoria(self._contexto)
def run(self, contexto: Contexto):
"""
Executa o redutor parcial
:param Contexto contexto: contexto com todas as informações necessárias
"""
super(SimulacaoParcial, self).run(contexto)
gevts_tempales = self._contexto.get_atributo(
EnumAtributo.AVALIACAO_MERO_GEVTS_TEMPLATES_EXECUTAR)
uniecos = self._contexto.get_atributo(
EnumAtributo.AVALIACAO_MERO_UNIECOS_EXECUTAR)
if (len(uniecos) > 1) or (len(gevts_tempales) > 1):
self.log(
tipo=EnumLogStatus.ERRO_FATAL,
texto=
"O redutor não esta preparado para lidar com otimização robusta."
)
if self._contexto.tem_atributo(EnumAtributo.REDUCAO_GEVT_DATA_FINAL):
if self._contexto.tem_atributo(
EnumAtributo.REDUCAO_GEVT_DIA_FINAL):
if self._contexto.tem_atributo(
EnumAtributo.REDUCAO_GEVT_TIME_LIST):
self._seta_qualificador_template_de_sim_parcial()
return self._contexto
self._data_sim_parcial = self._contexto.get_atributo(
EnumAtributo.REDUCAO_GEVT_DATA_FINAL)
self._avaliacao_gevt()
self._gera_e_seta_dias_datas_sim_parcial()
self._seta_qualificador_template_de_sim_parcial()
return
qtd_simulacao_total = self._contexto.get_atributo(
EnumAtributo.REDUCAO_QUANTIDADE_SIMULACAO_TOTAL)
solucao_base = self._contexto.get_atributo(EnumAtributo.SOLUCAO_BASE)
sorteio = self._contexto.get_modulo(EnumModulo.SORTEIO)
self._contexto = sorteio.run(self._contexto, solucao_base,
qtd_simulacao_total)
avaliacao = self._contexto.get_modulo(EnumModulo.AVALIACAO)
self._contexto = avaliacao.run(self._contexto)
self._avalia_rankeamento_simulacoes_parciais()
self.log(tipo=EnumLogStatus.INFO,
texto='Estudo de recall gerado na pasta de resultados')
ultima_iteracao = self._contexto.get_atributo(
EnumAtributo.AVALIACAO_ITERACAO_AVALIAR)
self._contexto.get_atributo(
EnumAtributo.SOLUCOES).solucoes_it_para_menos1(ultima_iteracao)
Exportacao().csv(self._contexto)
Exportacao().obejto(self._contexto)
self.log(
tipo=EnumLogStatus.INFO,
texto=
'Finalizando Tardis. Resumir a otimizacao com REDUCAO_GEVT_DATA_FINAL escolhida pelo arquivo de estudo de recall por data'
)
sys.exit()
def _salvar(self):
if self._existe_solucao_avaliar:
self._para_resume()
Exportacao().csv(self._contexto)
Exportacao().obejto(self._contexto)
LogarMemoria(self._contexto)