source: branches/HeuristicLab.MetaOptimization/HeuristicLab.MetaOptimization.Test/Program.cs @ 5009

using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using HeuristicLab.Algorithms.GeneticAlgorithm;
using HeuristicLab.Core;
using HeuristicLab.PluginInfrastructure;
using HeuristicLab.Parameters;
using HeuristicLab.Problems.MetaOptimization;
using HeuristicLab.Data;
using System;
using System.Threading;
using HeuristicLab.Random;
using HeuristicLab.Optimization;

namespace HeuristicLab.MetaOptimization.Test {
  class Program {
    private static int metaAlgorithmPopulationSize = 20;
    private static int metaAlgorithmMaxGenerations = 100;

    private static int baseAlgorithmPopulationSize = 20;
    private static int baseAlgorithmMaxGenerations = 30;

    static void Main(string[] args) {
      //TestIntSampling();
      //TestDoubleSampling();

      GeneticAlgorithm baseLevelAlgorithm = new GeneticAlgorithm();
      MetaOptimizationProblem metaOptimizationProblem = new MetaOptimizationProblem();
      GeneticAlgorithm metaLevelAlgorithm = GetMetaAlgorithm(metaOptimizationProblem);

      IValueConfiguration algorithmVc = SetupAlgorithm(baseLevelAlgorithm, metaOptimizationProblem);

      Console.WriteLine("Press enter to start");
      Console.ReadLine();
      TestConfiguration(algorithmVc, baseLevelAlgorithm);

      Console.WriteLine("Press enter to start");
      Console.ReadLine();
      TestOptimization(metaLevelAlgorithm);

      //TestMemoryLeak(metaLevelAlgorithm);

      Console.ReadLine();
    }

    private static void TestMemoryLeak(GeneticAlgorithm metaLevelAlgorithm) {
      IValueConfiguration algorithmVc = ((MetaOptimizationProblem)metaLevelAlgorithm.Problem).AlgorithmParameterConfiguration;

      Console.WriteLine("Starting Memory Test...");
      Console.ReadLine();

      for (int i = 0; i < 1000; i++) {
        var clone = algorithmVc.Clone();
      }

      Console.WriteLine("Finished. Now GC...");
      Console.ReadLine();

      GC.Collect();

      Console.WriteLine("Finished!");
      Console.ReadLine();
    }

    private static GeneticAlgorithm GetMetaAlgorithm(MetaOptimizationProblem metaOptimizationProblem) {
      GeneticAlgorithm metaLevelAlgorithm = new GeneticAlgorithm();
      metaLevelAlgorithm.PopulationSize.Value = metaAlgorithmPopulationSize;
      metaLevelAlgorithm.MaximumGenerations.Value = metaAlgorithmMaxGenerations;

      metaLevelAlgorithm.Problem = metaOptimizationProblem;
      metaLevelAlgorithm.Engine = new SequentialEngine.SequentialEngine();
      return metaLevelAlgorithm;
    }

    private static IValueConfiguration SetupAlgorithm(GeneticAlgorithm baseLevelAlgorithm, MetaOptimizationProblem metaOptimizationProblem) {
      baseLevelAlgorithm.Problem = new HeuristicLab.Problems.TestFunctions.SingleObjectiveTestFunctionProblem() { ProblemSize = new IntValue(2000) };
      baseLevelAlgorithm.PopulationSize.Value = baseAlgorithmPopulationSize;
      baseLevelAlgorithm.MaximumGenerations.Value = baseAlgorithmMaxGenerations;

      metaOptimizationProblem.Algorithm = baseLevelAlgorithm;
      IValueConfiguration algorithmVc = metaOptimizationProblem.AlgorithmParameterConfiguration;
      metaOptimizationProblem.Problems.Add(new HeuristicLab.Problems.TestFunctions.SingleObjectiveTestFunctionProblem());

      ConfigurePopulationSize(algorithmVc);
      ConfigureMutationRate(algorithmVc);
      ConfigureMutationOperator(algorithmVc);
      return algorithmVc;
    }

