Changeset 5359 for branches/HeuristicLab.MetaOptimization

Timestamp:

01/24/11 01:33:29 (14 years ago)

Author:

cneumuel

Message:

#1215

• renamed RunsAnalyzer to SolutionCacheAnalyzer
• only most recent results will stay in cache to avoid memory problems
• some minor tweaks and bugfixes

Location:

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

Files:

• Analyzers/BestParameterConfigurationAnalyzer.cs (modified) (2 diffs)
• Analyzers/ReferenceQualityAnalyzer.cs (modified) (2 diffs)
• Analyzers/SolutionCacheAnalyzer.cs (added)
• Encoding/ParameterConfigurationTree.cs (modified) (2 diffs)
• Encoding/ParameterConfigurations/ParameterConfiguration.cs (modified) (1 diff)
• Encoding/ValueConfigurations/CheckedValueConfigurationCollection.cs (modified) (2 diffs)
• Encoding/ValueConfigurations/ValueConfiguration.cs (modified) (6 diffs)
• Evaluators/ParameterConfigurationEvaluator.cs (modified) (6 diffs)
• HeuristicLab.Problems.MetaOptimization-3.3.csproj (modified) (1 diff)
• Interfaces/IValueConfiguration.cs (modified) (1 diff)
• MetaOptimizationProblem.cs (modified) (2 diffs)
• MetaOptimizationUtil.cs (added)

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

