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

Timestamp:

04/01/11 17:15:41 (14 years ago)

Author:

cneumuel

Message:

#1215

• worked on configurability of SymbolicExpressionGrammar

Location:

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

Files:

• ParameterConfigurationTree.cs (modified) (2 diffs)
• ParameterConfigurations/ParameterConfiguration.cs (modified) (11 diffs)
• ParameterConfigurations/SingleValuedParameterConfiguration.cs (modified) (3 diffs)
• SymbolicRegression (added)
• SymbolicRegression/SymbolValueConfiguration.cs (added)
• SymbolicRegression/SymbolicExpressionGrammarValueConfiguration.cs (added)
• ValueConfigurations/CheckedValueConfigurationCollection.cs (modified) (4 diffs)
• ValueConfigurations/ParameterizedValueConfiguration.cs (modified) (4 diffs)
• ValueConfigurations/ValueConfiguration.cs (modified) (2 diffs)

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

@@ -208 +208 @@
       ProblemConfiguration.Parameterize(problem);
 
-      //((IAlgorithm)AlgorithmConfiguration.ActualValue.Value).CollectParameterValues(this.Parameters);
+      algorithm.CollectParameterValues(this.Parameters);
       //((IProblem)ProblemConfiguration.ActualValue.Value).CollectParameterValues(this.Parameters);
-    }
+      //CollectAlgorithmParameterValues((IAlgorithm)AlgorithmConfiguration.ActualValue.Value, parameters);
+    }
+
+    //protected virtual void CollectAlgorithmParameterValues(IAlgorithm algorithm, IDictionary<string, IItem> values) {
+    //  var algorithmValues = new Dictionary<string, IItem>();
+    //  algorithm.CollectParameterValues(algorithmValues);
+    //  foreach (var value in algorithmValues) {
+    //    values.Add("Algorithm." + value.Key, value.Value);
+    //  }
+    //}
 
     public Experiment GenerateExperiment(IAlgorithm algorithm, bool createBatchRuns, int repetitions) {
@@ -297 +306 @@
       }
     }
+
+    public override void CollectOptimizedParameterNames(List<string> parameterNames, string prefix) {
+      AlgorithmConfiguration.CollectOptimizedParameterNames(parameterNames, string.Empty);
+      ProblemConfiguration.CollectOptimizedParameterNames(parameterNames, string.Empty);
+    }
+
+   
   }
 }

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

@@ -9 +9 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -25 +26 @@
     [Storable]
     protected bool optimize;
-    public bool Optimize {
+    public virtual bool Optimize {
       get { return optimize; }
       set {
@@ -33 +34 @@
             PopulateValueConfigurations();
           } else {
-            this.ValueConfigurations.Clear();
+            ClearValueConfigurations();
           }
           OnOptimizeChanged();
@@ -42 +43 @@
 
     [Storable]
-    private Image itemImage;
-    public virtual Image ItemImage {
+    protected Image itemImage;
+    public override Image ItemImage {
       get { return itemImage ?? base.ItemImage; }
     }
@@ -160 +161 @@
       }
     }
-
+    public ParameterConfiguration(string parameterName, Type type, IItem actualValue, IEnumerable<IValueConfiguration> valueConfigurations) {
+      this.ParameterName = parameterName;
+      this.parameterDataType = type;
+      this.valueDataType = type;
+      this.discoverValidValues = false;
+      this.validValues = null; // maybe use values from valueConfigurations
+      this.validTypes = new Type[] { type };
+      this.IsNullable = false;
+      this.itemImage = valueConfigurations.Count() > 0 ? valueConfigurations.FirstOrDefault().ItemImage : null;
+      this.ValueConfigurations = new CheckedValueConfigurationList(valueConfigurations);
+      this.ActualValue = new ConstrainedValue(actualValue, type, CreateValidValues(), this.IsNullable);
+    }
+    public ParameterConfiguration(string parameterName, Type type, IItem actualValue) {
+      this.ParameterName = parameterName;
+      this.parameterDataType = type;
+      this.valueDataType = type;
+      this.discoverValidValues = false;
+      this.validValues = null;
+      this.validTypes = new Type[] { type };
+      this.IsNullable = false;
+      this.itemImage = actualValue.ItemImage;
+      this.ValueConfigurations = new CheckedValueConfigurationList();
+      this.ActualValue = new ConstrainedValue(actualValue, type, CreateValidValues(), this.IsNullable);
+      if (Optimize) {
+        PopulateValueConfigurations();
+      }
+    }
     public ParameterConfiguration() { }
     [StorableConstructor]
@@ -180 +207 @@
       if (this.valueConfigurations != null) RegisterValueConfigurationEvents();
     }
