Пример #1
0
        /// <summary>
        /// Encerra uma geração
        /// </summary>
        private void FindBestChromosomeOfRun()
        {
            var melhores = new List<Individuo>();
            var originalValue = _fitnessMin;

            foreach (Individuo c in _population)
            {
                double fitness = c.Fitness;

                _fitnessSum += fitness;

                // check for min
                if (fitness < _fitnessMin & fitness> 0)
                {
                    _fitnessMin = fitness;
                    MelhorIndividuo = c;
                    Console.WriteLine("-> Bom! Valor={0}", _fitnessMin);

                    melhores.Add(c);

                }
            }

            if (melhores.Count > 0)
            {
                #region Cria diretorio da geração
                string generationResultPath = Path.Combine(_diretorioExecucao, _generationCount.ToString());
                Directory.CreateDirectory(generationResultPath);
                Thread.Sleep(5);
                #endregion

                foreach (var individuo in melhores)
                {
                    string generationBestPath = string.Format("{0}\\{1}.js", generationResultPath, individuo.Id);

                    File.WriteAllText(generationBestPath, individuo.Codigo);
                }

                if (_generationCount > 0)
                {
                    var di = new DirectoryInfo(_diretorioExecucao);
                    di.EnumerateFiles().Where(n => !n.Name.Contains("resultados")).ToList().ForEach(a => a.Delete());
                }

            }

            _fitnessAvg = ((double) _fitnessSum / _size);
        }
Пример #2
0
        /// <summary>
        /// Otimizar usando um HC que salta os vizinhos de IF e CALL
        /// </summary>
        /// <returns></returns>
        private bool OtimizarUsandoHc()
        {
            var totalVizinhosExplorar = _size * _executarAte;
            var otimizado = false;
            var melhores = new List<Individuo>();

            CriarIndividuoOriginal(_caminhoBiblioteca);

            CalcularVizinhos(_original.Ast);

            Console.WriteLine("      {0} nós para remover (IF, CALL).  ", _nosParaMutacao.Count);

            Console.WriteLine("      Avaliar {0} vizinhos", totalVizinhosExplorar);

            AvaliarIndividuo(0, MelhorIndividuo);

            //IfStatement
            //CallExpression

            var r = new Random();

            int ultimoIndice = r.Next(0, _nosParaMutacao.Count);

            for (int i = 1; i < totalVizinhosExplorar - 1; i++)
            {

                if (_nosParaMutacao.Count <= ultimoIndice) //zera de novo
                    ultimoIndice = 0;

                var no = _nosParaMutacao[ultimoIndice];

                #region cria o vizinho
                Console.WriteLine("      {0}|Nó:{1}|{2}", i, ultimoIndice, no.Tipo);
                Individuo c = MelhorIndividuo.Clone(); //Sempre usando o melhor

                ExecutarMutacao(c, no.Indice);
                #endregion

                ultimoIndice++;

                //Avalia o vizinho e veja se melhorou
                var fitvizinho = AvaliarIndividuo(i, c);

                if (fitvizinho < 0)
                    fitvizinho = fitvizinho * -1;

                if (fitvizinho < _fitnessMin)
                {
                    Console.WriteLine("      Encontrado. FIT Antigo {0} | FIT novo {1}", _fitnessMin, c.Fitness);
                    MelhorIndividuo = c;
                    _fitnessMin = fitvizinho;
                    otimizado = true;
                    melhores.Add(c);

                    CalcularVizinhos(MelhorIndividuo.Ast); //recalculo os nós
                }

                if (_nosParaMutacao.Count == i) //se deu a volta completa pode parar
                    break;

            }

            #region Cria diretorio dos resultados
            string generationResultPath = Path.Combine(_diretorioExecucao, "0");
            Directory.CreateDirectory(generationResultPath);
            Thread.Sleep(5);
            #endregion

            foreach (var individuo in melhores)
            {
                string generationBestPath = string.Format("{0}\\{1}.js", generationResultPath, individuo.Id);

                File.WriteAllText(generationBestPath, individuo.Codigo);
            }

            Console.WriteLine("============================================================");
            Console.WriteLine("  Houve otimizacao: {0}", otimizado);

            return otimizado;
        }
