Changeset 5313 for branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3

Timestamp:

01/17/11 19:17:51 (14 years ago)

Author:

cneumuel

Message:

#1215

• changed AlgorithType and ProblemType to actually be types not objects. this eliminates redundant views for MetaOptimizationProblem
• import algorithm for MetaOptimizationProblem
• nicer dialog for combination creation
• fixed iconimage for ParameterConfigurations
• fixed ValidValues

Location:

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

Files:

• ConstrainedTypeValue.cs (added)
• Encoding/ParameterConfigurationTree.cs (modified) (5 diffs)
• Encoding/ParameterConfigurations/ParameterConfiguration.cs (modified) (6 diffs)
• Encoding/ValueConfigurations/CheckedValueConfigurationCollection.cs (modified) (1 diff)
• Evaluators/ParameterConfigurationEvaluator.cs (modified) (3 diffs)
• HeuristicLab.Problems.MetaOptimization-3.3.csproj (modified) (1 diff)
• MetaOptimizationProblem.cs (modified) (8 diffs)
• TypeValue.cs (added)

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

@@ -105 +105 @@
     }
 
+    [Storable]
+    protected string name;
+    public string Name {
+      get { return name; }
+      set { name = value; }
+    }
+
     #region constructors and cloning
     public ParameterConfigurationTree(EngineAlgorithm algorithm)
@@ -110 +117 @@
       this.Optimize = true; // root must always be optimized
       this.parameters = new Dictionary<string, IItem>();
-
+      this.Name = algorithm.ItemName;
       PopulateParameterConfigurations(algorithm);
     }
@@ -119 +126 @@
     protected ParameterConfigurationTree(ParameterConfigurationTree original, Cloner cloner)
       : base(original, cloner) {
+      this.name = original.name;
       this.bestQualities = cloner.Clone(original.BestQualities);
       this.averageQualities = cloner.Clone(original.averageQualities);
@@ -186 +194 @@
         if (createBatchRuns) {
           BatchRun batchRun = new BatchRun(string.Format("BatchRun: {0}", combination.ParameterInfoString));
-          batchRun.Algorithm = clonedAlg;
+          batchRun.Optimizer = clonedAlg;
           batchRun.Repetitions = repetitions;
           experiment.Optimizers.Add(batchRun);
@@ -218 +226 @@
       return allOptimizables[random.Next(allOptimizables.Count)];
     }
+
+    public override string ToString() {
+      return this.Name;
+    }
   }
 }

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

@@ -13 +13 @@
 using HeuristicLab.Optimization;
 using HeuristicLab.Collections;
