Changeset 5087 for branches/HeuristicLab.MetaOptimization

Timestamp:

12/12/10 11:34:13 (14 years ago)

Author:

cneumuel

Message:

#1215

• enabled multiple problems
• enabled n repetitions
• improved results output
• reduced memory footprint significantly
• removed viewhost icons for less screen space waste

Location:

branches/HeuristicLab.MetaOptimization

Files:

• HeuristicLab.MetaOptimization.Test/Program.cs (modified) (7 diffs)
• HeuristicLab.Problems.MetaOptimization.Views/3.3/OptimizableView.Designer.cs (modified) (1 diff)
• HeuristicLab.Problems.MetaOptimization.Views/3.3/OptimizableView.cs (modified) (2 diffs)
• HeuristicLab.Problems.MetaOptimization.Views/3.3/ValueConfigurationViews/ValueConfigurationCheckedItemList.cs (modified) (1 diff)
• HeuristicLab.Problems.MetaOptimization.Views/3.3/ValueConfigurationViews/ValueView.Designer.cs (modified) (1 diff)
• HeuristicLab.Problems.MetaOptimization.Views/3.3/ValueConfigurationViews/ValueView.resx (modified) (1 diff)
• HeuristicLab.Problems.MetaOptimization/3.3/Analyzers/BestParameterConfigurationAnalyzer.cs (modified) (3 diffs)
• HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ParameterConfigurationTree.cs (modified) (9 diffs)
• HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ParameterConfigurations/ParameterConfiguration.cs (modified) (2 diffs)
• HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ValueConfigurations/ValueConfiguration.cs (modified) (5 diffs)
• HeuristicLab.Problems.MetaOptimization/3.3/Evaluators/MetaOptimizationEvaluator.cs (modified) (3 diffs)
• HeuristicLab.Problems.MetaOptimization/3.3/HeuristicLab.Problems.MetaOptimization-3.3.csproj (modified) (1 diff)
• HeuristicLab.Problems.MetaOptimization/3.3/MetaOptimizationProblem.cs (modified) (1 diff)

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

@@ -17 +17 @@
 using System.Text;
 using HeuristicLab.Selection;