Пример #3
0
        /// <summary>
        /// Executa uma mutação no individuo
        /// </summary>
        /// <param name="sujeito"> </param>
        /// <param name="no"></param>
        private void ExecutarMutacao(Individuo sujeito, int no)
        {
            string novaAst = "";

            var executarMutacao = new Thread(() => novaAst = _javascriptHelper.ExecutarMutacaoExclusao(sujeito.Ast, no));
            executarMutacao.Start();
            executarMutacao.Join(_timeout * 1000); //timeout

            sujeito.Ast = novaAst;
            sujeito.CriadoPor = Operador.Mutacao;
        }
Пример #4
0
        /// <summary>
        /// Executa os testes
        /// </summary>
        /// <param name="indice"></param>
        /// <param name="sujeito"></param>
        /// <returns></returns>
        private double ExecutarTestesParaIndividuoEspecifico(int indice, Individuo sujeito)
        {
            var sw = new Stopwatch();

            const long valorFitFalha = 120000;

            var caminhoNovoAvaliado = GerarCodigo(sujeito);

            #region Codigo Vazio [sujeito inválido]

            if (string.IsNullOrEmpty(sujeito.Codigo) | (!File.Exists(caminhoNovoAvaliado)))
            {
                Console.WriteLine("              Codigo Vazio");

                sujeito.Fitness = valorFitFalha;
                sujeito.TestesComSucesso = 0;
                sujeito.TempoExecucao = sw.Elapsed.ToString(@"hh\:mm\:ss\,ffff");

                Console.WriteLine(string.Format("            FIT:{0}       | CTs: {1}            | T: {2}", sujeito.Fitness,
                                           sujeito.TestesComSucesso, sujeito.TempoExecucao));

                CriarLinhaExcel(indice, sujeito, sujeito.TestesComSucesso, sujeito.TempoExecucao);

                return sujeito.Fitness;
            }

            #endregion

            #region Igual ao Original

            if (indice > 0 & _original.Codigo.Equals(sujeito.Codigo))
            {
                Console.WriteLine("              Igual ao Original");

                sujeito.TempoExecucao = _original.TempoExecucao;
                sujeito.TestesComSucesso = _original.TestesComSucesso;
                sujeito.Fitness = _original.Fitness;
                Console.WriteLine(string.Format("            FIT:{0}       | CTs: {1}            | T: {2}", sujeito.Fitness,
                                           sujeito.TestesComSucesso, sujeito.TempoExecucao));

                CriarLinhaExcel(indice, sujeito, sujeito.TestesComSucesso, sujeito.TempoExecucao);

                return sujeito.Fitness;
            }

            #endregion

            #region realmente executar os testes então

            try
            {
                _javascriptHelper.ConfigurarTimeOut(_timeout);
                _javascriptHelper.ConfigurarMelhorFit(_fitnessMin);

                //Console.WriteLine("              Avaliando via testes");
                sw.Start();
                var avaliar =
                    new Thread(() => sujeito.Fitness = _javascriptHelper.ExecutarTestes(caminhoNovoAvaliado, _caminhoScriptTestes));
                avaliar.Start();
                avaliar.Join(_timeout*1000); //timeout

                sw.Stop();

                //Console.WriteLine("              Executou até o final: {0}", jHelper.ExecutouTestesAteFinal);

                if (!_javascriptHelper.ExecutouTestesAteFinal)
                    sujeito.Fitness = valorFitFalha;

                if (_javascriptHelper.ExecutouTestesAteFinal && _javascriptHelper.TestesComFalha > 0)
                    sujeito.Fitness = valorFitFalha; //+ jHelper.TestesComFalha;

                sujeito.TestesComSucesso = _javascriptHelper.TestesComSucesso;
                sujeito.TempoExecucao = sw.Elapsed.ToString(@"hh\:mm\:ss\,ffff");
            }
            catch (Exception ex)
            {
                //Console.WriteLine("              Executou até o final: {0}", jHelper.ExecutouTestesAteFinal);

                sujeito.Fitness = valorFitFalha;
                sujeito.TestesComSucesso = _javascriptHelper != null ? _javascriptHelper.TestesComSucesso : 0;
                sujeito.TempoExecucao = sw.Elapsed.ToString(@"hh\:mm\:ss\,ffff");

                Console.WriteLine(ex);

            }

            #endregion

            CriarLinhaExcel(indice, sujeito, sujeito.TestesComSucesso, sujeito.TempoExecucao);

            return sujeito.Fitness;
        }