    private static void TestConfiguration(IValueConfiguration algorithmVc, GeneticAlgorithm baseLevelAlgorithm) {
      IRandom rand = new MersenneTwister();
      // set random values
      for (int i = 0; i < 10; i++) {
        IValueConfiguration clonedVc = (IValueConfiguration)algorithmVc.Clone();
        clonedVc.Randomize(rand);
        clonedVc.Parameterize((GeneticAlgorithm)clonedVc.ActualValue.Value);
        GeneticAlgorithm newAlg = (GeneticAlgorithm)clonedVc.ActualValue.Value;
        Console.WriteLine(string.Format("PopSize: original: {0}, randomized: {1}", baseLevelAlgorithm.PopulationSize, newAlg.PopulationSize));
        Console.WriteLine(string.Format("MutRate: original: {0}, randomized: {1}", baseLevelAlgorithm.MutationProbability, newAlg.MutationProbability));
        Console.WriteLine(string.Format("MutOp: original: {0}, randomized: {1}", baseLevelAlgorithm.Mutator, newAlg.Mutator));
      }

      // mutate
      for (int i = 0; i < 10; i++) {
        IValueConfiguration clonedVc = (IValueConfiguration)algorithmVc.Clone();
        clonedVc.Mutate(rand);
        clonedVc.Parameterize((GeneticAlgorithm)clonedVc.ActualValue.Value);
        GeneticAlgorithm newAlg = (GeneticAlgorithm)clonedVc.ActualValue.Value;
        Console.WriteLine(string.Format("PopSize: original: {0}, mutated: {1}", baseLevelAlgorithm.PopulationSize, newAlg.PopulationSize));
        Console.WriteLine(string.Format("MutRate: original: {0}, mutated: {1}", baseLevelAlgorithm.MutationProbability, newAlg.MutationProbability));
        Console.WriteLine(string.Format("MutOp: original: {0}, mutated: {1}", baseLevelAlgorithm.Mutator, newAlg.Mutator));
      }

      // cross
      for (int i = 0; i < 10; i++) {
        IValueConfiguration clonedVc1 = (IValueConfiguration)algorithmVc.Clone();
        clonedVc1.Randomize(rand);
        clonedVc1.Parameterize(baseLevelAlgorithm);

        IValueConfiguration clonedVc2 = (IValueConfiguration)algorithmVc.Clone();
        GeneticAlgorithm first = (GeneticAlgorithm)clonedVc1.ActualValue.Value;
        GeneticAlgorithm second = (GeneticAlgorithm)clonedVc2.ActualValue.Value;

        var popSizeBefore = first.PopulationSize.Value;
        var mutRateBefore = first.MutationProbability.Value;
        var mutOpBefore = first.Mutator;

        clonedVc1.Cross(clonedVc2, rand);
        clonedVc1.Parameterize((GeneticAlgorithm)clonedVc2.ActualValue.Value);

        Console.WriteLine(string.Format("PopSize: first: {0}, second: {1}, crossed: {2}", popSizeBefore, second.PopulationSize, first.PopulationSize));
        Console.WriteLine(string.Format("MutRate: first: {0}, second: {1}, crossed: {2}", mutRateBefore, second.MutationProbability, first.MutationProbability));
        Console.WriteLine(string.Format("MutRate: first: {0}, second: {1}, crossed: {2}", mutOpBefore, second.Mutator, first.Mutator));
      }
    }

    private static void ConfigureMutationOperator(IValueConfiguration algorithmVc) {
      var mutationOperator = algorithmVc.ParameterConfigurations.Where(x => x.Name == "Mutator").SingleOrDefault();
      mutationOperator.Optimize = true;

      // uncheck multiMutator to avoid Michalewicz issue
      var multiMutator = mutationOperator.ValueConfigurations.Where(x => x.ActualValue.Value.ItemName.StartsWith("Multi")).SingleOrDefault();
      if (multiMutator != null) {
        mutationOperator.ValueConfigurations.SetItemCheckedState(multiMutator, false);
      }
    }