@@ -12 +12 @@
 namespace HeuristicLab.Problems.MetaOptimization {
   /// <summary>
-  /// TODO An operator for analyzing the best solution of Traveling Salesman Problems given in path representation using city coordinates.
+  /// TODO 
   /// </summary>
   [Item("BestParameterConfigurationAnalyzer", "")]
@@ -98 +98 @@
       foreach (ParameterConfigurationTree pt in parameterTrees.OrderBy(x => x.AverageQualityNormalized)) { // todo: respect Maximization:true/false
         IRun run = new Run();
-        run.Name = string.Format("Individuum ({0})", i);
+        run.Name = string.Format("Individual {0} ({1})", i, pt.ParameterInfoString);
         pt.CollectResultValues(run.Results);
         pt.CollectParameterValues(run.Parameters);
+        MetaOptimizationUtil.ClearParameters(run, pt.GetOptimizedParameterNames());
         rc.Add(run);
         i++;

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

@@ -59 +59 @@
         ProblemQualityReferenceParameter.ActualValue = referenceQualities;
         NormalizePopulation(solutions, qualities, referenceQualities);
-        results.Add(new Result("ProblemsAverageQualityReferences", referenceQualities));
+        results.Add(new Result("QualityReferences", referenceQualities));
       }
 
@@ -75 +75 @@
     private void NormalizePopulation(ItemArray<ParameterConfigurationTree> solutions, ItemArray<DoubleValue> qualities, DoubleArray referenceQualities) {
       for (int i = 0; i < solutions.Length; i++) {
-        qualities[i].Value = ParameterConfigurationEvaluator.NormalizeQualities(solutions[i], referenceQualities.ToArray());
+        qualities[i].Value = MetaOptimizationUtil.NormalizeQualities(solutions[i], referenceQualities.ToArray());
       }
     }

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

@@ -126 +126 @@
     protected ParameterConfigurationTree(ParameterConfigurationTree original, Cloner cloner)
       : base(original, cloner) {
-      this.name = original.name;
+      this.averageQualityNormalized = cloner.Clone(original.averageQualityNormalized);
+      this.qualitiesNormalized = cloner.Clone(original.qualitiesNormalized);
       this.bestQualities = cloner.Clone(original.BestQualities);
       this.averageQualities = cloner.Clone(original.averageQualities);
@@ -139 +140 @@
         this.parameters.Add(p.Key, cloner.Clone(p.Value));
       }
+      this.name = original.name;
     }
     public override IDeepCloneable Clone(Cloner cloner) {

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

@@ -369 +369 @@
         StringBuilder sb = new StringBuilder();
         if (this.Optimize) {
-          sb.Append(string.Format("{0}: {1}", parameterName, this.ActualValue.Value != null ? this.ActualValue.Value.ToString() : "null"));
+          var vc = this.ValueConfigurations[actualValueConfigurationIndex];
+          if (IsSubclassOfRawGeneric(typeof(ValueTypeValue<>), vc.GetType())) {
+            // for int, double, bool use the value directly
+            sb.Append(string.Format("{0}: {1}", parameterName, this.ActualValue.Value != null ? this.ActualValue.Value.ToString() : "null"));
+          } else {
+            // for other types use NumberedName (this also uses the Number-Property for otherwise ambiguous ValueConfigurations)
+            sb.Append(string.Format("{0}: {1}", parameterName, vc.NumberedName));
+          }
 
           if (this.ActualValue.Value is IParameterizedItem) {

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

@@ -50 +50 @@
 
     private void RegisterEvents() {
+      this.ItemsAdded += new CollectionItemsChangedEventHandler<IndexedItem<IValueConfiguration>>(CheckedValueConfigurationList_ItemsAdded);
       this.ItemsRemoved += new CollectionItemsChangedEventHandler<IndexedItem<IValueConfiguration>>(CheckedValueConfigurationList_ItemsRemoved);
     }
@@ -55 +56 @@
     private void DeregisterEvents() {
       this.ItemsRemoved -= new CollectionItemsChangedEventHandler<IndexedItem<IValueConfiguration>>(CheckedValueConfigurationList_ItemsRemoved);
+      this.ItemsAdded -= new CollectionItemsChangedEventHandler<IndexedItem<IValueConfiguration>>(CheckedValueConfigurationList_ItemsAdded);
+    }
+
+    void CheckedValueConfigurationList_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<IValueConfiguration>> e) {
+      foreach (var item in e.Items) {
+        if(this.Where(x => x.ItemName == item.Value.ItemName).Count() > 0) {
+          int maxNumber = this.Where(x => x.ItemName == item.Value.ItemName).Select(x => x.Number).Max();
+          item.Value.Number = maxNumber + 1;
+        }
+      }
     }
 

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

@@ -15 +15 @@
   // TODO: ItemName/Descr, storability
   [StorableClass]
-  public class ValueConfiguration : Item, IValueConfiguration {
+  public class ValueConfiguration : NamedItem, IValueConfiguration {
+    public override bool CanChangeName {
+      get { return true; }
+    }
+
+    public override bool CanChangeDescription {
+      get { return true; }
+    }
+
     [Storable]
     protected bool isOptimizable;
@@ -80 +88 @@
           rangeConstraint = value;
           RegisterActualValueEvents();
+        }
+      }
+    }
+
+    [Storable]
+    protected int number = -1;
+    public int Number {
+      get { return number; }
+      set {
+        if (value != number) {
+          number = value;
+          OnToStringChanged();
         }
       }
@@ -113 +133 @@
       this.isOptimizable = original.isOptimizable;
       this.optimize = original.optimize;
+      this.number = original.number;
       RegisterActualValueEvents();
       RegisterRangeConstraintEvents();
@@ -193 +214 @@
     public override string ToString() {
       if (ActualValue != null && ActualValue.Value != null) {
+        string name = NumberedName;
+
         if (ActualValue.Value is IParameterizedItem) {
           if (Optimize) {
-            return string.Format("{0} (Optimize)", ActualValue.Value.ItemName);
+            return string.Format("{0} (Optimize)", name);
           } else {
-            return string.Format("{0}", ActualValue.Value.ItemName);
+            return string.Format("{0}", name);
           }
         } else {
           if (Optimize) {
-            return string.Format("{0} (Optimize: {1})", ActualValue.Value.ItemName, RangeConstraint);
+            return string.Format("{0} (Optimize: {1})", name, RangeConstraint);
           } else {
-            return string.Format("{0}: {1}", ActualValue.Value.ItemName, ActualValue.Value);
+            return string.Format("{0}: {1}", name, ActualValue.Value);
           }
         }
       } else {
         return base.ToString();
+      }
+    }
+
+    public string NumberedName {
+      get {
+        if (this.number == 0) {
+          return ActualValue.Value.ItemName;
+        } else {
+          return string.Format("{0} {1}", ActualValue.Value.ItemName, number);
+        }
       }
     }
@@ -227 +260 @@
     public virtual void Parameterize(IParameterizedItem item) {
       foreach (IParameterConfiguration pc in this.ParameterConfigurations) {
-        pc.Parameterize((IValueParameter)item.Parameters[pc.ParameterName]);
+        if(pc.Optimize) pc.Parameterize((IValueParameter)item.Parameters[pc.ParameterName]);
       }
     }
@@ -287 +320 @@
       }
     }