Пример #5
0
        private void ExecutarCruzamento(Individuo pai, Individuo mae, out Individuo filhoPai, out Individuo filhoMae)
        {
            string c1 = "", c2 = "";

            filhoPai = pai.Clone();
            filhoPai.CriadoPor = Operador.Cruzamento;

            filhoMae = mae.Clone();
            filhoMae.CriadoPor = Operador.Cruzamento;

            try
            {

                var totalPai = Rand.Next(0, _total);
                var totalMae = Rand.Next(0, _total);
                _javascriptHelper.ExecutarCrossOver(pai.Ast, mae.Ast, totalPai, totalMae, out c1, out c2);
            }
            catch (Exception ex)
            {
                Console.WriteLine("          Erro ao executar cruzamento");
                //Console.Error(ex.ToString());
            }

            filhoPai.Ast = c1;
            filhoMae.Ast = c2;
        }
Пример #6
0
        private void ExecutarMutacao(Individuo sujeito)
        {
            try
            {
                int totalMutacoes = 1;
                string novaAst = "";

                while (novaAst == "" & totalMutacoes < 5)
                {
                    if (totalMutacoes > 1)
                        Console.WriteLine("          Tentativa {0} de executar mutação", totalMutacoes);

                    int no = Rand.Next(0, _total);

                    var avaliar = new Thread(() => novaAst = _javascriptHelper.ExecutarMutacaoExclusao(sujeito.Ast, no));
                    avaliar.Start();
                    avaliar.Join(_timeout * 1000); //timeout

                    totalMutacoes++;
                }

                sujeito.Ast = novaAst;
                sujeito.CriadoPor = Operador.Mutacao;
            }
            catch (Exception ex)
            {
                Console.WriteLine("          Erro na Mutação");
                //Console.WriteLine("          {0}", ex);

                sujeito.Ast = "";
                sujeito.CriadoPor = Operador.Mutacao;
            }
        }
Пример #7
0
        private void CriarIndividuoOriginal(string caminhoBibliotecaJs)
        {
            var caminho = string.Format("{0}\\{1}", _diretorioFontes, caminhoBibliotecaJs);
            var caminhoDestino = string.Format("{0}\\{1}", _diretorioExecucao, caminhoBibliotecaJs);

            _original = new Individuo
            {
                Arquivo = caminho,
            };

            int contador = 0;

            while (_original.Fitness == Int64.MaxValue & contador < 50)
            {

                Console.WriteLine("      Criando e V8engine - Tentativa {0}", contador);

                try
                {

                    var codigo = File.ReadAllText(caminho);
                    var ast = _javascriptHelper.GerarAst(codigo);

                    _original.Ast = ast;

                    _original.Codigo = _javascriptHelper.GerarCodigo(_original.Ast);
                    File.WriteAllText(caminhoDestino, _original.Codigo);

                    _total = _javascriptHelper.ContarNos(_original.Ast);

                    var sw = new Stopwatch();
                    sw.Start();
                    _original.Fitness = _javascriptHelper.ExecutarTestes(caminhoDestino, _caminhoScriptTestes);
                    sw.Stop();
                    _original.TempoExecucao = sw.Elapsed.ToString(@"hh\:mm\:ss\,ffff");
                    _original.TestesComSucesso = _javascriptHelper.TestesComSucesso;

                    _fitnessMin = _original.Fitness;

                    MelhorIndividuo = _original;

                    break;
                }
                catch (Exception ex)
                {
                    //Console.WriteLine(ex);
                    //Console.WriteLine("Erro na criação do original");

                    //Dorme um minuto e tenta de novo
                    Thread.Sleep(60000);
                    Console.WriteLine(" Falhou ao criar individuo. Tentando novamente.");

                    _javascriptHelper.Dispose();
                    _javascriptHelper = new JavascriptHelper(_diretorioFontes, _usarSetTimeout, false);
                    _javascriptHelper.ConfigurarGeracao();

                }

                contador++;
            }
        }
