Changeset 5665 for branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding

Timestamp:

03/10/11 19:26:58 (14 years ago)

Author:

cneumuel

Message:

#1215

• implemented optimization of problem parameters

Location:

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

Files:

• AlgorithmProblemItem.cs (added)
• ParameterConfigurationTree.cs (modified) (5 diffs)
• ParameterConfigurations/ParameterConfiguration.cs (modified) (5 diffs)
• ParameterConfigurations/SingleValuedParameterConfiguration.cs (added)
• ValueConfigurations/ParameterizedValueConfiguration.cs (modified) (6 diffs)
• ValueConfigurations/ValueConfiguration.cs (modified) (2 diffs)

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

@@ -2 +2 @@
 using System.Collections;
 using System.Collections.Generic;
+using System.Linq;
+using System.Text;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -103 +105 @@
     }
 
-    [Storable]
-    protected string name;
-    public string Name {
-      get { return name; }
-      set { name = value; }
-    }
+    public ParameterizedValueConfiguration AlgorithmConfiguration {
+      get {
+        return this.ParameterConfigurations.ElementAt(0).ValueConfigurations.First() as ParameterizedValueConfiguration;
+      }
+    }
+
+    public ParameterizedValueConfiguration ProblemConfiguration {
+      get {
+        return this.ParameterConfigurations.ElementAt(1).ValueConfigurations.First() as ParameterizedValueConfiguration;
+      }
+    }
+
+    //[Storable]
+    //protected string name;
+    //public string Name {
+    //  get { return name; }
+    //  set { name = value; }
+    //}
 
     #region constructors and cloning
-    public ParameterConfigurationTree(IAlgorithm algorithm)
-      : base(null, algorithm.GetType()) {
-      this.Optimize = true; // root must always be optimized
+    public ParameterConfigurationTree(IAlgorithm algorithm, IProblem problem)
+      : base(null, algorithm.GetType(), false) {
+      this.Optimize = false;
+      this.IsOptimizable = false;
       this.parameters = new Dictionary<string, IItem>();
       this.Name = algorithm.ItemName;
-      PopulateParameterConfigurations(algorithm);
-    }
-    public ParameterConfigurationTree() {
-    }
+
+      var algproblemitem = new AlgorithmProblemItem();
+      algproblemitem.AlgorithmParameter.Value = algorithm;
+      algproblemitem.ProblemParameter.Value = problem;
+      this.discoverValidValues = false;
+      
+      this.parameterConfigurations.Add(new SingleValuedParameterConfiguration("Algorithm", algproblemitem.AlgorithmParameter));
+      this.parameterConfigurations.Add(new SingleValuedParameterConfiguration("Problem", algproblemitem.ProblemParameter));
+    }
+    public ParameterConfigurationTree() { }
     [StorableConstructor]
     protected ParameterConfigurationTree(bool deserializing) : base(deserializing) { }
@@ -138 +159 @@
         this.parameters.Add(p.Key, cloner.Clone(p.Value));
       }
-      this.name = original.name;
+      //this.name = original.name;
     }
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -181 +202 @@
     public override void Parameterize(IParameterizedItem item) {
       this.parameters.Clear();
-      base.Parameterize(item);
-      ((IAlgorithm)item).CollectParameterValues(this.Parameters);
+      var algorithm = item as IAlgorithm;
+      var problem = algorithm.Problem;
+
+      AlgorithmConfiguration.Parameterize(algorithm);
+      ProblemConfiguration.Parameterize(problem);
+
+      //((IAlgorithm)AlgorithmConfiguration.ActualValue.Value).CollectParameterValues(this.Parameters);
+      //((IProblem)ProblemConfiguration.ActualValue.Value).CollectParameterValues(this.Parameters);
     }
 
@@ -251 +278 @@
       return run;
     }
+
+    public override string ParameterInfoString {
+      get {
+        string algorithmInfo = this.AlgorithmConfiguration.ParameterInfoString;
+        string problemInfo = this.ProblemConfiguration.ParameterInfoString;
+        var sb = new StringBuilder();
+        if (!string.IsNullOrEmpty(algorithmInfo)) {
+          sb.Append("Algorithm: ");
+          sb.Append(algorithmInfo);
+        }
+        if (!string.IsNullOrEmpty(problemInfo)) {
+          if (sb.Length > 0)
+            sb.Append(", ");
+          sb.Append("Problem: ");
+          sb.Append(problemInfo);
+        }
+        return sb.ToString();
+      }
+    }
   }
 }

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

@@ -128 +128 @@
 
     [Storable]
+    protected bool discoverValidValues;
+    public bool DiscoverValidValues {
+      get { return discoverValidValues; }
+      set { discoverValidValues = value; }
+    }
+
+    [Storable]
     protected IItemSet<IItem> validValues;
 
     #region Constructors and Cloning
-    public ParameterConfiguration(string parameterName, IValueParameter valueParameter) {
+    public ParameterConfiguration(string parameterName, IValueParameter valueParameter, bool discoverValidValues) {
       this.ParameterName = parameterName;
       this.parameterDataType = valueParameter.GetType();
       this.valueDataType = valueParameter.DataType;
-      this.validValues = GetValidValues(valueParameter);
+      this.discoverValidValues = discoverValidValues;
+      this.validValues = discoverValidValues ? GetValidValues(valueParameter) : new ItemSet<IItem> { valueParameter.Value };
       this.validTypes = GetValidTypes(valueParameter).ToArray();
       this.IsNullable = valueParameter.ItemName.StartsWith("Optional");
@@ -169 +177 @@
       this.isNullable = original.isNullable;
       this.itemImage = original.itemImage;
+      this.discoverValidValues = original.discoverValidValues;
       if (this.valueConfigurations != null) RegisterValueConfigurationEvents();
     }
@@ -210 +219 @@
             val = CreateItem(t);
           }