+
+
     public override IDeepCloneable Clone(Cloner cloner) {
       return new ParameterConfiguration(this, cloner);
@@ -208 +237 @@
     }
 
-    private void PopulateValueConfigurations() {
+    protected virtual void PopulateValueConfigurations() {
       foreach (Type t in this.validTypes) {
         if (t == typeof(NullValue)) {
@@ -220 +249 @@
           }
           if (val != null) { // val can be null when ValidValues does not contain the type (this can happen when discoverValidValues=false)
+            IValueConfiguration valueConfiguration;
             if (val is IParameterizedItem) {
-              this.ValueConfigurations.Add(new ParameterizedValueConfiguration(val, val.GetType(), true), true);
+              valueConfiguration = new ParameterizedValueConfiguration(val, val.GetType(), true);
             } else {
-              this.ValueConfigurations.Add(new RangeValueConfiguration(val, val.GetType()), true);
+              if (val is ISymbolicExpressionGrammar) {
+                valueConfiguration = new SymbolicExpressionGrammarValueConfiguration((ISymbolicExpressionGrammar)val);
+              } else {
+                valueConfiguration = new RangeValueConfiguration(val, val.GetType());
+              }
             }
-          }
-        }
-      }
+            this.ValueConfigurations.Add(valueConfiguration, true);
+          }
+        }
+      }
+    }
+
+    protected virtual void ClearValueConfigurations() {
+      this.ValueConfigurations.Clear();
     }
 
@@ -260 +299 @@
     public IItem CreateItem(Type type) {
       // no valid values; just instantiate
-      if (validValues == null)
-        return (IItem)Activator.CreateInstance(type);
+      try {
+        if (validValues == null)
+          return (IItem)Activator.CreateInstance(type);
+      }
+      catch (MissingMemberException) {
+        return null; // can happen, when ApplicationManager.Manager.GetTypes(type, OnlyInstantiable=true) returns objects which have no default constructor
+      }
 
       if (type == typeof(NullValue))
@@ -279 +323 @@
         try {
           var val = CreateItem(t);
-          validValues.Add(val);
+          if (val != null) validValues.Add(val);
         }
         catch (MissingMethodException) { /* Constructor is missing, don't use those types */ }
@@ -415 +459 @@
 
     public void Parameterize(IValueParameter parameter) {
+      if (parameter is IFixedValueParameter)
+        return;
+
       if (Optimize) {
         if (this.ActualValue.Value is IParameterizedItem) {
           ((ParameterizedValueConfiguration)this.ValueConfigurations[actualValueConfigurationIndex]).Parameterize((IParameterizedItem)this.ActualValue.Value);
+        }
+        if (this.ActualValue.Value is ISymbolicExpressionGrammar) {
+          ((SymbolicExpressionGrammarValueConfiguration)this.ValueConfigurations[actualValueConfigurationIndex]).Parameterize((ISymbolicExpressionGrammar)this.ActualValue.Value);
         }
       }

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

@@ -1 @@
-using System.Linq;
+using System;
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -14 +15 @@
       : base(parameterName, valueParameter, false) {
       this.Optimize = true;
+      base.PopulateValueConfigurations();
       this.ValueConfigurations.Single().Optimize = true;
+    }
+    public SingleValuedParameterConfiguration(string parameterName, IValueConfiguration valueConfiguration) {
+      this.ParameterName = parameterName;
+      this.parameterDataType = valueConfiguration.ActualValue.ValueDataType;
+      this.valueDataType = valueConfiguration.ActualValue.ValueDataType;
+      this.discoverValidValues = false;
+      this.validValues = new ItemSet<IItem> { valueConfiguration.ActualValue.Value };
+      this.validTypes = new Type[] {valueConfiguration.ActualValue.ValueDataType};
+      this.IsNullable = false;
+      this.itemImage = valueConfiguration.ItemImage;
+      this.ValueConfigurations = new CheckedValueConfigurationList { valueConfiguration };
+      this.ValueConfigurations.Single().Optimize = true;
+      valueConfiguration.ToStringChanged += new EventHandler(valueConfiguration_ToStringChanged);
+      this.ActualValue = new ConstrainedValue(
+        valueConfiguration.ActualValue.Value,
+        valueConfiguration.ActualValue.ValueDataType,
+        this.validValues,
+        this.IsNullable);
     }
     public SingleValuedParameterConfiguration() { }
@@ -24 +44 @@
     }
     #endregion
+
+    protected override void PopulateValueConfigurations() {
+      // don't change valueconfigurations, since it only contains the one element specified in constructor
+    }
+
+    protected override void ClearValueConfigurations() {
+      // do nothing
+    }
+
+    public override string ToString() {
+      if (this.valueConfigurations.First() is SymbolValueConfiguration) {
+        var syVc = (SymbolValueConfiguration)this.valueConfigurations.First();
+        if (this.Optimize) {
+          return syVc.ToString() + " (Optimize)";
+        } else {
+          return syVc.ToString();
+        }
+      } else {
+        return base.ToString();
+      }
+    }
+
+    private void valueConfiguration_ToStringChanged(object sender, EventArgs e) {
+      OnToStringChanged();
+    }
   }
 }

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