Пример #8
0
        /// <summary>
        /// Inclui a linha no excel
        /// </summary>
        /// <param name="indice"></param>
        /// <param name="sujeito"></param>
        /// <param name="testesComSucesso"></param>
        /// <param name="tempoTotal"></param>
        private void CriarLinhaExcel(int indice, Individuo sujeito, int testesComSucesso, string tempoTotal)
        {
            #region Inclui no  CSV

            var myExport = new CsvExport();

            myExport.AddRow();

            myExport["Geracao"] = _generationCount;
            myExport["Individuo"] = sujeito.Arquivo;
            myExport["Operacao"] = sujeito.CriadoPor.ToString();
            myExport["Fitness"] = sujeito.Fitness;
            myExport["Tempo"] = tempoTotal;
            myExport["Testes"] = testesComSucesso;

            myExport.ExportToFile(Path.Combine(_diretorioExecucao, "resultados.csv"));

            #endregion
        }
Пример #9
0
        public string GerarCodigo(Individuo sujeito)
        {
            var caminhoNovoAvaliado = string.Format("{0}\\{1}.js", _diretorioExecucao, sujeito.Id);

            try
            {
                sujeito.Codigo = _javascriptHelper.GerarCodigo(sujeito.Ast);

                if (!string.IsNullOrEmpty(sujeito.Codigo))
                {
                    File.WriteAllText(caminhoNovoAvaliado, sujeito.Codigo);
                    sujeito.Arquivo = caminhoNovoAvaliado;
                }
                else
                {
                    sujeito.Arquivo = "";
                }
            }
            catch (Exception ex)
            {
                //Console.WriteLine(ex);
                Console.WriteLine("AST invalida. Codigo nao gerado");
                caminhoNovoAvaliado = "";
            }

            return caminhoNovoAvaliado;
        }
Пример #10
0
        private double AvaliarIndividuo(int indice, Individuo sujeito)
        {
            const int total = 5;
            var fits = new double[total];

            fits[0] = ExecutarTestesParaIndividuoEspecifico(indice, sujeito);

            //Falhou em testes
            if (fits[0].Equals(120000))
            {
                sujeito.Fitness = 120000;
                return 120000;
            }

            //Igual ao original
            if (fits[0].Equals(_fitnessMin))
            {
                sujeito.Fitness = _fitnessMin;
                return _fitnessMin;
            }

            //Realmente executar
            for (int i = 0; i < total; i++)
            {
                fits[i] = ExecutarTestesParaIndividuoEspecifico(indice, sujeito);
                Console.WriteLine("             {0}-{1}", i, fits[i]);
            }

            sujeito.Fitness = fits.Average();
            Console.WriteLine(string.Format("            FIT:{0}     | CTs: {1}      | T: {2}", sujeito.Fitness, sujeito.TestesComSucesso, sujeito.TempoExecucao));

            return sujeito.Fitness;
        }
Пример #11
0
        /// <summary>
        /// Lista de Funcoes com os detalhes para otimizaçao
        /// </summary>
        /// <returns></returns>
        public List<Function> DeterminarListaDeFuncoes(Individuo clone)
        {
            var nos = _javascriptHelper.ContarNosCallee(clone.Ast);

            var funcoesEncontradas = nos.GroupBy(f => f.NomeFuncao).Select(n => new Function { Nome = n.Key, Total = n.Count(), Ast = ""}).OrderByDescending(n => n.Total).ToList();

            _astDasFuncoes = ProcessarAstDasFuncoes(funcoesEncontradas, clone);

            foreach (var funcaoEncontrada in funcoesEncontradas)
            {
                //funcaoEncontrada.Ast =
                funcaoEncontrada.Ast =  _astDasFuncoes.ContainsKey(funcaoEncontrada.Nome) ? _astDasFuncoes[funcaoEncontrada.Nome] : "";
            }

            return funcoesEncontradas;
        }
