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 existe_solucao(self, solucao: Solucao, retorna_solucao=False): try: tamanho = len(self._solucoes_serializado) except Exception: if str(type(self._solucoes_serializado)) is not str(type({})): self._solucoes_serializado = {} self._add_serializado(solucao) if solucao.serializacao() in self._solucoes_serializado: # A solucao encontrada é a mesma da solução busca if solucao.id == self._solucoes_serializado[solucao.serializacao( )]['id'] and solucao.iteracao == self._solucoes_serializado[ solucao.serializacao()]['iteracao']: pass else: if retorna_solucao: iteracao = self._solucoes_serializado[ solucao.serializacao()]['iteracao'] id = self._solucoes_serializado[ solucao.serializacao()]['id'] return True, self._solucoes[iteracao][id] else: return True if retorna_solucao: return False, None else: return False
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 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 _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 _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 _escreve_params(self, solucao: Solucao, _path_params, prefixo): try: unievet_file_name = f'{self._qualificador}_{solucao.iteracao}_{solucao.id}_{prefixo}.unievent' cont = 'name_unievent {}\n'.format(unievet_file_name) if self._contexto.tem_atributo( EnumAtributo.REDUCAO_GEVT_DATA_FINAL): cont += f'{EnumValues.DATA_FINAL.name} {self._contexto.get_atributo(EnumAtributo.REDUCAO_GEVT_DATA_FINAL)}\n' if self._contexto.tem_atributo( EnumAtributo.REDUCAO_GEVT_DIA_FINAL): cont += f'{EnumValues.DIA_FINAL.name} {self._contexto.get_atributo(EnumAtributo.REDUCAO_GEVT_DIA_FINAL)}\n' # cont += f'***{EnumTipoVariaveis.VARIAVEL.name}***\n' # for key, variavel in solucao.get_variavies_by_tipo().items(): # cont += '{} {}\n'.format(key, variavel.valor) # # cont += f'***{EnumTipoVariaveis.CONSTANTE.name}***\n' # for key, variavel in solucao.get_variavies_by_tipo(EnumTipoVariaveis.CONSTANTE).items(): # cont += '{} {}\n'.format(key, variavel.valor) cont += f'***VARIAVEIS***\n' for nome, valor in solucao.get_variaveis_nome_valor().items(): cont += '{} {}\n'.format(nome, valor) if TXT().salvar(_path_params, cont): return True except Exception as ex: self.log(tipo=EnumLogStatus.WARN, texto=f'Erro ao escrever arquivo de dominio.', info_ex=str(ex)) return False return False
def _selecionar_melhor(self): """ Obtem a melhor solucao, de modo geral e se precisar de um novo caminho :param solucoes: Lista de todas as estratégias :type solucoes: Solucao :param nova: Informa se quer uma solucao para um novo caminho :type nova: bool :return: :rtype: """ solucoes_aux = self._contexto.get_atributo( EnumAtributo.SOLUCOES).solucoes #melhor_aux = self._solucao_base melhor_aux = None melhor_aux_of = float('-inf') quantidade_de_vezes_usar_solucao_com_melhor = 1 for k_iteracao in solucoes_aux: for k_id in solucoes_aux[k_iteracao]: if Solucao.validar_of(solucoes_aux[k_iteracao][k_id].of[ self._nome_of_mono].valor): direcao_of_valor = 1 if self._nomes_direcoes_of[self._nome_of_mono][ EnumValues.DIRECAO.name] in EnumValues.MIN.name: direcao_of_valor = -1 #if (direcao_of_valor * solucoes_aux[k_iteracao][k_id].of[self._nome_of_mono].valor) > (direcao_of_valor * melhor_aux.of[self._nome_of_mono].valor): if (direcao_of_valor * solucoes_aux[k_iteracao][k_id].of[ self._nome_of_mono].valor) > (direcao_of_valor * melhor_aux_of): eh_nova = True if k_iteracao in self._solucoes_usadas: if k_id in self._solucoes_usadas[k_iteracao]: if self._solucoes_usadas[k_iteracao][ k_id] > quantidade_de_vezes_usar_solucao_com_melhor: eh_nova = False if eh_nova: melhor_aux = solucoes_aux[k_iteracao][k_id] melhor_aux_of = solucoes_aux[k_iteracao][k_id].of[ self._nome_of_mono].valor if melhor_aux is None: melhor_aux = self._solucao_base self._solucao_melhor = melhor_aux if '[Melhor]' not in self._solucao_melhor.geral: self._solucao_melhor.geral += '[Melhor]' if melhor_aux.iteracao in self._solucoes_usadas: if melhor_aux.id in self._solucoes_usadas[melhor_aux.iteracao]: self._solucoes_usadas[melhor_aux.iteracao][melhor_aux.id] += 1 else: self._solucoes_usadas[melhor_aux.iteracao][melhor_aux.id] = 1 else: self._solucoes_usadas[melhor_aux.iteracao] = {melhor_aux.id: 1} self._contexto.set_atributo( EnumAtributo.OTIMIZACAO_MCC_SOLUCOES_USADAS, self._solucoes_usadas, True)
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 _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 _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 __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 _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 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])
class Default(InicializadorPadrao): """ Classe para inicializacao dos dados. """ def __init__(self): super(Default, self).__init__() self._name = __name__ """ Variavel com o nome do arquivo """ self._necessidade = [EnumAtributo.INICIALIZACAO_DOMINIO] + super( Default, self).necessidade """ Contem a lista de todos os atributos necessários para o módulo ser executado. """ self._solucao = None """ Objeto com todos os dominios """ 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 _linha_2_dominio(self, linha): """ Converte a linha do arquivo de donimio.csv em um objto do tipo dominio :param linha: Linha do arquivo de problema nome, problema, default, probabilidade :type linha: str :return: retorna o objeto do dominio :rtype: Dominio """ tipo = EnumTipoVariaveis.VARIAVEL linha = linha.strip() if len(linha.split(";")) < 2: self.log(tipo=EnumLogStatus.ERRO_FATAL, texto=f"Dominio {linha} esta com erro.") if linha[0] == "#": tipo = EnumTipoVariaveis.CONSTANTE linha = linha.replace("#", "") args = linha.split(";") nome = args[0].strip() default = None niveis = None probabilidade = None equacao = None if '=' in linha: tipo = EnumTipoVariaveis.CONDICIONAL if len(args) > 2: self.log( tipo=EnumLogStatus.WARN, texto= f"Para variavel tipo condicional, são usados somentes dois parametros, nome [{args[0]}] e equacao [{args[1]}]." ) equacao = args[1].strip() equacao = equacao.replace("=", "").strip() else: niveis, probabilidade = self._str_2_niveis(args[1].strip()) if len(args) > 2: default = InOut.ajusta_entrada(args[2].strip().replace( "'", "").replace('"', '')) if default == "": self.log( tipo=EnumLogStatus.WARN, texto= f'O valor default, não existe, com isso o default será [{niveis[0]}]' ) default = niveis[0] else: if default in niveis: pass else: self.log( tipo=EnumLogStatus.WARN, texto= f'O valor default [{default}], não existe no domínio, com isso o default será [{niveis[0]}]' ) default = niveis[0] if len(args) > 3: probabilidade = args[3].strip() if probabilidade == "": probabilidade = None else: probabilidade = probabilidade.replace("[", "").replace( "]", "").replace(" ", "").split(",") for ii in range(len(probabilidade)): probabilidade[ii] = InOut.ajusta_entrada( probabilidade[ii]) if len(niveis) != len(probabilidade): self.log( tipo=EnumLogStatus.ERRO_FATAL, texto= f"Quantidade de níveis [{len(niveis)}] é diferente da quantidade de probabilidades [{len(probabilidade)}]." ) return Dominio(nome, niveis, probabilidade, default, equacao, tipo) def _monta_niveis(self, linha, replace): linha = linha.strip() linha = linha.replace(replace, "") args = linha.split(";") if len(args) < 2: self.log(tipo=EnumLogStatus.ERRO_FATAL, texto=f"Dominio {linha} esta com erro.") nome = args[0].strip() default = None niveis, probabilidade = self._str_2_niveis(args[1].strip()) return nome, niveis, probabilidade, default def _str_2_niveis(self, str_niveis: str) -> tuple: """ Converte as string [ | ] ou { } exemplo [1 | 3] ou {1 2 3} em list [1, 2, 3] :param str_niveis: string nos formatos [ | ] ou { } exemplo [1 | 3] ou {1 2 3} :type str_niveis: str :return: list do problema :rtype: list """ niveis = [] probabilidade = [] discretizacao = str_niveis try: if str_niveis.find("[") >= 0: str_niveis = str_niveis.replace(",", "|") if str_niveis.find("{") >= 0: str_niveis = str_niveis.replace(",", " ") if str_niveis.find("[") >= 0 and str_niveis.find( "]") > 0 and str_niveis.find("|") > 0: discretizacao = discretizacao.replace("[", "") discretizacao = discretizacao.replace("]", "") discretizacao = discretizacao.strip() limite = discretizacao.split("|") for rr in range( int(InOut.ajusta_entrada(limite[0].strip())), int(InOut.ajusta_entrada(limite[1].strip())) + 1): niveis.append(InOut.ajusta_entrada(str(rr))) probabilidade.append(0) elif str_niveis.find("{") >= 0 and str_niveis.find("}") > 0: discretizacao = discretizacao.replace("{", "") discretizacao = discretizacao.replace("}", "") discretizacao = discretizacao.strip() possiveis = discretizacao.split(" ") for rr in range(len(possiveis)): niveis.append( InOut.ajusta_entrada(possiveis[rr].strip().replace( "'", "").replace('"', ''))) probabilidade.append(0) if len(niveis) > 0: for ii in range(len(probabilidade)): probabilidade[ii] = 1 / len(probabilidade) except Exception as ex: niveis = [] probabilidade = [] self.log(tipo=EnumLogStatus.ERRO_FATAL, texto=f"Erro para criar problema [{str_niveis}].", info_ex=str(ex)) return niveis, probabilidade
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 _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
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 _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()