Changeset 5184 for branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization

Timestamp:

12/30/10 22:50:59 (14 years ago)

Author:

cneumuel

Message:

#1215

• enhanced combinations generator (now with batchruns!)
• fixed ActualNames for metaopt-alg
• added penalty for invalid solution-candidates (algs which throw exceptions)
• migrated to .NET 4.0

Location:

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3

Files:

• Creators/RandomParameterConfigurationCreator.cs (modified) (2 diffs)
• Encoding/Crossovers/ParameterConfigurationCrossover.cs (modified) (4 diffs)
• Encoding/ParameterCombinationsEnumerator.cs (modified) (8 diffs)
• Encoding/ParameterConfigurationTree.cs (modified) (4 diffs)
• Encoding/ParameterConfigurations/ParameterConfiguration.cs (modified) (1 diff)
• Encoding/RangeConstraints/DoubleValueRange.cs (modified) (1 diff)
• Encoding/RangeConstraints/IntValueRange.cs (modified) (1 diff)
• Encoding/RangeConstraints/PercentValueRange.cs (modified) (1 diff)
• Encoding/ValueConfigurations/ValueConfiguration.cs (modified) (2 diffs)
• Evaluators/ParameterConfigurationEvaluator.cs (modified) (7 diffs)
• HeuristicLab.Problems.MetaOptimization-3.3.csproj (modified) (2 diffs)
• Interfaces/IOptimizable.cs (modified) (1 diff)
• Interfaces/IParameterConfigurationCreator.cs (modified) (1 diff)
• Interfaces/IParameterConfigurationCrossover.cs (added)
• Interfaces/IParameterConfigurationEvaluator.cs (modified) (1 diff)
• MetaOptimizationProblem.cs (modified) (6 diffs)

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Creators/RandomParameterConfigurationCreator.cs

@@ -21 +21 @@
     }
     public ILookupParameter<ParameterConfigurationTree> InitialParameterConfigurationParameter {
-      get { return (ILookupParameter<ParameterConfigurationTree>)Parameters["InitialParameterConfigurationTree"]; }
+      get { return (ILookupParameter<ParameterConfigurationTree>)Parameters[MetaOptimizationProblem.ParameterConfigurationTreeParameterName]; }
     }
 