Пример #12
0
        /// <summary>
        /// Troca a função antiga pela ASTnova
        /// </summary>
        /// <returns></returns>
        public string AtualizarFuncao(Individuo clone, string nomeFuncao, string astFuncaoNova)
        {
            var astFuncao = "";
            try
            {
                astFuncao = _javascriptHelper.AtualizarDeclaracaoFuncaoPeloNome(clone.Ast, nomeFuncao, astFuncaoNova);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Erro ao atualizar a função = {0}", ex.Message);
            }

             return astFuncao;
        }
Пример #13
0
        /// <summary>
        /// Percorre a árvore e junta todos os functions declarations
        /// </summary>
        /// <param name="funcoesEncontradas"></param>
        /// <param name="biblioteca"></param>
        /// <returns></returns>
        private Dictionary<string, string> ProcessarAstDasFuncoes(IEnumerable<Function> funcoesEncontradas, Individuo biblioteca)
        {
            var listaDeNomes = funcoesEncontradas.Select(n => n.Nome).ToList();

            var dicionarioResultado = _javascriptHelper.RecuperarTodasAstDeFuncao(biblioteca.Ast, listaDeNomes);

            return dicionarioResultado;
        }
Пример #14
0
        /// <summary>
        /// Usar Ramdon para otimizar
        /// </summary>
        /// <returns></returns>
        private bool OtimizarUsandoRd()
        {
            var totalVizinhosExplorar = _size * _executarAte;
            var moverNoPrimeiroMelhor = true;
            var otimizado = false;
            var melhores = new List<Individuo>();

            Console.WriteLine("      Avaliar {0} vizinhos", totalVizinhosExplorar);

            CriarIndividuoOriginal(_caminhoBiblioteca);

            AvaliarIndividuo(0, MelhorIndividuo);

            for (int i = 1; i < totalVizinhosExplorar -1; i++)
            {
                //cria o vizinho
                Console.WriteLine("      {0}", i);

                Individuo c = MelhorIndividuo.Clone();

                ExecutarMutacao(c);

                //Avalia o vizinho e veja se melhorou
                var fitvizinho = AvaliarIndividuo(i, c);

                if (fitvizinho < 0)
                    fitvizinho = fitvizinho*-1;

                if (fitvizinho < _fitnessMin)
                {
                    Console.WriteLine("      Encontrado. FIT Antigo {0} | FIT novo {1}", _fitnessMin, c.Fitness);
                    MelhorIndividuo = c;
                    _fitnessMin = fitvizinho;
                    otimizado = true;
                    melhores.Add(c);
                }
            }

            #region Cria diretorio dos resultados
            string generationResultPath = Path.Combine(_diretorioExecucao, "0");
            Directory.CreateDirectory(generationResultPath);
            Thread.Sleep(5);
            #endregion

            foreach (var individuo in melhores)
            {
                string generationBestPath = string.Format("{0}\\{1}.js", generationResultPath, individuo.Id);

                File.WriteAllText(generationBestPath, individuo.Codigo);
            }

            Console.WriteLine("============================================================");
            Console.WriteLine("  Houve otimizacao: {0}", otimizado);

            return otimizado;
        }