    private static void ConfigurePopulationSize(IValueConfiguration algorithmVc) {
      var populationSizePc = algorithmVc.ParameterConfigurations.Where(x => x.Name == "PopulationSize").SingleOrDefault();
      populationSizePc.Optimize = true;
      var populationSizeVc = populationSizePc.ValueConfigurations.First();
      populationSizeVc.Optimize = true;
      populationSizeVc.RangeConstraint.LowerBound = new IntValue(0);
      populationSizeVc.RangeConstraint.UpperBound = new IntValue(100);
      populationSizeVc.RangeConstraint.StepSize = new IntValue(1);
    }

    private static void ConfigureMutationRate(IValueConfiguration algorithmVc) {
      var mutationRatePc = algorithmVc.ParameterConfigurations.Where(x => x.Name == "MutationProbability").SingleOrDefault();
      mutationRatePc.Optimize = true;
      var mutationRateVc = mutationRatePc.ValueConfigurations.First();
      mutationRateVc.Optimize = true;
      mutationRateVc.RangeConstraint.LowerBound = new PercentValue(0.0);
      mutationRateVc.RangeConstraint.UpperBound = new PercentValue(1.0);
      mutationRateVc.RangeConstraint.StepSize = new PercentValue(0.01);
    }

    private static void TestOptimization(GeneticAlgorithm metaLevelAlgorithm) {
      metaLevelAlgorithm.Start();
      do {
        Thread.Sleep(1000);
        Console.Clear();
        try {
          foreach (var result in metaLevelAlgorithm.Results) {
            Console.WriteLine(result.ToString());
            if (result.Name == "Population") {
              RunCollection rc = (RunCollection)result.Value;
              var orderedRuns = rc.OrderBy(x => x.Results["BestQuality"]);
              foreach (IRun run in orderedRuns) {
                Console.WriteLine("Q: {0} PoSi: {1} MuRa: {2} MuOp: {3}",
                  ((DoubleValue)run.Results["BestQuality"]).Value.ToString("0.00").PadLeft(4, ' '),
                  ((IntValue)run.Parameters["PopulationSize"]).Value.ToString().PadLeft(3, ' '),
                  ((DoubleValue)run.Parameters["MutationProbability"]).Value.ToString("0.00").PadRight(3, ' '),
                  run.Parameters["Mutator"]);
              }
            }
          }
        }
        catch { }
      } while (metaLevelAlgorithm.ExecutionState != ExecutionState.Stopped);

      Console.WriteLine("Finished");
    }

    private static void TestIntSampling() {
      System.Random rand = new System.Random();
      int lower = 10;
      int upper = 20;
      int stepsize = 7;
      for (int i = 0; i < 100; i++) {
        int val;
        do {
          val = rand.Next(lower / stepsize, upper / stepsize + 1) * stepsize;
        } while (val < lower || val > upper);
        Console.WriteLine(val);
      }
    }

    private static void TestDoubleSampling() {
      System.Random rand = new System.Random();
      double lower = 2;
      double upper = 3;
      double stepsize = 0.6;
      for (int i = 0; i < 100; i++) {
        double val;
        do {
          val = Math.Round((rand.NextDouble() * (upper - lower) + lower) / stepsize, 0) * stepsize;
        } while (val < lower || val > upper);
        Console.WriteLine(val);
      }
    }

    private static IEnumerable<IItem> GetValidValues(IValueParameter valueParameter) {
      return ApplicationManager.Manager.GetInstances(valueParameter.DataType).Select(x => (IItem)x).OrderBy(x => x.ItemName);
    }
  }
}