/// <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);
}
/// <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;
}
/// <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;
}
/// <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;
}
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;
}
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;
}
}
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++;
}
}
/// <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
}
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;
}
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;
}
/// <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;
}
/// <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;
}
/// <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;
}
/// <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;
}
/// <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;
}