Пример #15
0
        /// <summary>
        /// Escopo do HC por função
        /// </summary>
        /// <returns></returns>
        private bool OtimizarUsandoHcPorFuncao()
        {
            var totalVizinhosExplorar = _size * _executarAte;
            var otimizado = false;
            var melhores = new List<Individuo>();
            Console.WriteLine("      Avaliar {0} vizinhos", totalVizinhosExplorar);

            CriarIndividuoOriginal(_caminhoBiblioteca);
            AvaliarIndividuo(0, MelhorIndividuo);
            _fitnessMin = MelhorIndividuo.Fitness;

            var funcoesOtimizar = DeterminarListaDeFuncoes(MelhorIndividuo.Clone());
            int indiceFuncaoAtual = 0;
            //IfStatement
            //CallExpression

            var funcaoEmOtimizacao = funcoesOtimizar[indiceFuncaoAtual];
            var r = new Random();
            //var totalNos = CalcularTodosVizinhos(funcaoEmOtimizacao.Ast);
            CalcularVizinhos(funcaoEmOtimizacao.Ast);// Atualiza a propriedade _nosParaMutacao
            int control = 0;

            Console.WriteLine("     {0} é utlizada {1}x", funcaoEmOtimizacao.Nome, funcaoEmOtimizacao.Total);
            Console.WriteLine("     {0} vizinhos para avaliar", _nosParaMutacao.Count);

            //Explorando os vizinhos
            for (int i = 0; i < totalVizinhosExplorar - 1; i++)
            {
                if (_nosParaMutacao.Count > 0)
                {

                    #region cria o vizinho

                    Console.WriteLine("      {0}|Nó:{1}|{2}", i, control, _nosParaMutacao[control].Tipo);

                    Individuo c = MelhorIndividuo.Clone(); //Sempre usando o melhor

                    //var novaFuncao = ExecutarMutacaoNaFuncao(funcaoEmOtimizacao.Ast, control);
                    var novaFuncao = ExecutarMutacaoNaFuncao(funcaoEmOtimizacao.Ast, _nosParaMutacao[control].Indice);

                    c.Ast = AtualizarFuncao(c, funcaoEmOtimizacao.Nome, novaFuncao);
                    c.CriadoPor = Operador.Mutacao;

                    #endregion

                    #region Avalia o vizinho

                    var fitvizinho = AvaliarIndividuo(i, c);

                    if (fitvizinho < 0)
                        fitvizinho = fitvizinho*-1;

                    if (fitvizinho < _fitnessMin)
                    {
                        Console.WriteLine("      Encontrado. FIT Antigo {0} | FIT novo {1}", _fitnessMin, c.Fitness);
                        MelhorIndividuo = c;
                        _fitnessMin = fitvizinho;
                        otimizado = true;
                        melhores.Add(c);

                        funcaoEmOtimizacao.Ast = novaFuncao; //Atualizo a melhor nova função

                        control = 0;

                        //CalcularVizinhos(ast); //recalculo os nós
                    }

                    #endregion

                    control++;
                }

                #region Critérios de parada
                //Queimou o Orçamento global
                if (i == totalVizinhosExplorar )
                {
                    break;
                }

                //acabaram os nós na função atual?
                if (control == _nosParaMutacao.Count)
                {
                    indiceFuncaoAtual++;
                    if (indiceFuncaoAtual < funcoesOtimizar.Count)
                    {
                        funcaoEmOtimizacao = funcoesOtimizar[indiceFuncaoAtual];
                        //totalNos = CalcularTodosVizinhos(funcaoEmOtimizacao.Ast);
                        CalcularVizinhos(funcaoEmOtimizacao.Ast);
                        control = 0;
                        Console.WriteLine("     {0} é utlizada {1}x", funcaoEmOtimizacao.Nome, funcaoEmOtimizacao.Total);
                        Console.WriteLine("     {0} vizinhos para avaliar", _nosParaMutacao.Count);
                    }
                    else
                    {
                        break;
                    }

                }

                #endregion

            }

            #region Cria diretorio dos resultados
            string generationResultPath = Path.Combine(_diretorioExecucao, "0");
            Directory.CreateDirectory(generationResultPath);
            Thread.Sleep(5);
            #endregion

            foreach (var individuo in melhores)
            {
                string generationBestPath = string.Format("{0}\\{1}.js", generationResultPath, individuo.Id);

                File.WriteAllText(generationBestPath, individuo.Codigo);
            }

            Console.WriteLine("============================================================");
            Console.WriteLine("  Houve otimizacao: {0}", otimizado);

            return otimizado;
        }