+using HeuristicLab.Algorithms.EvolutionStrategy;
 
 namespace HeuristicLab.MetaOptimization.Test {
   class Program {
-    private static int metaAlgorithmPopulationSize = 40;
+    private static int metaAlgorithmPopulationSize = 50;
     private static int metaAlgorithmMaxGenerations = 30;
-
-    private static int baseAlgorithmMaxGenerations = 100;
+    private static int metaProblemRepetitions = 3;
+
+    private static int baseAlgorithmMaxGenerations = 250;
 
     static void Main(string[] args) {
+      //TestShorten();
+
       //TestIntSampling();
       //TestDoubleSampling();
 
       GeneticAlgorithm baseLevelAlgorithm = new GeneticAlgorithm();
+
       MetaOptimizationProblem metaOptimizationProblem = new MetaOptimizationProblem();
-      GeneticAlgorithm metaLevelAlgorithm = GetMetaAlgorithm(metaOptimizationProblem);
-
-      IValueConfiguration algorithmVc = SetupAlgorithm(baseLevelAlgorithm, metaOptimizationProblem);
+      ((MetaOptimizationEvaluator)metaOptimizationProblem.Evaluator).Repetitions.Value = metaProblemRepetitions;
+      GeneticAlgorithm metaLevelAlgorithm = GetMetaGA(metaOptimizationProblem);
+      //EvolutionStrategy metaLevelAlgorithm = GetMetaES(metaOptimizationProblem);
+
+      IValueConfiguration algorithmVc = SetupGAAlgorithm(baseLevelAlgorithm, metaOptimizationProblem);
 
       //Console.WriteLine("Press enter to start");
       //Console.ReadLine();
       //TestConfiguration(algorithmVc, baseLevelAlgorithm);
-
+      
       //Console.WriteLine("Press enter to start");
       //Console.ReadLine();
@@ -69 +76 @@
     }
 
-    private static GeneticAlgorithm GetMetaAlgorithm(MetaOptimizationProblem metaOptimizationProblem) {
+    private static GeneticAlgorithm GetMetaGA(MetaOptimizationProblem metaOptimizationProblem) {
       GeneticAlgorithm metaLevelAlgorithm = new GeneticAlgorithm();
       metaLevelAlgorithm.PopulationSize.Value = metaAlgorithmPopulationSize;
@@ -83 +90 @@
     }
 
-    private static IValueConfiguration SetupAlgorithm(GeneticAlgorithm baseLevelAlgorithm, MetaOptimizationProblem metaOptimizationProblem) {
-      baseLevelAlgorithm.Problem = new HeuristicLab.Problems.TestFunctions.SingleObjectiveTestFunctionProblem() { 
-        Evaluator = new GriewankEvaluator(),
-        ProblemSize = new IntValue(1000) 
-      };
+    private static EvolutionStrategy GetMetaES(MetaOptimizationProblem metaOptimizationProblem) {
+      EvolutionStrategy metaLevelAlgorithm = new EvolutionStrategy();
+      metaLevelAlgorithm.PopulationSize.Value = metaAlgorithmPopulationSize;
+      metaLevelAlgorithm.MaximumGenerations.Value = metaAlgorithmMaxGenerations;
+
+      metaLevelAlgorithm.Problem = metaOptimizationProblem;
+      metaLevelAlgorithm.Engine = new SequentialEngine.SequentialEngine();
+
+      metaLevelAlgorithm.Mutator = new ParameterConfigurationManipulator();
+      //metaLevelAlgorithm.MutationProbability.Value = 0.15;
+
+      return metaLevelAlgorithm;
+    }
+
+    private static IValueConfiguration SetupGAAlgorithm(GeneticAlgorithm baseLevelAlgorithm, MetaOptimizationProblem metaOptimizationProblem) {
+      baseLevelAlgorithm.Problem = new HeuristicLab.Problems.TestFunctions.SingleObjectiveTestFunctionProblem();
       baseLevelAlgorithm.MaximumGenerations.Value = baseAlgorithmMaxGenerations;
 
       metaOptimizationProblem.Algorithm = baseLevelAlgorithm;
       IValueConfiguration algorithmVc = metaOptimizationProblem.AlgorithmParameterConfiguration;
-      metaOptimizationProblem.Problems.Add(new HeuristicLab.Problems.TestFunctions.SingleObjectiveTestFunctionProblem());
+
+      metaOptimizationProblem.Problems.Add(new HeuristicLab.Problems.TestFunctions.SingleObjectiveTestFunctionProblem() {
+        Evaluator = new GriewankEvaluator(),
+        ProblemSize = new IntValue(500)
+      });
+      metaOptimizationProblem.Problems.Add(new HeuristicLab.Problems.TestFunctions.SingleObjectiveTestFunctionProblem() {
+        Evaluator = new GriewankEvaluator(),
+        ProblemSize = new IntValue(1000)
+      });
 
       ConfigurePopulationSize(algorithmVc);
@@ -189 +215 @@
           vc.Optimize = true;
           ConfigureTournamentGroupSize(vc);
+        } else if (vc.ActualValue.ValueDataType == typeof(RandomSelector)) {
+          selectionOperatorPc.ValueConfigurations.SetItemCheckedState(vc, true);
         } else {
-          selectionOperatorPc.ValueConfigurations.SetItemCheckedState(vc, false);
+          selectionOperatorPc.ValueConfigurations.SetItemCheckedState(vc, true);
         }
       }
@@ -235 +263 @@
     }
 
-    private static void TestOptimization(GeneticAlgorithm metaLevelAlgorithm) {
+    private static void TestOptimization(EngineAlgorithm metaLevelAlgorithm) {
       ContentManager.Initialize(new PersistenceContentManager());
       string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Results");
-      if(!Directory.Exists(path))
+      if (!Directory.Exists(path))
         Directory.CreateDirectory(path);
-      string id = DateTime.Now.ToString("MM.dd.yy - HH;mm;ss,ffff");
-      string resultPath = Path.Combine(path, string.Format("Test - {0} - Result.hl", id));
-      string outputPath = Path.Combine(path, string.Format("Test - {0} - Console.txt", id));
+      string id = DateTime.Now.ToString("yyyy.MM.dd - HH;mm;ss,ffff");
+      string resultPath = Path.Combine(path, string.Format("{0} - Result.hl", id));
+      string outputPath = Path.Combine(path, string.Format("{0} - Console.txt", id));
+
 
       using (var sw = new StreamWriter(outputPath)) {
+        sw.AutoFlush = true;
+
+        StringBuilder sb1 = new StringBuilder();
+        sb1.AppendLine(string.Format("Meta.PopulationSize: {0}", metaAlgorithmPopulationSize));
+        sb1.AppendLine(string.Format("Meta.MaxGenerations: {0}", metaAlgorithmMaxGenerations));
+        sb1.AppendLine(string.Format("Meta.Repetitions   : {0}", metaProblemRepetitions));
+        sb1.AppendLine(string.Format("Base.MaxGenerations: {0}", baseAlgorithmMaxGenerations));
+        sw.WriteLine(sb1.ToString());
+        Console.WriteLine(sb1.ToString());
+
         metaLevelAlgorithm.Start();
         int i = 0;
@@ -250 +289 @@
         do {
           Thread.Sleep(500);
-          try {
-            if (metaLevelAlgorithm.Results.ContainsKey("Generations") && ((IntValue)metaLevelAlgorithm.Results["Generations"].Value).Value != currentGeneration) {
-              StringBuilder sb = new StringBuilder();
-              sb.AppendLine(DateTime.Now.ToLongTimeString());
-              sb.AppendLine("=================================");
-
-              foreach (var result in metaLevelAlgorithm.Results) {
-                sb.AppendLine(result.ToString());
-                if (result.Name == "Population") {
-                  RunCollection rc = (RunCollection)result.Value;
-                  var orderedRuns = rc.OrderBy(x => x.Results["BestQuality"]);
-                  
-                  sb.AppendLine("Qality PoSi MutRa Eli GrSi MutOp");
-                  foreach (IRun run in orderedRuns) {
-                    sb.AppendLine(string.Format("{0} {1} {2} {3} {4} {5}",
-                      ((DoubleValue)run.Results["BestQuality"]).Value.ToString("#0.00").PadLeft(7, ' '),
-                      ((IntValue)run.Parameters["PopulationSize"]).Value.ToString().PadLeft(3, ' ').PadRight(3, ' '),
-                      ((DoubleValue)run.Parameters["MutationProbability"]).Value.ToString("0.00").PadLeft(5, ' '),
-                      ((IntValue)run.Parameters["Elites"]).Value.ToString().PadLeft(3, ' '),
-                      ((TournamentSelector)run.Parameters["Selector"]).GroupSizeParameter.Value.ToString().PadLeft(4, ' '),
-                      run.Parameters["Mutator"]));
+          if (metaLevelAlgorithm.Results.ContainsKey("Generations") && ((IntValue)metaLevelAlgorithm.Results["Generations"].Value).Value != currentGeneration) {
+            while (metaLevelAlgorithm.Results.Count < 3) Thread.Sleep(100);
+            StringBuilder sb = new StringBuilder();
+            sb.AppendLine(DateTime.Now.ToLongTimeString());
+            sb.AppendLine("=================================");
+
+            foreach (var result in metaLevelAlgorithm.Results) {
+              sb.AppendLine(result.ToString());
+              if (result.Name == "Population") {
+                RunCollection rc = (RunCollection)result.Value;
+                var orderedRuns = rc.OrderBy(x => x.Results["RunsAverageQuality"]);
+
+                sb.AppendLine("Qual.  PoSi MutRa Eli GrSi MutOp");
+                foreach (IRun run in orderedRuns) {
+                  string selector;
+                  if (run.Parameters["Selector"] is TournamentSelector) {
+                    selector = string.Format("{0} ({1})", run.Parameters["Selector"].ToString(), ((TournamentSelector)run.Parameters["Selector"]).GroupSizeParameter.Value.ToString());
+                  } else {
+                    selector = string.Format("{0}", run.Parameters["Selector"].ToString());
                   }
+
+                  sb.AppendLine(string.Format("{0} {1} {2} {3} {4} {5}",
+                    ((DoubleValue)run.Results["RunsAverageQuality"]).Value.ToString("#0.00").PadLeft(7, ' '),
+                    ((IntValue)run.Parameters["PopulationSize"]).Value.ToString().PadLeft(3, ' ').PadRight(3, ' '),
+                    ((DoubleValue)run.Parameters["MutationProbability"]).Value.ToString("0.00").PadLeft(5, ' '),
+                    ((IntValue)run.Parameters["Elites"]).Value.ToString().PadLeft(3, ' '),
+                    Shorten(selector, 20).PadRight(20, ' '),
+                    run.Parameters["Mutator"].ToString()));
                 }
-              } // foreach
-              Console.Clear();
-              Console.WriteLine(sb.ToString());
-              sw.WriteLine(sb.ToString());
-              sw.Flush();
-              currentGeneration = ((IntValue)metaLevelAlgorithm.Results["Generations"].Value).Value;
-            } // if
-            if (i % 30 == 0) GC.Collect();
-            i++;
-          }
-          catch { }
+              }
+            } // foreach
+            Console.Clear();
+            Console.WriteLine(sb.ToString());
+            sw.WriteLine(sb.ToString());
+            currentGeneration = ((IntValue)metaLevelAlgorithm.Results["Generations"].Value).Value;
+          } // if
+          if (i % 30 == 0) GC.Collect();
+          i++;
         } while (metaLevelAlgorithm.ExecutionState != ExecutionState.Stopped);
       }
@@ -290 +333 @@
       Console.WriteLine("Storing...");
 
-      ContentManager.Save(metaLevelAlgorithm, resultPath, true);
+      ContentManager.Save((IStorableContent)metaLevelAlgorithm, resultPath, true);
       Console.WriteLine("Finished");
+    }
+
+    private static void TestShorten() {
+      int n = 8;
+      Console.WriteLine(Shorten("1", n));
+      Console.WriteLine(Shorten("12", n));
+      Console.WriteLine(Shorten("123", n));
+      Console.WriteLine(Shorten("1234", n));
+      Console.WriteLine(Shorten("12345", n));
+      Console.WriteLine(Shorten("123456", n));
+      Console.WriteLine(Shorten("1234567", n));
+      Console.WriteLine(Shorten("12345678", n));
+      Console.WriteLine(Shorten("123456789", n));
+      Console.WriteLine(Shorten("1234567890", n));
+      Console.WriteLine(Shorten("12345678901", n));
+    }
+
+    private static string Shorten(string s, int n) {
+      string placeholder = "..";
+      if (s.Length <= n) return s;
+      int len = n / 2 - placeholder.Length / 2;
+      string start = s.Substring(0, len);
+      string end = s.Substring(s.Length - len, len);
+      return start + placeholder + end;
     }
 

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization.Views/3.3/OptimizableView.Designer.cs

@@ -41 +41 @@
       this.viewHost.Size = new System.Drawing.Size(513, 345);
       this.viewHost.TabIndex = 0;
+      this.viewHost.ViewsLabelVisible = false;
       this.viewHost.ViewType = null;
       // 

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization.Views/3.3/OptimizableView.cs

@@ -53 +53 @@
                 Content.ActualValue.ValueDataType == typeof(DoubleValue) ||
                 Content.ActualValue.ValueDataType == typeof(PercentValue)) {
+              this.viewHost.ViewsLabelVisible = true;
               this.viewHost.Content = ((IValueConfiguration)Content).RangeConstraint;
             } else if(Content.ActualValue.ValueDataType == typeof(BoolValue)) {
               this.viewHost.Content = null; // no configuration required
             } else {
+              this.viewHost.ViewsLabelVisible = false;
               this.viewHost.Content = ((IValueConfiguration)Content).ParameterConfigurations;
             }
@@ -63 +65 @@
           }
         } else {
+          this.viewHost.ViewsLabelVisible = false;
           this.viewHost.Content = Content.ActualValue;
         }
       }
+      SetEnabledStateOfControls();
     }
     void Content_IsOptimizabeChanged(object sender, EventArgs e) {

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization.Views/3.3/ValueConfigurationViews/ValueConfigurationCheckedItemList.cs

@@ -24 +24 @@
     public ValueConfigurationCheckedItemCollectionView() {
       InitializeComponent();
+      this.viewHost.ViewsLabelVisible = false;
     }
 

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization.Views/3.3/ValueConfigurationViews/ValueView.Designer.cs

@@ -62 +62 @@
       this.valueViewHost.Size = new System.Drawing.Size(470, 219);
       this.valueViewHost.TabIndex = 3;
+      this.valueViewHost.ViewsLabelVisible = false;
       this.valueViewHost.ViewType = null;
       // 

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization.Views/3.3/ValueConfigurationViews/ValueView.resx

@@ -166 +166 @@
         fNTws+7PbaOWo6fHXMf6Hwc/vj/OGn/2S8Yv7ycKnpCfVEyqTDZPmU2dmnafvvF05dOJZ+nPFmYKf5X+
         tfa5zvMffnP8rX82YnbiBf/Fp99LXsq/PPRq2aueuYC5R69TXy/MF72Rf3P4LeNt37vwd5MLWe+x7ys/
-        6H7o/ujz8cGn1E+f/gUDmPP8usTo0wAAAAlwSFlzAAALDgAACw4BQL7hQQAAAbVJREFUOE+lk7lLA0EU
+        6H7o/ujz8cGn1E+f/gUDmPP8usTo0wAAAAlwSFlzAAALDQAACw0B7QfALAAAAbVJREFUOE+lk7lLA0EU
         xuMRcdeYyIBRQcmxURTiEXE8ECQqpAkpJJVNihSKjVjbW1lJChuxtBGUNGKRwj9AvA9QEMRGS01M4YYZ
         v9nN5twgavGDt/tmvn3HtxbOueU/6JcpGQEpMAfqfyMoLjeAZbYU5iw2ryJe0N6ZVUZJI3JesGrkhYB4

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Analyzers/BestParameterConfigurationAnalyzer.cs

@@ -40 +40 @@
     }
 
