Changeset 5357

Timestamp:

01/23/11 12:47:33 (14 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

Location:

branches/HeuristicLab.MetaOptimization

Files:

• HeuristicLab.MetaOptimization.Test/Program.cs (modified) (3 diffs)
• HeuristicLab.Problems.MetaOptimization/3.3/Encoding/ParameterCombinationsEnumerator.cs (modified) (1 diff)
• HeuristicLab.Problems.MetaOptimization/3.3/Encoding/ValueConfigurations/ValueConfiguration.cs (modified) (2 diffs)
• HeuristicLab.Problems.MetaOptimization/3.3/Evaluators/ParameterConfigurationEvaluator.cs (modified) (10 diffs)

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

@@ -39 +39 @@
     static void Main(string[] args) {
       ContentManager.Initialize(new PersistenceContentManager());
-
+      
       //TestTableBuilder();
       //TestShorten();
@@ -51 +51 @@
       //TestCombinations3();
       //TestEnumeratorCollectionEnumerator();
-      //TestCombinations4();
+      //TestCombinations4(); return;
       //TestAlgorithmPerformanceIssue();
       //TestWaitAny();
@@ -566 +566 @@
       });
 
-      ConfigurePopulationSize(algorithmVc, 12, 100, 1);
+      ConfigurePopulationSize(algorithmVc, 0, 20, 1);
       //ConfigureMutationRate(algorithmVc, 0.0, 1.0, 0.01);
       //ConfigureMutationOperator(algorithmVc);
-      ConfigureElites(algorithmVc, 0, 10, 1);
+      ConfigureElites(algorithmVc, 0, 30, 1);
       //ConfigureSelectionOperator(algorithmVc, true);
       return algorithmVc;

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

@@ -109 +109 @@
             }
           }
+          enumerators.Reverse(); // this makes the list of combinations better readable
         }
       }

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

@@ -214 +214 @@
       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()));
-          }
+        if (this.Optimize && 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();
@@ -273 +271 @@
       var list = new List<IOptimizable>();
       foreach (var pc in ParameterConfigurations) {
-        if(pc.Optimize) {
-          if(pc.ValueConfigurations.CheckedItems.Count() > 1) list.Add(pc); // only add if there are more than 1 choices. otherwise it makes no sense to optimize which VC is selected
+        if (pc.Optimize) {
+          if (pc.ValueConfigurations.CheckedItems.Count() > 1) list.Add(pc); // only add if there are more than 1 choices. otherwise it makes no sense to optimize which VC is selected
           list.AddRange(pc.GetAllOptimizables());
         }

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>();