-    public ILookupParameter<ParameterConfigurationTree> ParameterConfigurationParameter {
-      get { return (ILookupParameter<ParameterConfigurationTree>)Parameters["ParameterConfigurationTree"]; }
+    public IValueLookupParameter<ParameterConfigurationTree> ParameterConfigurationParameter {
+      get { return (IValueLookupParameter<ParameterConfigurationTree>)Parameters["ParameterConfigurationTreeSolutionCandidate"]; }
     }
 
@@ -33 +33 @@
     public RandomParameterConfigurationCreator() : base() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used to initialize the new random permutation."));
-      Parameters.Add(new LookupParameter<ParameterConfigurationTree>("InitialParameterConfigurationTree", "The parameter configuration tree on which the new solution will be based on."));
-      Parameters.Add(new LookupParameter<ParameterConfigurationTree>("ParameterConfigurationTree", "The new random parameter set."));
+      Parameters.Add(new LookupParameter<ParameterConfigurationTree>(MetaOptimizationProblem.ParameterConfigurationTreeParameterName, "The parameter configuration tree on which the new solution will be based on."));
+      Parameters.Add(new ValueLookupParameter<ParameterConfigurationTree>("ParameterConfigurationTreeSolutionCandidate", "The new random parameter set."));
     }
     public override IDeepCloneable Clone(Cloner cloner) {

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/Crossovers/ParameterConfigurationCrossover.cs

@@ -15 +15 @@
   [Item("ParameterConfigurationCrossover", "TODO")]
   [StorableClass]
-  public class ParameterConfigurationCrossover : SingleSuccessorOperator, IParameterConfigurationOperator, ICrossover {
+  public class ParameterConfigurationCrossover : SingleSuccessorOperator, IParameterConfigurationOperator, IParameterConfigurationCrossover {
     public override bool CanChangeName {
       get { return false; }
@@ -23 +23 @@
       get { return (LookupParameter<IRandom>)Parameters["Random"]; }
     }
-    public ILookupParameter<ItemArray<IValueConfiguration>> ParentsParameter {
-      get { return (ScopeTreeLookupParameter<IValueConfiguration>)Parameters["Parents"]; }
+    public ILookupParameter<ItemArray<ParameterConfigurationTree>> ParentsParameter {
+      get { return (ScopeTreeLookupParameter<ParameterConfigurationTree>)Parameters["Parents"]; }
     }
-    public ILookupParameter<IValueConfiguration> ChildParameter {
-      get { return (ILookupParameter<IValueConfiguration>)Parameters["Child"]; }
+    public ILookupParameter<ParameterConfigurationTree> ChildParameter {
+      get { return (ILookupParameter<ParameterConfigurationTree>)Parameters["Child"]; }
     }
 
@@ -43 +43 @@
       : base() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic crossover operators."));
-      Parameters.Add(new ScopeTreeLookupParameter<IValueConfiguration>("Parents", "The parent vectors which should be crossed."));
-      ParentsParameter.ActualName = "ParameterConfigurationTree";
-      Parameters.Add(new LookupParameter<IValueConfiguration>("Child", "The child vector resulting from the crossover."));
-      ChildParameter.ActualName = "ParameterConfigurationTree";
+      Parameters.Add(new ScopeTreeLookupParameter<ParameterConfigurationTree>("Parents", "The parent vectors which should be crossed."));
+      Parameters.Add(new LookupParameter<ParameterConfigurationTree>("Child", "The child vector resulting from the crossover."));
 
       Parameters.Add(new ValueLookupParameter<IIntValueCrossover>(MetaOptimizationProblem.IntValueCrossoverParameterName, ""));
@@ -56 +54 @@
 
     public override IOperation Apply() {
-      IValueConfiguration child1 = (IValueConfiguration)ParentsParameter.ActualValue[0].Clone();
-      IValueConfiguration child2 = (IValueConfiguration)ParentsParameter.ActualValue[1];
+      ParameterConfigurationTree child1 = (ParameterConfigurationTree)ParentsParameter.ActualValue[0].Clone();
+      ParameterConfigurationTree child2 = (ParameterConfigurationTree)ParentsParameter.ActualValue[1];
 
       //child1.Cross(child2, RandomParameter.ActualValue);

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/ParameterCombinationsEnumerator.cs

@@ -10 +10 @@
     private IOptimizable node;
     private List<IEnumerator> enumerators;
-    IEnumerator valueEnumerator;
+    private EnumeratorCollectionEnumerator<IItem> valueEnumerator;
+    private bool initialized = false;
 
     public ParameterCombinationsEnumerator(IOptimizable node) {
@@ -21 +22 @@
     }
     object IEnumerator.Current {
-      get { return Current; }
+      get {
+        if (!initialized)
+          throw new SystemException("Enumeration not started. Call MoveNext!");
+        return Current; 
+      }
     }
 
@@ -27 +32 @@
 
     public bool MoveNext() {
-      int i = 0;
-      bool ok = false;
-      while (!ok && i < enumerators.Count) {
-        if (enumerators[i].MoveNext()) {
-          ok = true;
+      if (!initialized) {
+        foreach (var enu in enumerators) {
+          enu.Reset();
+          if (!enu.MoveNext())
+            return false;
+        }
+        initialized = true;
+      } else {
+        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 {
-          i++;
+          return false;
         }
-      }
-
-      if (ok) {
-        for (int k = i - 1; k >= 0; k--) {
-          enumerators[k].Reset();
-          enumerators[k].MoveNext();
-        }
-      } else {
-        return false;
       }
 
@@ -61 +75 @@
       enumerators.Clear();
       valueEnumerator = null;
+      initialized = false;
 
       var pc = node as IParameterConfiguration;
       if (pc != null) {
-        valueEnumerator = pc.ValueConfigurations.CheckedItems.ToArray().GetEnumerator();
-        //valueEnumerator.Reset();
-        enumerators.Add(valueEnumerator);
+        valueEnumerator = new EnumeratorCollectionEnumerator<IItem>();
 
         foreach (var valueConfiguration in pc.ValueConfigurations.CheckedItems) {
@@ -72 +85 @@
             var enumerator = new ParameterCombinationsEnumerator(valueConfiguration);
             enumerator.Reset();
-            enumerator.MoveNext();
-            enumerators.Add(enumerator);
+            valueEnumerator.AddEnumerator(enumerator);
+          } else {
+            valueEnumerator.AddEnumerator(new List<IItem> { valueConfiguration }.GetEnumerator());
           }
         }
+        valueEnumerator.Reset();
+        enumerators.Add(valueEnumerator);
       }
 
@@ -81 +97 @@
       if (vc != null) {
         if (vc.RangeConstraint != null) {
-          valueEnumerator = vc.RangeConstraint.GetCombinations().ToArray().GetEnumerator();
-          //valueEnumerator.Reset();
-          //enumerator.MoveNext();
+          valueEnumerator = new EnumeratorCollectionEnumerator<IItem>();
+          valueEnumerator.AddEnumerator(vc.RangeConstraint.GetCombinations().GetEnumerator());
+          valueEnumerator.Reset();
           enumerators.Add(valueEnumerator);
         } else {
@@ -90 +106 @@
               var enumerator = new ParameterCombinationsEnumerator(parameterConfiguration);
               enumerator.Reset();
-              enumerator.MoveNext();
               enumerators.Add(enumerator);
             }
@@ -97 +112 @@
       }
     }
+  }
 
+  /// <summary>
+  /// Enumerator which can enumerate all elements of a list of enumerators
+  /// </summary>
+  /// <typeparam name="T"></typeparam>
+  public class EnumeratorCollectionEnumerator<T> : IEnumerator<T> {
+    private List<IEnumerator<T>> enumerators = new List<IEnumerator<T>>();
+    private IEnumerator<IEnumerator<T>> currentEnumerator;
+
+    public EnumeratorCollectionEnumerator() { }
+
+    public void AddEnumerator(IEnumerator<T> enumerator) {
+      enumerators.Add(enumerator);
+    }
+
+    public void Dispose() {  }
+
+    public T Current {
+      get { return currentEnumerator.Current.Current; }
+    }
+
+    object IEnumerator.Current {
+      get { return this.Current; }
+    }
+
+    public bool MoveNext() {
+      bool ok = currentEnumerator.Current.MoveNext();
+      if (!ok) {
+        ok = currentEnumerator.MoveNext();
+        if (!ok)
+          return false;
+        else
+          return this.MoveNext();
+      }
+      return true;
+    }
+
+    public void Reset() {
+      foreach (var enu in enumerators) {
+        enu.Reset();
+      }
+      currentEnumerator = enumerators.GetEnumerator();
+      currentEnumerator.Reset();
+      currentEnumerator.MoveNext();
+    }
   }
 }

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

@@ -14 +14 @@
   [StorableClass]
   public class ParameterConfigurationTree : ValueConfiguration, IEnumerable {
-    //[Storable]
-    //public EngineAlgorithm Algorithm {
-    //  get { return (EngineAlgorithm)base.ActualValue.Value; }
-    //  set {
-    //    base.ActualValue.Value = value;
-    //  }
-    //}
-
     [Storable]
     private DoubleValue bestQuality;
@@ -83 +75 @@
       get { return runs; }
       set { runs = value; }
-     }
-
+    }
+
+    [Storable]
     protected IDictionary<string, IItem> parameters;
     public IDictionary<string, IItem> Parameters {
@@ -109 +102 @@
       : base(original, cloner) {
       this.bestQuality = cloner.Clone(original.BestQuality);
+      this.averageQuality = cloner.Clone(original.averageQuality);
+      this.worstQuality = cloner.Clone(original.worstQuality);
+      this.qualityStandardDeviation = cloner.Clone(original.qualityStandardDeviation);
+      this.qualityVariance = cloner.Clone(original.qualityVariance);
+      this.averageExecutionTime = cloner.Clone(original.averageExecutionTime);
+      this.repetitions = cloner.Clone(original.repetitions);
+      this.runs = cloner.Clone(original.runs);
       this.parameters = new Dictionary<string, IItem>();
       foreach (var p in original.parameters) {
@@ -182 +182 @@
     }
 
-    public Experiment GenerateExperiment(IAlgorithm algorithm) {
+    public Experiment GenerateExperiment(IAlgorithm algorithm, bool createBatchRuns, int repetitions) {
       Experiment experiment = new Experiment();
       foreach (IValueConfiguration combination in this) {
         IAlgorithm clonedAlg = (IAlgorithm)algorithm.Clone();
-        clonedAlg.Name = combination.ToParameterInfoString();
+        clonedAlg.Name = combination.ParameterInfoString;
         combination.Parameterize(clonedAlg);
-        experiment.Optimizers.Add(clonedAlg);
+        clonedAlg.StoreAlgorithmInEachRun = false;
+        if (createBatchRuns) {
+          BatchRun batchRun = new BatchRun(string.Format("BatchRun: {0}", combination.ParameterInfoString));
+          batchRun.Algorithm = clonedAlg;
+          batchRun.Repetitions = repetitions;
+          experiment.Optimizers.Add(batchRun);
+        } else {
+          experiment.Optimizers.Add(clonedAlg);
+        }
       }
       return experiment;
+    }
+
+    public Experiment GenerateExperiment(IAlgorithm algorithm) {
+      return GenerateExperiment(algorithm, false, 0);
     }
 

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

@@ -300 +300 @@
     }
 
-    public string ToParameterInfoString() {
-      StringBuilder sb = new StringBuilder();
-      if (this.Optimize) {
-        sb.Append(string.Format("{0}: {1}", parameterName, this.ActualValue.Value));
-        //sb.Append(" (");
-        //var subParams = new List<string>();
-        //if (this.ActualValue.Value is IParameterizedItem) {
-        //  subParams.Add(this.ValueConfigurations.CheckedItems.ElementAt(actualValueConfigurationIndex).ToParameterInfoString());
-        //}
-        //sb.Append(string.Join(", ", subParams.ToArray()));
-        //sb.Append(")");
-      }
-      return sb.ToString();
+    public string ParameterInfoString {
+      get {
+        StringBuilder sb = new StringBuilder();
+        if (this.Optimize) {
+          sb.Append(string.Format("{0}: {1}", parameterName, this.ActualValue.Value != null ? this.ActualValue.Value.ToString() : "null"));
+
+          if (this.ActualValue.Value is IParameterizedItem) {
+            string subParams = this.ValueConfigurations.CheckedItems.ElementAt(actualValueConfigurationIndex).ParameterInfoString;
+            if (!string.IsNullOrEmpty(subParams)) {
+              sb.Append(" (");
+              sb.Append(subParams);
+              sb.Append(")");
+            }
+          }
+        }
+        return sb.ToString();
+      }
     }
 

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/RangeConstraints/DoubleValueRange.cs

@@ -44 +44 @@
 
       while (value <= UpperBound.Value) {
-        //yield return new DoubleValue(value);
         solutions.Add(new DoubleValue(value));
         value += StepSize.Value;

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/RangeConstraints/IntValueRange.cs

@@ -44 +44 @@
 
       while (value <= this.UpperBound.Value) {
-        //yield return new IntValue(value);
         solutions.Add(new IntValue(value));
         value += this.StepSize.Value;

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/RangeConstraints/PercentValueRange.cs

@@ -39 +39 @@
 
       while (value <= UpperBound.Value) {
-        //yield return new PercentValue(value);
         solutions.Add(new PercentValue(value));
         value += StepSize.Value;

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

@@ -95 +95 @@
         RangeConstraint = new DoubleValueRange(new DoubleValue(0), (DoubleValue)value, new DoubleValue(0.01));
       } else if (actualValue.ValueDataType == typeof(PercentValue)) {
-        RangeConstraint = new PercentValueRange(new PercentValue(0), new PercentValue(1), new PercentValue(0.001));
+        RangeConstraint = new PercentValueRange(new PercentValue(0), new PercentValue(1), new PercentValue(0.01));
       } else if (actualValue.ValueDataType == typeof(BoolValue)) {
         this.IsOptimizable = false; // there is nothing to configure for bools
@@ -211 +211 @@
     }
 
-    public string ToParameterInfoString() {
-      StringBuilder sb = new StringBuilder();
-      if (this.Optimize) {
-        if (this.ParameterConfigurations.Count > 0) {
-          var parameterInfos = new List<string>();
-          foreach (var pc in this.ParameterConfigurations) {
-            if (pc.Optimize) parameterInfos.Add(pc.ToParameterInfoString());
-          }
-          sb.Append(string.Join(", ", parameterInfos.ToArray()));
-        }
-      }
-      return sb.ToString();
+    public string ParameterInfoString {
+      get {
+        StringBuilder sb = new StringBuilder();
+        if (this.Optimize) {
+          if (this.ParameterConfigurations.Count > 0) {
+            var parameterInfos = new List<string>();
+            foreach (var pc in this.ParameterConfigurations) {
+              if (pc.Optimize) parameterInfos.Add(pc.ParameterInfoString);
+            }
+            sb.Append(string.Join(", ", parameterInfos.ToArray()));
+          }
+        }
+        return sb.ToString();
+      }
     }
 

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

@@ -19 +19 @@
   public class ParameterConfigurationEvaluator : SingleSuccessorOperator, IParameterConfigurationEvaluator {
     private bool algorithmStopped;
+    private bool algorithmExceptionOccured;
 
     public ILookupParameter<DoubleValue> QualityParameter {
@@ -69 +70 @@
 
       algorithmStopped = false;
-      algorithm.Stopped += new EventHandler(ActualValue_Stopped);
+      algorithmExceptionOccured = false;
+      algorithm.Stopped += new EventHandler(algorithm_Stopped);
+      algorithm.Paused += new EventHandler(algorithm_Paused);
+      algorithm.ExceptionOccurred += new EventHandler<EventArgs<Exception>>(algorithm_ExceptionOccurred);
 
       List<double> qualities = new List<double>();
@@ -85 +89 @@
             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);
+          if (algorithmExceptionOccured) {
+            // this parametercombination was bad. set penalty for this solution
+            qualities.Add(double.MaxValue); // todo: respect Maximization
+            executionTimes.Add(algorithm.ExecutionTime);
+          } else {
+            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;
+          algorithmExceptionOccured = false;
         }
-
       }
 
-
-      algorithm.Stopped -= new EventHandler(ActualValue_Stopped);
+      algorithm.Stopped -= new EventHandler(algorithm_Stopped);
+      algorithm.Paused -= new EventHandler(algorithm_Paused);
+      algorithm.ExceptionOccurred -= new EventHandler<EventArgs<Exception>>(algorithm_ExceptionOccurred);
       algorithm.Prepare();
 
@@ -104 +116 @@
 
       ParameterConfigurationParameter.ActualValue.AverageExecutionTime = new TimeSpanValue(TimeSpan.FromMilliseconds(executionTimes.Average(t => t.TotalMilliseconds)));
-      ParameterConfigurationParameter.ActualValue.Repetitions = Repetitions;
+      ParameterConfigurationParameter.ActualValue.Repetitions = (IntValue)Repetitions.Clone();
       ParameterConfigurationParameter.ActualValue.BestQuality = new DoubleValue(qualities.First());
       ParameterConfigurationParameter.ActualValue.AverageQuality = new DoubleValue(qualities.Average());
@@ -110 +122 @@
       ParameterConfigurationParameter.ActualValue.QualityVariance = new DoubleValue(qualities.Variance());
       ParameterConfigurationParameter.ActualValue.QualityStandardDeviation = new DoubleValue(qualities.StandardDeviation());
-      ParameterConfigurationParameter.ActualValue.Runs = algorithm.Runs;
+      ParameterConfigurationParameter.ActualValue.Runs = (RunCollection)algorithm.Runs.Clone();
 
       double quality = ParameterConfigurationParameter.ActualValue.AverageQuality.Value; // todo: also include other measures (executiontime, variance)
@@ -116 +128 @@
 
       return base.Apply();
+    }
+
+    private void algorithm_Paused(object sender, EventArgs e) {
+      algorithmStopped = true;
+    }
+
+    private void algorithm_Stopped(object sender, EventArgs e) {
+      algorithmStopped = true;
+    }
+
+    void algorithm_ExceptionOccurred(object sender, EventArgs<Exception> e) {
+      algorithmExceptionOccured = true;
     }
 
@@ -128 +152 @@
     }
 
-    void ActualValue_Stopped(object sender, EventArgs e) {
-      algorithmStopped = true;
-    }
+
   }
 }

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

@@ -11 +11 @@
     <RootNamespace>HeuristicLab.Problems.MetaOptimization</RootNamespace>
     <AssemblyName>HeuristicLab.Problems.MetaOptimization-3.3</AssemblyName>
-    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
     <TargetFrameworkProfile />
@@ -147 +147 @@
     <Compile Include="Encoding\ValueConfigurations\ValueConfiguration.cs" />
     <Compile Include="Encoding\ValueConfigurations\CheckedValueConfigurationCollection.cs" />
+    <Compile Include="Interfaces\IParameterConfigurationCrossover.cs" />
     <Compile Include="Interfaces\ICheckedValueConfigurationCollection.cs" />
     <Compile Include="Operators\Crossovers\DiscreteIntValueCrossover.cs" />

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IOptimizable.cs

@@ -18 +18 @@
     void Mutate(IRandom random, MutateDelegate mutate, ParameterConfigurationManipulator pcmanip);
     void Cross(IRandom random, IOptimizable other, CrossDelegate cross, ParameterConfigurationCrossover pccross);
-    string ToParameterInfoString();
+    string ParameterInfoString { get; }
 
     event EventHandler IsOptimizableChanged;

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IParameterConfigurationCreator.cs

@@ -2 +2 @@
 
 namespace HeuristicLab.Problems.MetaOptimization {
-  public interface IParameterConfigurationCreator : ISolutionCreator {
+  public interface IParameterConfigurationCreator : ISolutionCreator, IParameterConfigurationOperator {
   }
 }

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Interfaces/IParameterConfigurationEvaluator.cs

@@ -5 +5 @@
   /// An interface which represents an evaluation operator for Meta Optimization Problems.
   /// </summary>
-  public interface IParameterConfigurationEvaluator : ISingleObjectiveEvaluator {  }
+  public interface IParameterConfigurationEvaluator : ISingleObjectiveEvaluator, IParameterConfigurationOperator { }
 }

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

@@ -40 +40 @@
     public const string ProblemTypeParameterName = "ProblemType";
     public const string ProblemsParameterName = "Problems";
-    public const string ParameterConfigurationTreeParameterName = "ParameterConfigurationTree";
+    public const string ParameterConfigurationTreeParameterName = "InitialParameterConfigurationTree";
     public const string RepetitionsParameterName = "Repetitions";
 
@@ -95 +95 @@
       set { RepetitionsParameter.Value = value; }
     }
+    private BestParameterConfigurationAnalyzer BestParameterConfigurationAnalyzer {
+      get { return Operators.OfType<BestParameterConfigurationAnalyzer>().FirstOrDefault(); }
+    }
     #endregion
 
@@ -101 +104 @@
       Parameters.Add(new ValueParameter<ISingleObjectiveProblem>(ProblemTypeParameterName, "The problem type.", new SingleObjectiveTestFunctionProblem()));
       Parameters.Add(new ValueParameter<ConstrainedItemList<ISingleObjectiveProblem>>(ProblemsParameterName, "The problems that should be evaluated.", new ConstrainedItemList<ISingleObjectiveProblem>()));
-      Parameters.Add(new ValueParameter<ParameterConfigurationTree>(ParameterConfigurationTreeParameterName, "List of algorithm parameters that should be optimized."));
+      Parameters.Add(new ValueParameter<ParameterConfigurationTree>(ParameterConfigurationTreeParameterName, "Tree of algorithm parameters that should be optimized."));
       Parameters.Add(new ValueParameter<IntValue>(RepetitionsParameterName, "The number of evaluations for each problem.", new IntValue(3)));
 
@@ -109 +112 @@
       Parameters.Add(new ConstrainedValueParameter<IDoubleValueManipulator>(DoubleValueManipulatorParameterName, "", validDoubleManipulators, new NormalDoubleValueManipulator()));
 
-
       Maximization = new BoolValue(false);
       SolutionCreator = new RandomParameterConfigurationCreator();
@@ -116 +118 @@
       InitializeOperators();
       RegisterParameterEvents();
+      ParameterizeAnalyzer();
       ParameterizeSolutionCreator();
       ParameterizeEvaluator();
@@ -158 +161 @@
     }
     private void ParameterizeAnalyzer() {
+      if (BestParameterConfigurationAnalyzer != null) {
+        BestParameterConfigurationAnalyzer.ParameterConfigurationParameter.ActualName = ((RandomParameterConfigurationCreator)SolutionCreator).ParameterConfigurationParameter.ActualName;
+      }
     }
     private void ParameterizeOperators() {
-      
+      foreach (IParameterConfigurationCrossover op in Operators.OfType<IParameterConfigurationCrossover>()) {
+        op.ParentsParameter.ActualName = ((RandomParameterConfigurationCreator)SolutionCreator).ParameterConfigurationParameter.ActualName;
+        op.ChildParameter.ActualName = ((RandomParameterConfigurationCreator)SolutionCreator).ParameterConfigurationParameter.ActualName;
+      }
+      foreach (IParameterConfigurationManipulator op in Operators.OfType<IParameterConfigurationManipulator>()) {
+        op.ParameterConfigurationTreeParameter.ActualName = ((RandomParameterConfigurationCreator)SolutionCreator).ParameterConfigurationParameter.ActualName;
+      }
     }