@@ -1 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Linq;
-using System.Text;
+using HeuristicLab.Collections;
+using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Common;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Collections;
 
 namespace HeuristicLab.Problems.MetaOptimization {
@@ -29 +27 @@
       RegisterEvents();
     }
+    public CheckedValueConfigurationList(IEnumerable<IValueConfiguration> collection)
+      : base(collection) {
+      validValues = null;
+      // event wiring not needed
+    }
     public CheckedValueConfigurationList() {
       RegisterEvents();
@@ -43 +46 @@
       RegisterEvents();
     }
+
     public override IDeepCloneable Clone(Cloner cloner) {
       return new CheckedValueConfigurationList(this, cloner);
@@ -61 +65 @@
     }
 
-    void CheckedValueConfigurationList_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<IValueConfiguration>> e) {
+    private void CheckedValueConfigurationList_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<IValueConfiguration>> e) {
       foreach (var item in e.Items) {
         var matchingItems = this.Where(x => x != item.Value && x.ActualValue.ValueDataType == item.Value.ActualValue.ValueDataType);

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

@@ -20 +20 @@
       get { return base.Optimize; }
       set {
-        base.Optimize = value;
-        if (optimize) {
-          ClearParameterConfigurations();
-          if (this.actualValue.Value is IParameterizedNamedItem) PopulateParameterConfigurations(this.actualValue.Value as IParameterizedNamedItem, this.discoverValidValues);
-        } else {
-          ClearParameterConfigurations();
+        if (this.optimize != value) {
+          base.Optimize = value;
+          if (optimize) {
+            ClearParameterConfigurations();
+            PopulateParameterConfigurations(this.actualValue.Value, this.discoverValidValues);
+          } else {
+            ClearParameterConfigurations();
+          }
         }
       }
@@ -35 +37 @@
         ClearParameterConfigurations();
         base.ActualValue = value;
-        if(this.actualValue.Value != null) PopulateParameterConfigurations(this.actualValue.Value as IParameterizedNamedItem, this.discoverValidValues);
+        if (this.Optimize && this.actualValue.Value != null) PopulateParameterConfigurations(this.actualValue.Value, this.discoverValidValues);
       }
     }
@@ -66 +68 @@
     #endregion
 
-    protected virtual void PopulateParameterConfigurations(IParameterizedNamedItem parameterizedItem, bool discoverValidValues) {
-      foreach (var childParameter in parameterizedItem.Parameters) {
-        IValueParameter valueParameter = childParameter as IValueParameter;
-        if (valueParameter != null) {
-          var pc = new ParameterConfiguration(valueParameter.Name, valueParameter, discoverValidValues);
-          this.parameterConfigurations.Add(pc);
+    protected virtual void PopulateParameterConfigurations(IItem item, bool discoverValidValues) {
+      var parameterizedItem = item as IParameterizedItem;
+      if (parameterizedItem != null) {
+        foreach (var childParameter in parameterizedItem.Parameters) {
+          IValueParameter valueParameter = childParameter as IValueParameter;
+          if (valueParameter != null) {
+            var pc = new ParameterConfiguration(valueParameter.Name, valueParameter, discoverValidValues);
+            this.parameterConfigurations.Add(pc);
+          }
         }
       }
@@ -126 +131 @@
     }
 
-    public IEnumerable<string> GetOptimizedParameterNames() {
+    public virtual IEnumerable<string> GetOptimizedParameterNames() {
       var list = new List<string>();
-      this.CollectOptimizedParameterNames(list, "");
+      this.CollectOptimizedParameterNames(list, string.Empty);
       return list;
     }

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

@@ -20 +20 @@
     [Storable]
     protected bool isOptimizable;
-    public bool IsOptimizable {
+    public virtual bool IsOptimizable {
       get { return isOptimizable; }
       set {
@@ -36 +36 @@
       set {
         if (optimize != value) {
+          if (value == true && !this.IsOptimizable)
+            throw new NotSupportedException("This value is not optimizable.");
+
           optimize = value;
           OnOptimizeChanged();