Changeset 5144 for branches/HeuristicLab.MetaOptimization/HeuristicLab.MetaOptimization.Test/Program.cs

Timestamp:

12/21/10 01:13:49 (13 years ago)

Author:

cneumuel

Message:

#1215

• added possibility to create all parameter combinations from a ParameterConfigurationTree and generate an experiment from them

File:

• branches/HeuristicLab.MetaOptimization/HeuristicLab.MetaOptimization.Test/Program.cs (modified) (15 diffs)

branches/HeuristicLab.MetaOptimization/HeuristicLab.MetaOptimization.Test/Program.cs

@@ -1 @@
-using System.Collections.Generic;
-using System.Diagnostics;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
 using System.Linq;
+using System.Text;
+using System.Threading;
+using HeuristicLab.Algorithms.EvolutionStrategy;
 using HeuristicLab.Algorithms.GeneticAlgorithm;
+using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
 using HeuristicLab.PluginInfrastructure;
-using HeuristicLab.Parameters;
 using HeuristicLab.Problems.MetaOptimization;
-using HeuristicLab.Data;
-using System;
-using System.Threading;
+using HeuristicLab.Problems.TestFunctions;
 using HeuristicLab.Random;
-using HeuristicLab.Optimization;
-using HeuristicLab.Common;
-using System.IO;
-using HeuristicLab.Problems.TestFunctions;
-using System.Text;
 using HeuristicLab.Selection;
-using HeuristicLab.Algorithms.EvolutionStrategy;
-using HeuristicLab.PluginInfrastructure.Manager;
 
 namespace HeuristicLab.MetaOptimization.Test {
@@ -35 +33 @@
       //TestTypeDiscovery();
       //TestOperators();
-      
+      //TestCombinations();
+      //TestCombinations2();
+      //TestCombinations3();
+      TestCombinations4();
+
       GeneticAlgorithm baseLevelAlgorithm = new GeneticAlgorithm();
 
@@ -45 +47 @@
       IValueConfiguration algorithmVc = SetupGAAlgorithm(baseLevelAlgorithm, metaOptimizationProblem);
 
+      //TestToString(algorithmVc);
+
+
       //Console.WriteLine("Press enter to start");
       //Console.ReadLine();
       //TestConfiguration(algorithmVc, baseLevelAlgorithm);
-      
+
       //Console.WriteLine("Press enter to start");
       //Console.ReadLine();
@@ -58 +63 @@
     }
 
