Changeset 5357 for branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Evaluators

Timestamp:

01/23/11 12:47:33 (13 years ago)

Author:

cneumuel

Message:

#1215

• changed ordering of parameter combinations to make them better readable
• changed handling of invalid parameter settings from penalty approach to repair approach

File:

• branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Evaluators/ParameterConfigurationEvaluator.cs (modified) (10 diffs)

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

@@ -21 +21 @@
   [Item("ParameterConfigurationEvaluator", "A base class for operators which evaluate Meta Optimization solutions.")]
   [StorableClass]
-  public class ParameterConfigurationEvaluator : SingleSuccessorOperator, IParameterConfigurationEvaluator {
-    private const double PenaltyQuality = 100000.0; // todo: use something better
-
+  public class ParameterConfigurationEvaluator : SingleSuccessorOperator, IParameterConfigurationEvaluator, IStochasticOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
     public ILookupParameter<DoubleValue> QualityParameter {
       get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
@@ -56 +57 @@
     public ParameterConfigurationEvaluator()
       : 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<DoubleValue>("Quality", "The evaluated quality of the ParameterVector."));
       Parameters.Add(new LookupParameter<TypeValue>(MetaOptimizationProblem.AlgorithmTypeParameterName, "Missing description."));
@@ -76 +78 @@
 
     public override IOperation Apply() {
+      IRandom random = RandomParameter.ActualValue;
       ParameterConfigurationTree parameterConfiguration = ParameterConfigurationParameter.ActualValue;
       IAlgorithm algorithm = (IAlgorithm)Activator.CreateInstance(AlgorithmTypeParameter.ActualValue.Value);
@@ -87 +90 @@
         Console.WriteLine("Used Cache for {0}", parameterConfiguration.ParameterInfoString);
       } else {
-        runs = ExecuteAlgorithm(parameterConfiguration, algorithm, problems);
+        do {
+          runs = ExecuteAlgorithm(parameterConfiguration, algorithm, problems, Repetitions.Value, GenerationsParameter.ActualValue != null ? GenerationsParameter.ActualValue.Value : 0);
+          if (runs == null) {
+            Repair(parameterConfiguration, random);
+            parameterConfiguration.Parameterize(algorithm);
+          }
+        } while (runs == null);
       }
 
@@ -111 +120 @@
 
       return base.Apply();
+    }
+
+    /// <summary>
+    /// This method should repair an invalid parameterConfiguration.
+    /// The strategy is to just randomize parameter settings. It's not guaranteed to be a vaild setting
+    /// </summary>
+    private void Repair(ParameterConfigurationTree parameterConfiguration, IRandom random) {
+      parameterConfiguration.Randomize(random);
     }
 
@@ -127 +144 @@
     }
 
-    private RunCollection ExecuteAlgorithm(ParameterConfigurationTree parameterConfiguration, IAlgorithm algorithm, IItemList<IProblem> problems) {
+    /// <summary>
+    /// Executes an algorithm 
+    /// </summary>
+    /// <param name="parameterConfiguration"></param>
+    /// <param name="algorithm"></param>
+    /// <param name="problems"></param>
+    /// <returns></returns>
+    private static RunCollection ExecuteAlgorithm(ParameterConfigurationTree parameterConfiguration, IAlgorithm algorithm, IItemList<IProblem> problems, int repetitions, int currentGeneration) {
       IAlgorithm algorithmClone = (IAlgorithm)algorithm.Clone();
       var parameterNames = new List<string>();
@@ -145 +169 @@
         algorithmClone.Problem = (IProblem)problem.Clone();
 
-        for (int i = 0; i < Repetitions.Value; i++) {
+        for (int i = 0; i < repetitions; i++) {
           algorithmClone.Prepare();
 
@@ -152 +176 @@
 
           if (algorithmClone.ExecutionState == ExecutionState.Paused) {
-            // this parametercombination was bad. set penalty for this solution
-            // TODO!
+            // the parameter settings were invalid. 
+            // (1) set penalty for this solution. 
+            //     it's difficult to create penalty values for BestQuality and ExecutionTime. Maybe ReferenceQuality * X (but what about ExecutionTime?)
+            //     therefore use repair instead.
+            
+            // (2) repair and retry
+            return null;
           }
           int problemIndex = problems.IndexOf(problem) + 1;
@@ -159 +188 @@
           CleanRun(run, resultNames, parameterNames);
           run.Results.Add("Meta.FromCache", new BoolValue(false));
-          run.Results.Add("Meta.Generation", new IntValue(GenerationsParameter.ActualValue != null ? GenerationsParameter.ActualValue.Value : 0));
+          run.Results.Add("Meta.Generation", new IntValue(currentGeneration));
           run.Results.Add("Meta.ProblemIndex", new IntValue(problemIndex));
           int runCountOfThisProblem = algorithmClone.Runs.Where(x => ((IntValue)x.Results["Meta.ProblemIndex"]).Value == problemIndex).Count();
@@ -173 +202 @@
     /// only keep the results which are important and the parameters which were optimized
     /// </summary>
-    private void CleanRun(IRun run, IEnumerable<string> resultsToKeep, IEnumerable<string> parametersToKeep) {
+    private static void CleanRun(IRun run, IEnumerable<string> resultsToKeep, IEnumerable<string> parametersToKeep) {
       var resultsToRemove = new List<string>();
       var parametersToRemove = new List<string>();