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

Timestamp:

01/04/11 02:18:27 (14 years ago)

Author:

cneumuel

Message:

#1215

• lots of memory-consumption improvements
• validValues -> validTypes (this saves memory!)
• changed manipulators; modifications are less significant, out-of-bound-values are resampled instead of set to lower or upper bound
• changed the way a base-level algorithm gets executed -> introduced AlgorithmExecutor

Location:

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

Files:

• Crossovers/ParameterConfigurationCrossover.cs (modified) (2 diffs)
• ParameterConfigurationTree.cs (modified) (1 diff)
• ParameterConfigurations/ParameterConfiguration.cs (modified) (8 diffs)
• RangeConstraints/ConstrainedValue.cs (modified) (3 diffs)
• RangeConstraints/DoubleValueRange.cs (modified) (1 diff)
• RangeConstraints/IntValueRange.cs (modified) (1 diff)
• RangeConstraints/PercentValueRange.cs (modified) (2 diffs)
• ValueConfigurations/CheckedValueConfigurationCollection.cs (modified) (1 diff)
• ValueConfigurations/ValueConfiguration.cs (modified) (3 diffs)

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/Crossovers/ParameterConfigurationCrossover.cs

@@ -8 +8 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using System;
 
 namespace HeuristicLab.Problems.MetaOptimization {
@@ -57 +58 @@
       ParameterConfigurationTree child2 = (ParameterConfigurationTree)ParentsParameter.ActualValue[1];
 
-      //child1.Cross(child2, RandomParameter.ActualValue);
-      //this.ChildParameter.ActualValue = child1;
-
       child1.Cross(RandomParameter.ActualValue, child2, Cross, this);
       this.ChildParameter.ActualValue = child1;

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

@@ -177 +177 @@
 
     public override void Parameterize(IParameterizedItem item) {
+      this.parameters.Clear();
       base.Parameterize(item);
-      this.parameters.Clear();
       ((IAlgorithm)item).CollectParameterValues(this.Parameters);
     }

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

@@ -10 +10 @@
 using HeuristicLab.PluginInfrastructure;
 using System.Text;
+using System.Reflection;
 
 namespace HeuristicLab.Problems.MetaOptimization {
   [StorableClass]
   public class ParameterConfiguration : Item, IParameterConfiguration, IStorableContent {
-    public bool IsOptimizable { 
-      get { return true; } 
+    public bool IsOptimizable {
+      get { return true; }
     }
 
@@ -58 +59 @@
 
     [Storable]
-    protected IItemSet<IItem> validValues;
-    public IItemSet<IItem> ValidValues {
-      get { return validValues; }
+    protected Type[] validTypes;
+    public Type[] ValidTypes {
+      get { return validTypes; }
       protected set {
-        if (this.validValues != value) {
-          this.validValues = value;
+        if (this.validTypes != value) {
+          this.validTypes = value;
         }
       }
@@ -124 +125 @@
       this.parameterDataType = valueParameter.GetType();
       this.valueDataType = valueParameter.DataType;
-      this.validValues = GetValidValues(valueParameter);
+      this.validTypes = GetValidTypes(valueParameter).ToArray();
       this.IsNullable = valueParameter.ItemName.StartsWith("Optional");
       if (IsNullable) {
-        validValues.Add(new NullValue());
-      }
-      this.ValueConfigurations = new CheckedValueConfigurationCollection(this.validValues);
-      this.ActualValue = new ConstrainedValue(valueParameter.Value, valueParameter.DataType, this.ValidValues, this.IsNullable);
+        validTypes = new List<Type>(validTypes) { typeof(NullValue) }.ToArray();
+      }
+      this.ValueConfigurations = new CheckedValueConfigurationCollection(this.validTypes);
+      this.ActualValue = new ConstrainedValue(valueParameter.Value != null ? (IItem)valueParameter.Value.Clone() : null, valueParameter.DataType, this.ValidTypes, this.IsNullable);
       if (Optimize) {
         PopulateValueConfigurations();
@@ -139 +140 @@
     [StorableConstructor]
     protected ParameterConfiguration(bool deserializing) { }
-    protected ParameterConfiguration(ParameterConfiguration original, Cloner cloner) : base(original, cloner) {
+    protected ParameterConfiguration(ParameterConfiguration original, Cloner cloner)
+      : base(original, cloner) {
       this.parameterName = original.ParameterName;
       this.parameterDataType = original.parameterDataType;
       this.valueDataType = original.ValueDataType;
-      this.validValues = cloner.Clone(original.ValidValues);
+      this.validTypes = original.validTypes.ToArray();
       this.valueConfigurations = cloner.Clone(original.ValueConfigurations);
       this.ActualValue = cloner.Clone(original.ActualValue);
@@ -180 +182 @@
 
     private void PopulateValueConfigurations() {
-      foreach (IItem validValue in this.validValues) {
-        if (validValue is NullValue) {
+      foreach (Type t in this.validTypes) {
+        if (t == typeof(NullValue)) {
           this.ValueConfigurations.Add(new NullValueConfiguration());
         } else {
           IItem val;
-          if (ActualValue.Value != null && ActualValue.ValueDataType == validValue.GetType()) {
+          if (ActualValue.Value != null && ActualValue.ValueDataType == t) {
             val = ActualValue.Value; // use existing value for that type (if available)
           } else {
-            val = validValue;
+            val = (IItem)Activator.CreateInstance(t);
           }
           this.ValueConfigurations.Add(new ValueConfiguration(val, val.GetType()), true);
@@ -195 +197 @@
     }
 
-    private IItemSet<IItem> GetValidValues(IValueParameter parameter) {
-      if (IsSubclassOfRawGeneric(typeof(OptionalConstrainedValueParameter<>), parameter.GetType())) {
-        var x = (IEnumerable)parameter.GetType().GetProperty("ValidValues").GetValue(parameter, new object[] { });
-        return new ItemSet<IItem>(x.Cast<IItem>());
-      } else {
-        return new ItemSet<IItem>(ApplicationManager.Manager.GetInstances(valueDataType).Select(x => (IItem)x).OrderBy(x => x.ItemName));
-      }
+    private IEnumerable<Type> GetValidTypes(IValueParameter parameter) {
+      //if (IsSubclassOfRawGeneric(typeof(OptionalConstrainedValueParameter<>), parameter.GetType())) {
+      //  var x = (IEnumerable)parameter.GetType().GetProperty("ValidValues").GetValue(parameter, new object[] { });
+      //  return new ItemSet<IItem>(x.Cast<IItem>());
+      //} else {
+      //  return new ItemSet<IItem>(ApplicationManager.Manager.GetInstances(valueDataType).Select(x => (IItem)x).OrderBy(x => x.ItemName));
+      //}
+      return ApplicationManager.Manager.GetTypes(valueDataType, true);
     }
 
@@ -278 +281 @@
       if (handler != null) handler(sender, e);
     }
-    
+
     public virtual event EventHandler IsOptimizableChanged;
     private void OnIsOptimizableChanged() {
@@ -333 +336 @@
         }
       }
-      parameter.Value = this.ActualValue.Value;
+      var clonedValue = this.ActualValue.Value != null ? (IItem)this.ActualValue.Value.Clone() : null;
+      AdaptValidValues(parameter, clonedValue);
+      parameter.Value = clonedValue;
+    }
+
+    /// <summary>
+    /// Adds value to the ValidValues of the parameter if they don't contain the value
+    /// </summary>
+    private void AdaptValidValues(IValueParameter parameter, IItem value) {
+      // this requires some tricky reflection, because the type is unknown at runtime so parameter.ValidValues cannot be casted to Collection<?>
+      if (IsSubclassOfRawGeneric(typeof(OptionalConstrainedValueParameter<>), parameter.GetType())) {
+        var validValues = parameter.GetType().GetProperty("ValidValues").GetValue(parameter, new object[] { });
+        Type validValuesType = validValues.GetType();
+
+        var containsMethod = validValuesType.GetMethod("Contains");
+        if (!(bool)containsMethod.Invoke(validValues, new object[] { value })) {
+          var addMethod = validValuesType.GetMethod("Add");
+          addMethod.Invoke(validValues, new object[] { value });
+        }
+      }
     }
 

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/RangeConstraints/ConstrainedValue.cs

@@ -33 +33 @@
 
     [Storable]
-    protected IItemSet<IItem> validValues;
-    public IItemSet<IItem> ValidValues {
-      get { return validValues; }
+    protected Type[] validTypes;
+    public Type[] ValidTypes {
+      get { return validTypes; }
       protected set {
-        if (this.validValues != value) {
-          this.validValues = value;
+        if (this.validTypes != value) {
+          this.validTypes = value;
         }
       }
@@ -65 +65 @@
     [StorableConstructor]
     protected ConstrainedValue(bool deserializing) : base(deserializing) { }
-    public ConstrainedValue(IItem value, Type valueDataType, IItemSet<IItem> validValues, bool isNullable) {
+    public ConstrainedValue(IItem value, Type valueDataType, Type[] validTypes, bool isNullable) {
       this.Value = value;
       this.ValueDataType = valueDataType;
-      this.ValidValues = validValues;
+      this.ValidTypes = validTypes;
       this.isNullable = isNullable;
     }
@@ -74 +74 @@
       this.valueDataType = original.valueDataType;
       this.Value = cloner.Clone(original.value);
-      this.ValidValues = cloner.Clone(original.ValidValues);
+      if(original.ValidTypes != null) this.ValidTypes = original.ValidTypes.ToArray();
       this.isNullable = original.isNullable;
     }

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/RangeConstraints/DoubleValueRange.cs

@@ -25 +25 @@
       do {
         val = Math.Round((random.NextDouble() * (UpperBound.Value - LowerBound.Value) + LowerBound.Value) / StepSize.Value, 0) * StepSize.Value;
-      } while (val < LowerBound.Value || val > UpperBound.Value);
+      } while (!IsInRange(val));
       return new DoubleValue(val);
     }
 
-    public void Fix(DoubleValue value) {
-      // apply stepsize
+    public void ApplyStepSize(DoubleValue value) {
       value.Value = ((int)Math.Round(value.Value / this.StepSize.Value, 0)) * this.StepSize.Value;
+    }
 
-      // repair bounds
-      if (value.Value > this.UpperBound.Value) value.Value = this.UpperBound.Value;
-      if (value.Value < this.LowerBound.Value) value.Value = this.LowerBound.Value;
+    public bool IsInRange(double value) {
+      return value <= this.UpperBound.Value && value >= this.LowerBound.Value;
     }
 
     public override IEnumerable<DoubleValue> GetCombinations() {
       var solutions = new List<DoubleValue>();
-      double value = ((int)Math.Round(LowerBound.Value / StepSize.Value, 0)) * StepSize.Value;
-      if (value < LowerBound.Value) value += StepSize.Value;
+      double value = LowerBound.Value;
 
       while (value <= UpperBound.Value) {

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/RangeConstraints/IntValueRange.cs

@@ -25 +25 @@
       do {
         val = random.Next(LowerBound.Value / StepSize.Value, UpperBound.Value / StepSize.Value + 1) * StepSize.Value;
-      } while (val < LowerBound.Value || val > UpperBound.Value);
+      } while (!IsInRange(val));
       return new IntValue(val);
     }
 
-    public void Fix(IntValue value) {
-      // apply stepsize
+    public void ApplyStepSize(IntValue value) {
       value.Value = ((int)Math.Round(value.Value / (double)this.StepSize.Value, 0)) * this.StepSize.Value;
+    }
 
-      // repair bounds
-      if (value.Value > this.UpperBound.Value) value.Value = this.UpperBound.Value;
-      if (value.Value < this.LowerBound.Value) value.Value = this.LowerBound.Value;
+    public bool IsInRange(int value) {
+      return value <= this.UpperBound.Value && value >= this.LowerBound.Value;
     }
 
     public override IEnumerable<IntValue> GetCombinations() {
       var solutions = new List<IntValue>();
-      int value = (this.LowerBound.Value / StepSize.Value) * StepSize.Value;
-      if (value < this.LowerBound.Value) value += StepSize.Value;
+      int value = this.LowerBound.Value;
 
       while (value <= this.UpperBound.Value) {

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/RangeConstraints/PercentValueRange.cs

@@ -25 +25 @@
       do {
         val = Math.Round((random.NextDouble() * (UpperBound.Value - LowerBound.Value) + LowerBound.Value) / StepSize.Value, 0) * StepSize.Value;
-      } while (val < LowerBound.Value || val > UpperBound.Value);
+      } while (!IsInRange(val));
       return new PercentValue(val);
     }
@@ -33 +33 @@
     }
 
+    public void ApplyStepSize(PercentValue value) {
+      value.Value = ((int)Math.Round(value.Value / this.StepSize.Value, 0)) * this.StepSize.Value;
+    }
+
+    public bool IsInRange(double value) {
+      return value <= this.UpperBound.Value && value >= this.LowerBound.Value;
+    }
+
     public override IEnumerable<PercentValue> GetCombinations() {
       var solutions = new List<PercentValue>();
-      double value = ((int)Math.Round(LowerBound.Value / StepSize.Value, 0)) * StepSize.Value;
-      if (value < LowerBound.Value) value += StepSize.Value;
+      double value = LowerBound.Value;
 
       while (value <= UpperBound.Value) {

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

@@ -24 +24 @@
     }
 
-    public CheckedValueConfigurationCollection(IItemSet<IItem> validValues) {
-      this.validValues = validValues;
+    public CheckedValueConfigurationCollection(IEnumerable<Type> validTypes) {
+      this.validValues = new ItemSet<IItem>();
+      foreach (Type t in validTypes) {
+        this.validValues.Add((IItem)Activator.CreateInstance(t));
+      }
       RegisterEvents();
     }

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

@@ -60 +60 @@
       set {
         if (this.actualValue != value) {
-          RegisterActualValueEvents();
+          DeregisterActualValueEvents();
           ClearParameterConfigurations();
           this.actualValue = value;
@@ -66 +66 @@
           OnValueChanged();
           OnToStringChanged();
-          DeregisterActualValueEvents();
+          RegisterActualValueEvents();
         }
       }
@@ -87 +87 @@
     public ValueConfiguration(IItem value, Type valueDataType) {
       this.ParameterConfigurations = new ItemList<IParameterConfiguration>();
-      var validValues = new ItemSet<IItem>(ApplicationManager.Manager.GetInstances(valueDataType).Select(x => (IItem)x).OrderBy(x => x.ItemName));
-      this.ActualValue = new ConstrainedValue(value, valueDataType, validValues, false);
+      var validTypes = ApplicationManager.Manager.GetTypes(valueDataType).OrderBy(x => x.Name).ToArray();
+      this.ActualValue = new ConstrainedValue(value, valueDataType, validTypes, false);
       this.IsOptimizable = true;
       if (actualValue.ValueDataType == typeof(IntValue)) {