+    private static void TestToString(IValueConfiguration algorithmVc) {
+      var random = new MersenneTwister();
+      Console.WriteLine(algorithmVc.ToParameterInfoString());
+      algorithmVc.Randomize(random);
+      Console.WriteLine(algorithmVc.ToParameterInfoString());
+      algorithmVc.Randomize(random);
+      Console.WriteLine(algorithmVc.ToParameterInfoString());
+      algorithmVc.Randomize(random);
+    }
+
+    private static void TestCombinations() {
+      Console.WriteLine("IntRange 3-18:3");
+      IntValueRange intRange = new IntValueRange(new IntValue(3), new IntValue(18), new IntValue(3));
+      foreach (var val in intRange.GetCombinations()) {
+        Console.WriteLine(val);
+      }
+
+      Console.WriteLine("DoubleRange 1.0-2.5:0.5");
+      var dblRange = new DoubleValueRange(new DoubleValue(0.7), new DoubleValue(2.8), new DoubleValue(0.5));
+      foreach (var val in dblRange.GetCombinations()) {
+        Console.WriteLine(val);
+      }
+
+      Console.WriteLine("PercentRange 33%-66%:33%");
+      var pctRange = new PercentValueRange(new PercentValue(0.32), new PercentValue(0.98), new PercentValue(0.33));
+      foreach (var val in pctRange.GetCombinations()) {
+        Console.WriteLine(val);
+      }
+    }
+
+    private static void TestCombinations3() {
+      Node root = new Node("root");
+      root.ChildNodes.Add(new Node("root.n1"));
+      root.ChildNodes.Add(new Node("root.n2"));
+      Node n3 = new Node("root.n3");
+      n3.ChildNodes.Add(new Node("root.n3.n1"));
+      n3.ChildNodes.Add(new Node("root.n3.n2"));
+      root.ChildNodes.Add(n3);
+
+      Console.WriteLine(root.ToString());
+      Console.WriteLine("--");
+      int cnt = 0;
+      var enumerator = new NodeEnumerator(root);
+      enumerator.Reset();
+      while (enumerator.MoveNext()) {
+        Console.WriteLine(enumerator.Current.ToString());
+        cnt++;
+      }
+      Console.WriteLine("count: " + cnt);
+    }
+
+    private static void TestCombinations4() {
+      GeneticAlgorithm ga = new GeneticAlgorithm();
+      ga.Problem = new SingleObjectiveTestFunctionProblem();
+      ParameterConfigurationTree vc = new ParameterConfigurationTree(ga);
+
+      //ConfigurePopulationSize(vc, 20, 100, 20);
+      //ConfigureMutationRate(vc, 0.10, 0.60, 0.10);
+      ConfigureMutationOperator(vc);
+      ConfigureSelectionOperator(vc, false);
+
+      //foreach (var combination in vc.IterateCombinations()) {
+      //  Console.WriteLine(combination.ToParameterInfoString());
+      //}
+
+      int count = 0;
+      IEnumerator enumerator = new ParameterCombinationsEnumerator(vc);
+      enumerator.Reset();
+      while (enumerator.MoveNext()) {
+        var current = (IValueConfiguration)enumerator.Current;
+        count++;
+        Console.WriteLine(current.ToParameterInfoString());
+      }
+      Console.WriteLine("You are about to create {0} algorithms.", count);
+
+      Experiment experiment = vc.GenerateExperiment(ga);
+      foreach (var opt in experiment.Optimizers) {
+        Console.WriteLine(opt.Name);
+      }
+    }
+
     private static void TestOperators() {
       IRandom random = new MersenneTwister();
@@ -64 +150 @@
       manip.IntValueManipulatorParameter.ActualValue = new UniformIntValueManipulator();
       manip.DoubleValueManipulatorParameter.ActualValue = new NormalDoubleValueManipulator();
-      
+
       var doubleRange = new DoubleValueRange(new DoubleValue(0), new DoubleValue(100), new DoubleValue(0.1));
       using (var sw = new StreamWriter("out-DoubleValue.txt")) {
@@ -70 +156 @@
           var val = new DoubleValue(50);
           NormalDoubleValueManipulator.ApplyStatic(random, val, doubleRange);
-          
+
           sw.WriteLine(val);
         }
@@ -98 +184 @@
     private static void TestTypeDiscovery() {
       PluginLoader.pluginAssemblies.Any();
-      
+
       var items = ApplicationManager.Manager.GetInstances(typeof(DoubleArray)).ToArray();
 
@@ -107 +193 @@
 
     private static void TestMemoryLeak(GeneticAlgorithm metaLevelAlgorithm) {
-      IValueConfiguration algorithmVc = ((MetaOptimizationProblem)metaLevelAlgorithm.Problem).AlgorithmParameterConfiguration;
+      IValueConfiguration algorithmVc = ((MetaOptimizationProblem)metaLevelAlgorithm.Problem).ParameterConfigurationTree;
 
       Console.WriteLine("Starting Memory Test...");
@@ -160 +246 @@
 
       metaOptimizationProblem.Algorithm = baseLevelAlgorithm;
-      IValueConfiguration algorithmVc = metaOptimizationProblem.AlgorithmParameterConfiguration;
+      IValueConfiguration algorithmVc = metaOptimizationProblem.ParameterConfigurationTree;
 
       metaOptimizationProblem.Problems.Add(new HeuristicLab.Problems.TestFunctions.SingleObjectiveTestFunctionProblem() {
@@ -171 +257 @@
       });
 
-      ConfigurePopulationSize(algorithmVc);
-      ConfigureMutationRate(algorithmVc);
+      ConfigurePopulationSize(algorithmVc, 20, 100, 1);
+      ConfigureMutationRate(algorithmVc, 0.0, 1.0, 0.01);
       ConfigureMutationOperator(algorithmVc);
       ConfigureElites(algorithmVc);
-      ConfigureSelectionOperator(algorithmVc);
+      ConfigureSelectionOperator(algorithmVc, true);
       return algorithmVc;
     }
@@ -203 +289 @@
         GeneticAlgorithm newAlg = (GeneticAlgorithm)baseLevelAlgorithm.Clone();
         //clonedVc.Mutate(rand);
-        
+
         //.Apply(rand, clonedVc); todo
         clonedVc.Parameterize(newAlg);
@@ -259 +345 @@
     }
 
-    private static void ConfigureSelectionOperator(IValueConfiguration algorithmVc) {
+    private static void ConfigureSelectionOperator(IValueConfiguration algorithmVc, bool configureTournamenSize) {
       var selectionOperatorPc = algorithmVc.ParameterConfigurations.Where(x => x.Name == "Selector").SingleOrDefault();
       selectionOperatorPc.Optimize = true;
@@ -266 +352 @@
         if (vc.ActualValue.ValueDataType == typeof(TournamentSelector)) {
           selectionOperatorPc.ValueConfigurations.SetItemCheckedState(vc, true);
-          vc.Optimize = true;
-          ConfigureTournamentGroupSize(vc);
+          if (configureTournamenSize) {
+            vc.Optimize = true;
+            ConfigureTournamentGroupSize(vc);
+          }
         } else if (vc.ActualValue.ValueDataType == typeof(RandomSelector)) {
           selectionOperatorPc.ValueConfigurations.SetItemCheckedState(vc, true);
@@ -286 +374 @@
     }
 
-    private static void ConfigurePopulationSize(IValueConfiguration algorithmVc) {
+    private static void ConfigurePopulationSize(IValueConfiguration algorithmVc, int lower, int upper, int stepsize) {
       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(20);
-      populationSizeVc.RangeConstraint.UpperBound = new IntValue(100);
-      populationSizeVc.RangeConstraint.StepSize = new IntValue(1);
-    }
-
-    private static void ConfigureMutationRate(IValueConfiguration algorithmVc) {
+      populationSizeVc.RangeConstraint.LowerBound = new IntValue(lower);
+      populationSizeVc.RangeConstraint.UpperBound = new IntValue(upper);
+      populationSizeVc.RangeConstraint.StepSize = new IntValue(stepsize);
+    }
+
+    private static void ConfigureMutationRate(IValueConfiguration algorithmVc, double lower, double upper, double stepsize) {
       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);
+      mutationRateVc.RangeConstraint.LowerBound = new PercentValue(lower);
+      mutationRateVc.RangeConstraint.UpperBound = new PercentValue(upper);
+      mutationRateVc.RangeConstraint.StepSize = new PercentValue(stepsize);
     }
 
@@ -446 +534 @@
     }
   }
+
+  public class Node {
+    public string Name { get; set; }
+    public int ActualValue { get; set; }
+    public int[] PossibleValues { get; set; }
+    public List<Node> ChildNodes { get; set; }
+
+    public Node(string name) {
+      this.Name = name;
+      PossibleValues = new int[] { 1, 2, 3 };
+      ChildNodes = new List<Node>();
+    }
+
+    public void Init() {
+      this.ActualValue = PossibleValues.First();
+      foreach (var child in ChildNodes) {
+        child.Init();
+      }
+    }
+
+    public IEnumerable<Node> IterateCombinations() {
+      foreach (int val in PossibleValues) {
+        this.ActualValue = val;
+        if (ChildNodes.Count > 0) {
+          List<IEnumerable<Node>> lists = new List<IEnumerable<Node>>();
+          List<IEnumerator<Node>> enumerators = new List<IEnumerator<Node>>();
+
+          foreach (Node child in ChildNodes) {
+            IEnumerable<Node> combinations = child.IterateCombinations();
+            IEnumerator<Node> enumerator = combinations.GetEnumerator();
+            enumerator.MoveNext(); // initialize
+            lists.Add(combinations);
+            enumerators.Add(enumerator);
+          }
+
+
+          bool abort = false;
+          while (!abort) {
+            abort = true;
+            foreach (var enumerator in enumerators) {
+              if (enumerator.MoveNext()) {
+                abort = false;
+                yield return this;
+              }
+            }
+          }
+
+        } else {
+          yield return this;
+        }
+      }
+    }
+
+    public override string ToString() {
+      StringBuilder sb = new StringBuilder();
+      sb.Append(string.Format("{0}:{1}", this.Name, this.ActualValue));
+      if (this.ChildNodes.Count() > 0) {
+        sb.Append(" (");
+        var lst = new List<string>();
+        foreach (Node child in ChildNodes) {
+          lst.Add(child.ToString());
+        }
+        sb.Append(string.Join(", ", lst.ToArray()));
+        sb.Append(")");
+      }
+
+      return sb.ToString();
+    }
+  }
+
+  public class NodeEnumerator : IEnumerator<Node> {
+    private Node node;
+    private List<IEnumerator> enumerators;
+
+    public NodeEnumerator(Node node) {
+      this.node = node;
+      this.enumerators = new List<IEnumerator>();
+    }
+
+    public Node Current {
+      get { return node; }
+    }
+    object IEnumerator.Current {
+      get { return Current; }
+    }
+
+    public void Dispose() { }
+
+    public bool MoveNext() {
+      int i = 0;
+      bool ok = false;
+      while(!ok && i < enumerators.Count) {
+        if(enumerators[i].MoveNext()) {
+          ok = true;
+        } else {
+          i++;
+        }
+      }
+
+      if (ok) {
+        for (int k = i-1; k >= 0; k--) {
+          enumerators[k].Reset();
+          enumerators[k].MoveNext();
+        }
+      } else {
+        return false;
+      }
+
+      node.ActualValue = (int)enumerators[0].Current;
+      return true;
+    }
+
+    public void Reset() {
+      enumerators.Clear();
+      enumerators.Add(node.PossibleValues.GetEnumerator());
+      enumerators[0].Reset();
+
+      foreach (var child in node.ChildNodes) {
+        var enumerator = new NodeEnumerator(child);
+        enumerator.Reset();
+        enumerator.MoveNext();
+        enumerators.Add(enumerator);
+      }
+    }
+  }
 }