+using System.Drawing;
 
 namespace HeuristicLab.Problems.MetaOptimization {
@@ -43 +44 @@
 
     [Storable]
+    private Image itemImage;
+    public virtual Image ItemImage {
+      get { return itemImage ?? base.ItemImage; }
+    }
+
+    [Storable]
     protected string parameterName;
     public string ParameterName {
@@ -133 +140 @@
       this.validTypes = GetValidTypes(valueParameter).ToArray();
       this.IsNullable = valueParameter.ItemName.StartsWith("Optional");
+      this.itemImage = valueParameter.ItemImage;
       if (IsNullable) {
         validTypes = new List<Type>(validTypes) { typeof(NullValue) }.ToArray();
       }
-      this.ValueConfigurations = new CheckedValueConfigurationList();
+      this.ValueConfigurations = new CheckedValueConfigurationList(this.validValues ?? CreateValidValues());
       this.ActualValue = new ConstrainedValue(
         valueParameter.Value != null ? (IItem)valueParameter.Value.Clone() : null, 
@@ -162 +170 @@
       this.actualValueConfigurationIndex = original.actualValueConfigurationIndex;
       this.isNullable = original.isNullable;
+      this.itemImage = original.itemImage;
       if (this.valueConfigurations != null) RegisterValueConfigurationEvents();
     }
@@ -246 +255 @@
     }
 
-    private ItemSet<IItem> CreateValidValues() {
+    private IItemSet<IItem> CreateValidValues() {
       var validValues = new ItemSet<IItem>();
       foreach (Type t in this.validTypes) {
@@ -295 +304 @@
     }
     public override string ItemDescription {
-      //get { return parameter != null ? parameter.Description : base.ItemDescription; }
       get { return base.ItemDescription; }
     }
-    public override System.Drawing.Image ItemImage {
-      //get { return parameter != null ? parameter.ItemImage : base.ItemImage; }
-      get { return base.ItemImage; }
-    }
     public override string ItemName {
-      //get { return parameter != null ?parameter.ItemName : base.ItemName; }
       get { return base.ItemName; }
     }

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

@@ -25 +25 @@
     }
 
-    public CheckedValueConfigurationList(ItemSet<IItem> validValues) {
+    public CheckedValueConfigurationList(IItemSet<IItem> validValues) {
       this.validValues = validValues;
       RegisterEvents();

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

@@ -27 +27 @@
       get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
     }
-    public ILookupParameter<EngineAlgorithm> AlgorithmParameter {
-      get { return (ILookupParameter<EngineAlgorithm>)Parameters[MetaOptimizationProblem.AlgorithmTypeParameterName]; }
+    public ILookupParameter<TypeValue> AlgorithmTypeParameter {
+      get { return (ILookupParameter<TypeValue>)Parameters[MetaOptimizationProblem.AlgorithmTypeParameterName]; }
     }
     public ILookupParameter<IItemList<ISingleObjectiveProblem>> ProblemsParameter {
@@ -57 +57 @@
       : base() {
       Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The evaluated quality of the ParameterVector."));
-      Parameters.Add(new LookupParameter<EngineAlgorithm>(MetaOptimizationProblem.AlgorithmTypeParameterName, "Missing description."));
+      Parameters.Add(new LookupParameter<TypeValue>(MetaOptimizationProblem.AlgorithmTypeParameterName, "Missing description."));
       Parameters.Add(new LookupParameter<IItemList<ISingleObjectiveProblem>>(MetaOptimizationProblem.ProblemsParameterName, "Missing description."));
       Parameters.Add(new LookupParameter<ParameterConfigurationTree>("ParameterConfigurationTree", "Missing description."));
@@ -77 +77 @@
     public override IOperation Apply() {
       ParameterConfigurationTree parameterConfiguration = ParameterConfigurationParameter.ActualValue;
-      EngineAlgorithm algorithm = (EngineAlgorithm)AlgorithmParameter.ActualValue;
+      EngineAlgorithm algorithm = (EngineAlgorithm)Activator.CreateInstance(AlgorithmTypeParameter.ActualValue.Value);
       IItemList<ISingleObjectiveProblem> problems = ProblemsParameter.ActualValue;
       ItemDictionary<StringValue, RunCollection> runsCache = ResultsParameter.ActualValue.ContainsKey("Runs") ? (ItemDictionary<StringValue, RunCollection>)ResultsParameter.ActualValue["Runs"].Value : null;

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

@@ -133 +133 @@
   <ItemGroup>
     <Compile Include="Analyzers\BestParameterConfigurationAnalyzer.cs" />
+    <Compile Include="ConstrainedTypeValue.cs" />
+    <Compile Include="TypeValue.cs" />
     <None Include="Properties\AssemblyInfo.cs.frame" />
     <None Include="HeuristicLabProblemsMetaOptimizationPlugin.cs.frame" />

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

@@ -40 +40 @@
     public const string ProblemTypeParameterName = "ProblemType";
     public const string ProblemsParameterName = "Problems";
-    public const string ParameterConfigurationTreeParameterName = "InitialParameterConfigurationTree";
+    public const string ParameterConfigurationTreeParameterName = "ParameterConfigurationTree";
     public const string RepetitionsParameterName = "Repetitions";
 
@@ -49 +49 @@
 
     #region Parameter Properties
-    public IValueParameter<EngineAlgorithm> AlgorithmTypeParameter {
-      get { return (ValueParameter<EngineAlgorithm>)Parameters[AlgorithmTypeParameterName]; }
-    }
-    public IValueParameter<ISingleObjectiveProblem> ProblemTypeParameter {
-      get { return (ValueParameter<ISingleObjectiveProblem>)Parameters[ProblemTypeParameterName]; }
+    public IValueParameter<ConstrainedTypeValue<EngineAlgorithm>> AlgorithmTypeParameter {
+      get { return (ValueParameter<ConstrainedTypeValue<EngineAlgorithm>>)Parameters[AlgorithmTypeParameterName]; }
+    }
+    public IValueParameter<ConstrainedTypeValue<ISingleObjectiveProblem>> ProblemTypeParameter {
+      get { return (ValueParameter<ConstrainedTypeValue<ISingleObjectiveProblem>>)Parameters[ProblemTypeParameterName]; }
     }
     public IValueParameter<ConstrainedItemList<ISingleObjectiveProblem>> ProblemsParameter {
@@ -76 +76 @@
     #region Properties
     public EngineAlgorithm Algorithm {
+      get { return CreateAlgorithm(AlgorithmType.Value, ProblemType.Value); }
+    }
+    public ConstrainedTypeValue<EngineAlgorithm> AlgorithmType {
       get { return AlgorithmTypeParameter.Value; }
       set { AlgorithmTypeParameter.Value = value; }
     }
-    public ISingleObjectiveProblem Problem {
+    public ConstrainedTypeValue<ISingleObjectiveProblem> ProblemType {
       get { return ProblemTypeParameter.Value; }
       set { ProblemTypeParameter.Value = value; }
@@ -108 +111 @@
     public MetaOptimizationProblem()
       : base() {
-      Parameters.Add(new ValueParameter<EngineAlgorithm>(AlgorithmTypeParameterName, "The algorithm which's parameters should be optimized.", new GeneticAlgorithm()));
-      Parameters.Add(new ValueParameter<ISingleObjectiveProblem>(ProblemTypeParameterName, "The problem type.", new SingleObjectiveTestFunctionProblem()));
+      Parameters.Add(new ValueParameter<ConstrainedTypeValue<EngineAlgorithm>>(AlgorithmTypeParameterName, "The algorithm which's parameters should be optimized.", new ConstrainedTypeValue<EngineAlgorithm>(typeof(GeneticAlgorithm))));
+      Parameters.Add(new ValueParameter<ConstrainedTypeValue<ISingleObjectiveProblem>>(ProblemTypeParameterName, "The problem type.", new ConstrainedTypeValue<ISingleObjectiveProblem>(typeof(SingleObjectiveTestFunctionProblem))));
       Parameters.Add(new ValueParameter<ConstrainedItemList<ISingleObjectiveProblem>>(ProblemsParameterName, "The problems that should be evaluated.", new ConstrainedItemList<ISingleObjectiveProblem>()));
       Parameters.Add(new ValueParameter<ParameterConfigurationTree>(ParameterConfigurationTreeParameterName, "Tree of algorithm parameters that should be optimized."));
@@ -134 +137 @@
       ParameterizeOperators();
 
-      Problems.Type = Problem.GetType();
-      Algorithm.Problem = Problem;
-      ParameterConfigurationTreeParameter.ActualValue = new ParameterConfigurationTree(Algorithm);
+      ProblemTypeParameter_ValueChanged(this, EventArgs.Empty);
     }
 
@@ -143 +144 @@
     private MetaOptimizationProblem(MetaOptimizationProblem original, Cloner cloner)
       : base(original, cloner) {
-      // todo
       this.RegisterParameterEvents();
     }
@@ -160 +160 @@
       Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
       AlgorithmTypeParameter.ValueChanged += new EventHandler(AlgorithmTypeParameter_ValueChanged);
+      AlgorithmType.ValueChanged += new EventHandler(AlgorithmType_ValueChanged);
       ProblemTypeParameter.ValueChanged += new EventHandler(ProblemTypeParameter_ValueChanged);
+      ProblemType.ValueChanged += new EventHandler(ProblemType_ValueChanged);
     }
 
@@ -215 +217 @@
       ParameterizeAnalyzer();
     }
-    void AlgorithmTypeParameter_ValueChanged(object sender, EventArgs e) {
-      Algorithm.Problem = Problem;
-      ParameterConfigurationTreeParameter.ActualValue = new ParameterConfigurationTree(Algorithm);
-    }
-    void ProblemTypeParameter_ValueChanged(object sender, EventArgs e) {
-      Problems.Type = Problem.GetType();
-      Algorithm.Problem = Problem;
-      ParameterConfigurationTreeParameter.ActualValue = new ParameterConfigurationTree(Algorithm);
-    }
-    #endregion
+    private void AlgorithmTypeParameter_ValueChanged(object sender, EventArgs e) {
+      AlgorithmType_ValueChanged(sender, e);
+    }
+
+    private void AlgorithmType_ValueChanged(object sender, EventArgs e) {
+      ParameterConfigurationTreeParameter.ActualValue = new ParameterConfigurationTree(CreateAlgorithm(AlgorithmType.Value, ProblemType.Value));
+    }
+
+    private void ProblemTypeParameter_ValueChanged(object sender, EventArgs e) {
+      ProblemType_ValueChanged(sender, e);
+    }
+
+    private void ProblemType_ValueChanged(object sender, EventArgs e) {
+      Problems.Clear();
+      Problems.Type = ProblemType.Value;
+      ParameterConfigurationTreeParameter.ActualValue = new ParameterConfigurationTree(CreateAlgorithm(AlgorithmType.Value, ProblemType.Value));
+    }
+    #endregion
+
+    private EngineAlgorithm CreateAlgorithm(Type algorithmType, Type problemType) {
+      EngineAlgorithm algorithm = (EngineAlgorithm)Activator.CreateInstance(algorithmType);
+      algorithm.Problem = (IProblem)Activator.CreateInstance(problemType);
+      return algorithm;
+    }
+
+    public void ImportAlgorithm(EngineAlgorithm algorithm) {
+      AlgorithmType.Value = algorithm.GetType();
+      if(algorithm.Problem != null) ProblemType.Value = algorithm.Problem.GetType();
+      ParameterConfigurationTreeParameter.ActualValue = new ParameterConfigurationTree(algorithm);
+      if(algorithm.Problem != null) Problems.Add((ISingleObjectiveProblem)algorithm.Problem);
+    }
   }
 }