+
+    public IEnumerable<string> GetOptimizedParameterNames() {
+      var list = new List<string>();
+      this.CollectOptimizedParameterNames(list, "");
+      return list;
+    }
   }
 }

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

@@ -82 +82 @@
       IAlgorithm algorithm = (IAlgorithm)Activator.CreateInstance(AlgorithmTypeParameter.ActualValue.Value);
       IItemList<IProblem> problems = ProblemsParameter.ActualValue;
-      ItemDictionary<StringValue, RunCollection> runsCache = ResultsParameter.ActualValue.ContainsKey("Runs") ? (ItemDictionary<StringValue, RunCollection>)ResultsParameter.ActualValue["Runs"].Value : null;
+      ItemDictionary<StringValue, RunCollection> solutionCache = ResultsParameter.ActualValue.ContainsKey("SolutionCache") ? (ItemDictionary<StringValue, RunCollection>)ResultsParameter.ActualValue["SolutionCache"].Value : null;
       double[] referenceQualities = GetReferenceQualities(problems);
+      int currentGeneration = GenerationsParameter.ActualValue != null ? GenerationsParameter.ActualValue.Value : 0;
+      int repetitions = Repetitions.Value;
 
       RunCollection runs;
-      if (runsCache != null && runsCache.Count(x => x.Key.Value == parameterConfiguration.ParameterInfoString) > 0) {
-        runs = runsCache.Single(x => x.Key.Value == parameterConfiguration.ParameterInfoString).Value;
-        Console.WriteLine("Used Cache for {0}", parameterConfiguration.ParameterInfoString);
+      if (solutionCache != null && solutionCache.Count(x => x.Key.Value == parameterConfiguration.ParameterInfoString) > 0) {
+        runs = solutionCache.Single(x => x.Key.Value == parameterConfiguration.ParameterInfoString).Value;
       } else {
         do {
-          runs = ExecuteAlgorithm(parameterConfiguration, algorithm, problems, Repetitions.Value, GenerationsParameter.ActualValue != null ? GenerationsParameter.ActualValue.Value : 0);
+          runs = ExecuteAlgorithm(parameterConfiguration, algorithm, problems, repetitions, currentGeneration);
           if (runs == null) {
             Repair(parameterConfiguration, random);
@@ -98 +99 @@
         } while (runs == null);
       }
-
+      
       List<List<double>> qualities = new List<List<double>>();
       List<List<TimeSpan>> executionTimes = new List<List<TimeSpan>>();
@@ -117 +118 @@
       parameterConfiguration.Runs = (RunCollection)runs.Clone();
 
-      this.QualityParameter.ActualValue = new DoubleValue(NormalizeQualities(parameterConfiguration, referenceQualities));
+      this.QualityParameter.ActualValue = new DoubleValue(MetaOptimizationUtil.NormalizeQualities(parameterConfiguration, referenceQualities));
 
       return base.Apply();
@@ -147 +148 @@
     /// 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>();
+      var parameterNames = parameterConfiguration.GetOptimizedParameterNames();
       var resultNames = new List<string> { "BestQuality", "Execution Time" };
-      parameterConfiguration.CollectOptimizedParameterNames(parameterNames, "");
 
       // set parameters
@@ -186 +182 @@
           int problemIndex = problems.IndexOf(problem) + 1;
           IRun run = algorithmClone.Runs.Last();
-          CleanRun(run, resultNames, parameterNames);
+          MetaOptimizationUtil.ClearResults(run, resultNames);
+          MetaOptimizationUtil.ClearParameters(run, parameterNames);
           run.Results.Add("Meta.FromCache", new BoolValue(false));
           run.Results.Add("Meta.Generation", new IntValue(currentGeneration));
@@ -197 +194 @@
       return algorithmClone.Runs;
     }
-
-    /// <summary>
-    /// Removes all information from the run which is not needed for lated analysis
-    /// only keep the results which are important and the parameters which were optimized
-    /// </summary>
-    private static void CleanRun(IRun run, IEnumerable<string> resultsToKeep, IEnumerable<string> parametersToKeep) {
-      var resultsToRemove = new List<string>();
-      var parametersToRemove = new List<string>();
-      foreach (var result in run.Results) {
-        if (!resultsToKeep.Contains(result.Key))
-          resultsToRemove.Add(result.Key);
-      }
-      foreach (var parameter in run.Parameters) {
-        if (!parametersToKeep.Contains(parameter.Key))
-          parametersToRemove.Add(parameter.Key);
-      }
-
-      foreach (var result in resultsToRemove)
-        run.Results.Remove(result);
-      foreach (var parameter in parametersToRemove)
-        run.Parameters.Remove(parameter);
-    }
-
-    public static double NormalizeQualities(ParameterConfigurationTree parameterConfigurationTree, double[] referenceQualities) {
-      double[] qualitiesNormalized = new double[referenceQualities.Length];
-      for (int i = 0; i < referenceQualities.Length; i++) {
-        qualitiesNormalized[i] = parameterConfigurationTree.AverageQualities[i] / referenceQualities[i];
-      }
-      parameterConfigurationTree.QualitiesNormalized = new DoubleArray(qualitiesNormalized);
-      parameterConfigurationTree.AverageQualityNormalized = new DoubleValue(qualitiesNormalized.Average());
-      return parameterConfigurationTree.AverageQualityNormalized.Value;
-    }
-
-    public static double Variance(IEnumerable<double> source) {
-      double avg = source.Average();
-      double d = source.Aggregate(0.0, (total, next) => total += Math.Pow(next - avg, 2));
-      return d / (source.Count() - 1);
-    }
-
-    public static double StandardDeviation(IEnumerable<double> source) {
-      return Math.Sqrt(source.Variance());
-    }
   }
 }

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