-    public BestParameterConfigurationAnalyzer() : base() {
+    public BestParameterConfigurationAnalyzer()
+      : base() {
       Parameters.Add(new ScopeTreeLookupParameter<ParameterConfigurationTree>("ParameterConfigurationTree", "TODO The TSP solutions given in path representation from which the best solution should be analyzed."));
       Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "TODO The qualities of the TSP solutions which should be analyzed."));
@@ -63 +64 @@
       ItemArray<ParameterConfigurationTree> parameterTrees = ParameterConfigurationParameter.ActualValue;
 
-      int i = qualities.Select((x, index) => new { index, x.Value }).OrderBy(x => x.Value).First().index;
+      int idxBest = qualities.Select((x, index) => new { index, x.Value }).OrderBy(x => x.Value).First().index;
 
-      EngineAlgorithm bestAlg = ((EngineAlgorithm)((ParameterConfigurationTree)parameterTrees[i]).ActualValue.Value);
-      Run bestRun = new Run(bestAlg);
-      ((ParameterConfigurationTree)parameterTrees[i]).CollectResultValues(bestRun.Results);
 
-      if (bestKnownQuality == null || qualities[i].Value < bestKnownQuality.Value) { // todo: respect Maximization:true/false
-        BestKnownQualityParameter.ActualValue = new DoubleValue(qualities[i].Value);
+      ParameterConfigurationTree best = (ParameterConfigurationTree)parameterTrees[idxBest];
+      IRun bestRun = new Run();
+      best.CollectResultValues(bestRun.Results);
+      best.CollectParameterValues(bestRun.Parameters);
+
+      if (bestKnownQuality == null || qualities[idxBest].Value < bestKnownQuality.Value) { // todo: respect Maximization:true/false
+        BestKnownQualityParameter.ActualValue = new DoubleValue(qualities[idxBest].Value);
+
         BestKnownSolutionParameter.ActualValue = bestRun;
       }
 
-      IRun best = BestSolutionParameter.ActualValue;
-      if (best == null) {
+      if (BestSolutionParameter.ActualValue == null) {
         BestSolutionParameter.ActualValue = bestRun;
         results.Add(new Result("Best Parameter Settings", bestRun));
@@ -84 +87 @@
 
       // population
+
+      int i = 0;
       RunCollection rc = new RunCollection();
       foreach (ParameterConfigurationTree pt in parameterTrees.OrderByDescending(x => x.BestQuality.Value)) { // todo: respect Maximization:true/false
-        IAlgorithm alg = (IAlgorithm)pt.ActualValue.Value;
-        alg.StoreAlgorithmInEachRun = false;
-        IRun run = new Run(alg);
+        IRun run = new Run();
+        run.Name = string.Format("Individuum ({0})", i);
         pt.CollectResultValues(run.Results);
+        pt.CollectParameterValues(run.Parameters);
         rc.Add(run);
+        i++;
       }
       if (PopulationParameter.ActualValue == null) {

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ParameterConfigurationTree.cs

@@ -13 +13 @@
   [StorableClass]
   public class ParameterConfigurationTree : ValueConfiguration {
-    [Storable]
-    public EngineAlgorithm Algorithm {
-      get { return (EngineAlgorithm)base.ActualValue.Value; }
-      set {
-        base.ActualValue.Value = value;
-      }
-    }
+    //[Storable]
+    //public EngineAlgorithm Algorithm {
+    //  get { return (EngineAlgorithm)base.ActualValue.Value; }
+    //  set {
+    //    base.ActualValue.Value = value;
+    //  }
+    //}
 
     [Storable]
@@ -48 +48 @@
       set { worstQuality = value; }
     }
-    
+
     [Storable]
     private DoubleValue qualityVariance;
@@ -55 +55 @@
       set { qualityVariance = value; }
     }
-    
+
     [Storable]
     private DoubleValue qualityStandardDeviation;
@@ -62 +62 @@
       set { qualityStandardDeviation = value; }
     }
-    
+
     [Storable]
     private TimeSpanValue averageExecutionTime;
@@ -78 +78 @@
 
     [Storable]
-    public RunCollection Runs { get; set; }
-    
+    protected RunCollection runs;
+    public RunCollection Runs {
+      get { return runs; }
+      set { runs = value; }
+     }
+
+    protected IDictionary<string, IItem> parameters;
+    public IDictionary<string, IItem> Parameters {
+      get { return parameters; }
+      set { parameters = value; }
+    }
+
     #region constructors and cloning
-    public ParameterConfigurationTree(EngineAlgorithm algorithm) : base(algorithm, algorithm.GetType()) {
+    public ParameterConfigurationTree(EngineAlgorithm algorithm)
+      : base(null, algorithm.GetType()) {
       this.Optimize = true; // root must always be optimized
       this.BestQuality = new DoubleValue();
+      this.parameters = new Dictionary<string, IItem>();
+
+      PopulateParameterConfigurations(algorithm);
+      Initialize();
     }
     public ParameterConfigurationTree() {
@@ -90 +105 @@
     [StorableConstructor]
     protected ParameterConfigurationTree(bool deserializing) : base(deserializing) { }
-    protected ParameterConfigurationTree(ParameterConfigurationTree original, Cloner cloner) : base(original, cloner) {
+    protected ParameterConfigurationTree(ParameterConfigurationTree original, Cloner cloner)
+      : base(original, cloner) {
       this.bestQuality = cloner.Clone(original.BestQuality);
-      this.Algorithm.Prepare();
-      this.Algorithm.Runs.Clear();
+      this.parameters = new Dictionary<string, IItem>();
+      foreach (var p in original.parameters) {
+        this.parameters.Add(p.Key, cloner.Clone(p.Value));
+      }
       Initialize();
     }
@@ -121 +139 @@
     }
 
+    public virtual void CollectParameterValues(IDictionary<string, IItem> values) {
+      foreach (var p in parameters) {
+        values.Add(p);
+      }
+    }
+
     #region Events
     //public event EventHandler AlgorithmChanged;
@@ -134 +158 @@
 
     //private void RegisterAlgorithmEvents() {
-      
+
     //}
     //private void DeregisterAlgorithmEvents() {
@@ -151 +175 @@
     #endregion
 
+    public override void Parameterize(IParameterizedItem item) {
+      base.Parameterize(item);
+      this.parameters.Clear();
+      ((IAlgorithm)item).CollectParameterValues(this.Parameters);
+    }
   }
 }

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ParameterConfigurations/ParameterConfiguration.cs

@@ -281 +281 @@
     public void Randomize(IRandom random) {
       if (Optimize) {
+        foreach (var vc in this.ValueConfigurations.CheckedItems) {
+          vc.Randomize(random);
+        }
         actualValueConfigurationIndex = random.Next(ValueConfigurations.CheckedItems.Count());
-        this.ValueConfigurations.CheckedItems.ElementAt(actualValueConfigurationIndex).Randomize(random);
         this.ActualValue = this.ValueConfigurations.CheckedItems.ElementAt(actualValueConfigurationIndex).ActualValue;
       }
@@ -294 +296 @@
         actualValueConfigurationIndex = random.Next(ValueConfigurations.CheckedItems.Count());
         this.ActualValue = this.ValueConfigurations.CheckedItems.ElementAt(actualValueConfigurationIndex).ActualValue;
-        this.ValueConfigurations.CheckedItems.ElementAt(actualValueConfigurationIndex).Mutate(random);
       }
     }

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ValueConfigurations/ValueConfiguration.cs

@@ -34 +34 @@
           if (optimize) {
             ClearParameterConfigurations();
-            PopulateParameterConfigurations();
+            if (this.actualValue.Value is IParameterizedNamedItem) PopulateParameterConfigurations(this.actualValue.Value as IParameterizedNamedItem);
           } else {
             ClearParameterConfigurations();
@@ -53 +53 @@
     [Storable]
     protected ConstrainedValue actualValue;
-    public ConstrainedValue ActualValue {
+    public virtual ConstrainedValue ActualValue {
       get { return actualValue; }
       set {
@@ -59 +59 @@
           ClearParameterConfigurations();
           this.actualValue = value;
-          PopulateParameterConfigurations();
+          if (this.actualValue.Value is IParameterizedNamedItem) PopulateParameterConfigurations(this.actualValue.Value as IParameterizedNamedItem);
           OnValueChanged();
           OnToStringChanged();
@@ -112 +112 @@
     #endregion
 
-    protected virtual void PopulateParameterConfigurations() {
-      if (this.actualValue.Value is IParameterizedNamedItem) {
-        var parameterizedItem = this.actualValue.Value as IParameterizedNamedItem;
-        foreach (var childParameter in parameterizedItem.Parameters) {
-          var pc = ParameterConfiguration.Create(parameterizedItem, childParameter);
-          if (pc != null) this.parameterConfigurations.Add(pc);
-        }
+    protected virtual void PopulateParameterConfigurations(IParameterizedNamedItem parameterizedItem) {
+      foreach (var childParameter in parameterizedItem.Parameters) {
+        var pc = ParameterConfiguration.Create(parameterizedItem, childParameter);
+        if (pc != null) this.parameterConfigurations.Add(pc);
       }
     }
@@ -195 +192 @@
     }
 
-    public void Parameterize(IParameterizedItem item) {
+    public virtual void Parameterize(IParameterizedItem item) {
       foreach (IParameterConfiguration pc in this.ParameterConfigurations) {
         pc.Parameterize((IValueParameter)item.Parameters[pc.ParameterName]);

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Evaluators/MetaOptimizationEvaluator.cs

@@ -63 +63 @@
 
     public override IOperation Apply() {
-      EngineAlgorithm algorithm = (EngineAlgorithm)ParameterConfigurationParameter.ActualValue.ActualValue.Value;
+      EngineAlgorithm algorithm = AlgorithmParameter.ActualValue;
+      IItemList<ISingleObjectiveProblem> problems = ProblemsParameter.ActualValue;
 
       // set parameters
       ParameterConfigurationParameter.ActualValue.Parameterize(algorithm);
+      algorithm.Problem = problems.First();
+      algorithm.StoreAlgorithmInEachRun = false;
 
       algorithmStopped = false;
@@ -73 +76 @@
       List<double> qualities = new List<double>();
       List<TimeSpan> executionTimes = new List<TimeSpan>();
+      algorithm.Engine = new SequentialEngine.SequentialEngine();
       algorithm.Prepare(true);
 
-      for (int i = 0; i < Repetitions.Value; i++) {
-        algorithm.Engine = new SequentialEngine.SequentialEngine();
-        algorithm.Prepare();
-        algorithm.Start();
-        while (!algorithmStopped) {
-          Thread.Sleep(200); // wait for algorithm to complete; do not rely on Algorithm.ExecutionState here, because change of ExecutionState happens before Run is added (which causes problems because Algorithm might get cloned when its started already)
+      foreach (ISingleObjectiveProblem problem in problems) {
+        algorithm.Problem = problem;
+
+        for (int i = 0; i < Repetitions.Value; i++) {
+          algorithm.Prepare();
+          algorithm.Start();
+          while (!algorithmStopped) {
+            Thread.Sleep(200); // wait for algorithm to complete; do not rely on Algorithm.ExecutionState here, because change of ExecutionState happens before Run is added (which causes problems because Algorithm might get cloned when its started already)
+          }
+          qualities.Add(((DoubleValue)algorithm.Results["BestQuality"].Value).Value);
+          executionTimes.Add(algorithm.ExecutionTime);
+
+          // parameters will be stored in ParameterConfigurationTree anyway. they would be redundant in runs
+          algorithm.Runs.Last().Parameters.Clear();
+          // but keep the problem, since this differs in runs
+          algorithm.Runs.Last().Parameters.Add("Problem", problem);
+          algorithmStopped = false;
         }
-        qualities.Add(((DoubleValue)algorithm.Results["BestQuality"].Value).Value);
-        executionTimes.Add(algorithm.ExecutionTime);
 
-        algorithmStopped = false;
       }
+
+
       algorithm.Stopped -= new EventHandler(ActualValue_Stopped);
+      algorithm.Prepare();
 
       qualities = qualities.OrderBy(x => x).ToList();  // todo: respect Maximization:true/false
-      
+
       ParameterConfigurationParameter.ActualValue.AverageExecutionTime = new TimeSpanValue(TimeSpan.FromMilliseconds(executionTimes.Average(t => t.TotalMilliseconds)));
       ParameterConfigurationParameter.ActualValue.Repetitions = Repetitions;
@@ -102 +117 @@
       double quality = ParameterConfigurationParameter.ActualValue.AverageQuality.Value; // todo: also include other measures (executiontime, variance)
       this.QualityParameter.ActualValue = new DoubleValue(quality);
-      
+
       return base.Apply();
     }

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/HeuristicLab.Problems.MetaOptimization-3.3.csproj

@@ -79 +79 @@
     </Reference>
     <Reference Include="HeuristicLab.SequentialEngine-3.3">
-      <HintPath>..\..\HeuristicLab.MetaOptimization.Test\bin\Debug\HeuristicLab.SequentialEngine-3.3.dll</HintPath>
+      <HintPath>..\..\..\..\..\..\..\..\Program Files\HeuristicLab 3.3\HeuristicLab.SequentialEngine-3.3.dll</HintPath>
     </Reference>
     <Reference Include="System" />

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/MetaOptimizationProblem.cs

@@ -151 +151 @@
     }
     void BaseLevelAlgorithmParameter_ValueChanged(object sender, EventArgs e) {
-      Algorithm.ProblemChanged += new EventHandler(BaseLevelAlgorithm_ProblemChanged); // when to deregister?
-      BaseLevelAlgorithm_ProblemChanged(sender, e);
+      AlgorithmParameterConfiguration = new ParameterConfigurationTree(Algorithm);
+
+      //Algorithm.ProblemChanged += new EventHandler(BaseLevelAlgorithm_ProblemChanged); // when to deregister?
+      //BaseLevelAlgorithm_ProblemChanged(sender, e);
     }
 
     void BaseLevelAlgorithm_ProblemChanged(object sender, EventArgs e) {
-      if (Algorithm != null && Algorithm.Problem != null) {
-        AlgorithmParameterConfiguration = new ParameterConfigurationTree(Algorithm);
-      }
+      //if (Algorithm != null && Algorithm.Problem != null) {
+      //  AlgorithmParameterConfiguration = new ParameterConfigurationTree(Algorithm);
+      //}
     }
     #endregion