source: branches/PushGP/HeuristicLab.PushGP/Push.Thesis/Program.cs @ 15334

using System.Linq;
using System.Text;

namespace Push.Thesis {
  using System.IO;
  using System.Threading.Tasks;

  using HeuristicLab.Algorithms.GeneticAlgorithm;
  using HeuristicLab.BenchmarkSuite;
  using HeuristicLab.Optimization;
  using HeuristicLab.ParallelEngine;
  using HeuristicLab.Persistence.Default.Xml;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Analyzer;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Crossover;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Extensions;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Manipulator;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Problem.BenchmarkSuite;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Selector;

  class Program {
    static void Main(string[] args) {
      //BuildListOfInstructions();
      GenerateRuns();
      GenerateExperiments();
      //GenerateExperimentWithAllProblems();
    }

    private static void GenerateExperimentWithAllProblems() {
      var provider = new BenchmarkSuiteInstanceProvider();

      var algs = provider
        .GetDataDescriptors()
        .AsParallel()
        .Select(descriptor => new Run(GetAlgorithm((IBenchmarkSuiteDataDescriptor)descriptor)))
        .ToList();

      var experiment = new Experiment("Experiment Benchmark Suite");
      experiment.Runs.AddRange(algs);

      XmlGenerator.Serialize(experiment, @"C:\tmp\Plush - GA\Experiment Benchmark Suite.hl");
    }

    static void GenerateRuns() {
      var provider = new BenchmarkSuiteInstanceProvider();
      var descriptors = provider.GetDataDescriptors();

      Parallel.ForEach(descriptors, descriptor => {
        var benchmarkSuiteProblemDescriptor = (BenchmarkSuiteDataDescriptor)descriptor;
        var alg = GetAlgorithm(benchmarkSuiteProblemDescriptor);

        XmlGenerator.Serialize(alg, $@"C:\tmp\Plush - GA\Runs\{descriptor.Name}.hl");
      });
    }

    static void GenerateExperiments() {
      var provider = new BenchmarkSuiteInstanceProvider();
      var descriptors = provider.GetDataDescriptors();

      Parallel.ForEach(descriptors, descriptor => {
        var benchmarkSuiteProblemDescriptor = (BenchmarkSuiteDataDescriptor)descriptor;
        var alg = GetAlgorithm(benchmarkSuiteProblemDescriptor);
        var experiment = GetExperiment(alg, 10);

        XmlGenerator.Serialize(experiment, $@"C:\tmp\Plush - GA\Experiments\Experiment_{descriptor.Name}.hl");
      });
    }

    static Experiment GetExperiment(IAlgorithm alg, int repeats) {
      var experiment = new Experiment("Experiment: " + alg.Problem.Name);
      experiment.Optimizers.Add(new BatchRun {
        Optimizer = alg,
        Repetitions = repeats
      });

      return experiment;
    }

    static IAlgorithm GetAlgorithm(IBenchmarkSuiteDataDescriptor descriptor) {
      var ga = new GeneticAlgorithm();

      var problemData = descriptor.CreateProblemData();
      var pushProblem = new PlushPushBenchmarkSuiteProblem();

      pushProblem.Load(problemData);
      ga.Name = "GA " + pushProblem.Name;

      ga.Problem = pushProblem;

      var crossover = ga.CrossoverParameter.ValidValues.OfType<AlternationCrossover>().First();

      switch (problemData.ProblemType) {
        case ProblemType.NumberIO:
        case ProblemType.SmallOrLarge:
        case ProblemType.Median:
        case ProblemType.Smallest:
          crossover.AlignmentDeviation = 5;
          break;

        default:
          crossover.AlignmentDeviation = 10;
          break;
      }

      crossover.AlternationRate = 0.01;
      ga.Crossover = crossover;

      ga.Selector = ga.SelectorParameter.ValidValues.OfType<LexicaseSelector>().First();

      var mutator = ga.MutatorParameter.ValidValues.OfType<UniformMutation>().First();
      mutator.InstructionMutationProbability = 0.875;
      mutator.CloseMutationProbability = 0.125;
      mutator.CloseIncrementRate = 0.1;
      ga.Mutator = mutator;

      ga.MutationProbability.Value = 0.8;
      ga.SetSeedRandomly.Value = true;
      ga.PopulationSize.Value = 1000;

      ga.MaximumGenerations.Value = problemData.ProgramExecutionBudget / problemData.TrainingCount / 1000;

      var zeroErrorAnalyzer = pushProblem.OperatorsParameter.Value
        .OfType<IndividualZeroErrorAnalyzer>().SingleOrDefault();

      if (zeroErrorAnalyzer != null) {
        zeroErrorAnalyzer.StoreHistoryParameter.Value.Value = true;
        zeroErrorAnalyzer.UpdateIntervalParameter.Value.Value = 5;
      }

      ga.Engine = new ParallelEngine();

      return ga;
    }

    static void BuildListOfInstructions() {
      var sb = new StringBuilder();
      var attributes = ExpressionTable.StatelessExpressionTable.Values.Select(e => {
        var type = e.GetType();
        var attribute = ExpressionTable.TypeToAttributeTable[type];

        return attribute;
      }).ToList();

      var attributesGrouped = attributes.GroupBy(a => a.StackType).OrderBy(g => g.Key.ToString());

      foreach (var entry in attributesGrouped) {
        sb.AppendLine($"\\textbf{{{entry.Key}}}");
        sb.AppendLine("\\begin{description}");

        foreach (var attribute in entry) {
          var name = attribute.Name
            .Replace("_", "\\_")
            .Replace("%", "\\%");

          sb.AppendLine($"\\item[{{{name}}}] {attribute.Description}");

          if (attribute.RequiredBlockCount > 0)
            sb.AppendLine($"\\\\block wants: {attribute.RequiredBlockCount}");

          if (attribute.AdditionalStackDependencies != default(HeuristicLab.Problems.ProgramSynthesis.Push.Stack.StackTypes)) {
            var dependenciesNames = attribute.AdditionalStackDependencies.ToValues().Select(v => v.ToString()).OrderBy(x => x);
            var dependenciesStr = string.Join(", ", dependenciesNames);

            sb.AppendLine($"\\\\dependencies: {dependenciesStr}");
          }

        }

        sb.AppendLine("\\end{description}");
      }


      File.WriteAllText(@"T:\BTSync\projects\git\bitbucket\master\Paper\appendix\instructions.tex", sb.ToString());
    }
  }
}