-          if (val is IParameterizedItem) {
-            this.ValueConfigurations.Add(new ParameterizedValueConfiguration(val, val.GetType()), true);
-          } else {
-            this.ValueConfigurations.Add(new RangeValueConfiguration(val, val.GetType()), true);
+          if (val != null) { // val can be null when ValidValues does not contain the type (this can happen when discoverValidValues=false)
+            if (val is IParameterizedItem) {
+              this.ValueConfigurations.Add(new ParameterizedValueConfiguration(val, val.GetType(), true), true);
+            } else {
+              this.ValueConfigurations.Add(new RangeValueConfiguration(val, val.GetType()), true);
+            }
           }
         }
@@ -395 +406 @@
     }
 
-    public static IParameterConfiguration Create(IParameterizedNamedItem parent, IParameter parameter) {
+    public static IParameterConfiguration Create(IParameterizedNamedItem parent, IParameter parameter, bool discoverValidValues) {
       if (parameter is IValueParameter) {
         IValueParameter valueParameter = parameter as IValueParameter;
-        return new ParameterConfiguration(parameter.Name, valueParameter);
+        return new ParameterConfiguration(parameter.Name, valueParameter, discoverValidValues);
       }
       return null;
@@ -410 +421 @@
       }
       var clonedValue = this.ActualValue.Value != null ? (IItem)this.ActualValue.Value.Clone() : null;
-      if(clonedValue != null) AdaptValidValues(parameter, clonedValue);
+      if (clonedValue != null) AdaptValidValues(parameter, clonedValue);
       parameter.Value = clonedValue;
     }

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

@@ -12 +12 @@
     [Storable]
     protected IItemCollection<IParameterConfiguration> parameterConfigurations = new ItemCollection<IParameterConfiguration>();
-    public IItemCollection<IParameterConfiguration> ParameterConfigurations {
+    public virtual IItemCollection<IParameterConfiguration> ParameterConfigurations {
       get { return new ReadOnlyItemCollection<IParameterConfiguration>(this.parameterConfigurations); }
       protected set { this.parameterConfigurations = value; }
@@ -23 +23 @@
         if (optimize) {
           ClearParameterConfigurations();
-          if (this.actualValue.Value is IParameterizedNamedItem) PopulateParameterConfigurations(this.actualValue.Value as IParameterizedNamedItem);
+          if (this.actualValue.Value is IParameterizedNamedItem) PopulateParameterConfigurations(this.actualValue.Value as IParameterizedNamedItem, this.discoverValidValues);
         } else {
           ClearParameterConfigurations();
@@ -35 +35 @@
         ClearParameterConfigurations();
         base.ActualValue = value;
-        if(this.actualValue.Value != null) PopulateParameterConfigurations(this.actualValue.Value as IParameterizedNamedItem);
+        if(this.actualValue.Value != null) PopulateParameterConfigurations(this.actualValue.Value as IParameterizedNamedItem, this.discoverValidValues);
       }
+    }
+
+    [Storable]
+    protected bool discoverValidValues;
+    public bool DiscoverValidValues {
+      get { return discoverValidValues; }
+      set { discoverValidValues = value; }
     }
 
@@ -45 +52 @@
       this.ParameterConfigurations = new ItemList<IParameterConfiguration>();
     }
-    public ParameterizedValueConfiguration(IItem value, Type valueDataType)
+    public ParameterizedValueConfiguration(IItem value, Type valueDataType, bool discoverValidValues)
       : base(value, valueDataType) {
+      this.discoverValidValues = discoverValidValues;
     }
     protected ParameterizedValueConfiguration(ParameterizedValueConfiguration original, Cloner cloner)
       : base(original, cloner) {
+      this.discoverValidValues = original.discoverValidValues;
       this.ParameterConfigurations = cloner.Clone(original.parameterConfigurations);
     }
@@ -57 +66 @@
     #endregion
 
-    protected virtual void PopulateParameterConfigurations(IParameterizedNamedItem parameterizedItem) {
+    protected virtual void PopulateParameterConfigurations(IParameterizedNamedItem parameterizedItem, bool discoverValidValues) {
       foreach (var childParameter in parameterizedItem.Parameters) {
-        var pc = ParameterConfiguration.Create(parameterizedItem, childParameter);
-        if (pc != null) this.parameterConfigurations.Add(pc);
+        IValueParameter valueParameter = childParameter as IValueParameter;
+        if (valueParameter != null) {
+          var pc = new ParameterConfiguration(valueParameter.Name, valueParameter, discoverValidValues);
+          this.parameterConfigurations.Add(pc);
+        }
       }
     }
@@ -71 +83 @@
       get {
         StringBuilder sb = new StringBuilder();
-        if (this.Optimize && this.ParameterConfigurations.Count > 0) {
+        if ((this.Optimize) && this.ParameterConfigurations.Count > 0) {
           var parameterInfos = new List<string>();
           foreach (var pc in this.ParameterConfigurations) {

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

@@ -2 +2 @@
 using System.Collections.Generic;
 using System.Drawing;
-using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.PluginInfrastructure;
 
 namespace HeuristicLab.Problems.MetaOptimization {
@@ -74 +72 @@
     #region Constructors and Cloning
     public ValueConfiguration(IItem value, Type valueDataType) {
-      var validTypes = ApplicationManager.Manager.GetTypes(valueDataType).OrderBy(x => x.Name).ToArray();
       this.ActualValue = new ConstrainedValue(value, valueDataType, new ItemSet<IItem> { value }, false);
       this.IsOptimizable = true;