@@ -134 +134 @@
     <Compile Include="Analyzers\BestParameterConfigurationAnalyzer.cs" />
     <Compile Include="ConstrainedTypeValue.cs" />
+    <Compile Include="MetaOptimizationUtil.cs" />
     <Compile Include="TypeValue.cs" />
     <None Include="Properties\AssemblyInfo.cs.frame" />
     <None Include="HeuristicLabProblemsMetaOptimizationPlugin.cs.frame" />
-    <Compile Include="Analyzers\RunsAnalyzer.cs" />
+    <Compile Include="Analyzers\SolutionCacheAnalyzer.cs" />
     <Compile Include="Analyzers\ReferenceQualityAnalyzer.cs" />
     <Compile Include="ConstrainedItemList.cs" />

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

@@ -8 +8 @@
     IItemCollection<IParameterConfiguration> ParameterConfigurations { get; }
     IRange RangeConstraint { get; }
+    int Number { get; set; } // if larger than 0 it will be visible in the name. this can be used when multiple ValueConfiguration with the same name exist in a list
+    string NumberedName { get; }
+
     event EventHandler ValueChanged;
     

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

@@ -104 +104 @@
       get { return Operators.OfType<ReferenceQualityAnalyzer>().FirstOrDefault(); }
     }
-    private RunsAnalyzer RunsAnalyzer {
-      get { return Operators.OfType<RunsAnalyzer>().FirstOrDefault(); }
+    private SolutionCacheAnalyzer RunsAnalyzer {
+      get { return Operators.OfType<SolutionCacheAnalyzer>().FirstOrDefault(); }
     }
     #endregion
@@ -169 +169 @@
       Operators.Add(new BestParameterConfigurationAnalyzer());
       Operators.Add(new ReferenceQualityAnalyzer());
-      Operators.Add(new RunsAnalyzer());
+      Operators.Add(new SolutionCacheAnalyzer());
     }
     private void ParameterizeSolutionCreator() {