Changeset 3861 for trunk/sources/HeuristicLab.Problems.ExternalEvaluation

Timestamp:

05/27/10 09:14:49 (15 years ago)

Author:

abeham

Message:

#866

• worked on external evaluation problem

Location:

trunk/sources/HeuristicLab.Problems.ExternalEvaluation/3.3

Files:

• Analyzers (added)
• Analyzers/BestExternalEvaluationSolutionAnalyzer.cs (added)
• ExternalEvaluationProblem.cs (modified) (7 diffs)
• ExternalEvaluationSolutionCreator.cs (modified) (1 diff)
• HeuristicLab.Problems.ExternalEvaluation-3.3.csproj (modified) (1 diff)
• Interfaces/IExternalEvaluationProblemEvaluator.cs (modified) (1 diff)

trunk/sources/HeuristicLab.Problems.ExternalEvaluation/3.3/ExternalEvaluationProblem.cs

@@ -20 +20 @@
 #endregion
 
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using HeuristicLab.Collections;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Parameters;
-using System.Drawing;
-using HeuristicLab.Optimization;
-using HeuristicLab.Data;
-using HeuristicLab.Operators;
 
 namespace HeuristicLab.Problems.ExternalEvaluation {
@@ -35 +38 @@
       get { return HeuristicLab.Common.Resources.VS2008ImageLibrary.Type; }
     }
+    public new ParameterCollection Parameters {
+      get { return base.Parameters; }
+    }
+    IKeyedItemCollection<string, IParameter> IParameterizedItem.Parameters {
+      get { return Parameters; }
+    }
 
     #region Parameters
@@ -49 +58 @@
       get { return MaximizationParameter; }
     }
-    public ValueParameter<IOperator> SolutionCreatorParameter {
-      get { return (ValueParameter<IOperator>)Parameters["SolutionCreator"]; }
+    public ValueParameter<ISolutionCreator> SolutionCreatorParameter {
+      get { return (ValueParameter<ISolutionCreator>)Parameters["SolutionCreator"]; }
     }
     IParameter IProblem.SolutionCreatorParameter {
@@ -66 +75 @@
     public OptionalValueParameter<IScope> BestKnownSolutionParameter {
       get { return (OptionalValueParameter<IScope>)Parameters["BestKnownSolution"]; }
+    }
+    public ValueParameter<ItemList<IOperator>> OperatorsParameter {
+      get { return (ValueParameter<ItemList<IOperator>>)Parameters["Operators"]; }
     }
     #endregion
@@ -74 +86 @@
       set { MaximizationParameter.Value = value; }
     }
-    public IOperator SolutionCreator {
+    public ISolutionCreator SolutionCreator {
       get { return SolutionCreatorParameter.Value; }
       set { SolutionCreatorParameter.Value = value; }
@@ -81 +93 @@
       get { return SolutionCreatorParameter.Value; }
     }
-    public ISingleObjectiveTestFunctionProblemEvaluator Evaluator {
+    public IExternalEvaluationProblemEvaluator Evaluator {
       get { return EvaluatorParameter.Value; }
       set { EvaluatorParameter.Value = value; }
@@ -95 +107 @@
       set { BestKnownQualityParameter.Value = value; }
     }
-    private List<IOperator> operators;
     public IEnumerable<IOperator> Operators {
-      get { return operators; }
-    }
-    private BestSingleObjectiveTestFunctionSolutionAnalyzer BestSingleObjectiveTestFunctionSolutionAnalyzer {
-      get { return operators.OfType<BestSingleObjectiveTestFunctionSolutionAnalyzer>().FirstOrDefault(); }
-    }
-    #endregion
-
+      get { return OperatorsParameter.Value; }
+    }
+    private BestExternalEvaluationSolutionAnalyzer BestExternalEvaluationSolutionAnalyzer {
+      get { return OperatorsParameter.Value.OfType<BestExternalEvaluationSolutionAnalyzer>().FirstOrDefault(); }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected ExternalEvaluationProblem(bool deserializing) : base(deserializing) { }
     public ExternalEvaluationProblem()
       : base() {
       ExternalEvaluator evaluator = new ExternalEvaluator();
-      EmptyOperator solutionCreator = new EmptyOperator();
+      ExternalEvaluationSolutionCreator solutionCreator = new ExternalEvaluationSolutionCreator();
 
       Parameters.Add(new ValueParameter<IExternalEvaluationDriver>("Driver", "The communication driver that is used to exchange data with the external process."));
       Parameters.Add(new ValueParameter<IExternalEvaluationProblemEvaluator>("Evaluator", "The evaluator that collects the values to exchange.", evaluator));
       Parameters.Add(new ValueParameter<IOperator>("SolutionCreator", "An operator to create the solution components.", solutionCreator));
-    }
+      Parameters.Add(new ValueParameter<BoolValue>("Maximization", "Set to false as most test functions are minimization problems.", new BoolValue(false)));
+      Parameters.Add(new OptionalValueParameter<DoubleValue>("BestKnownQuality", "The quality of the best known solution of this problem."));
+      Parameters.Add(new OptionalValueParameter<IScope>("BestKnownSolution", "The best known solution for this external evaluation problem."));
+      Parameters.Add(new ValueParameter<ItemList<IOperator>>("Operators", "The operators that are passed to the algorithm.", new ItemList<IOperator>()));
+
+      InitializeOperators();
+      AttachEventHandlers();
+    }
+
+    #region Events
+    public event EventHandler SolutionCreatorChanged;
+    private void OnSolutionCreatorChanged() {
+      EventHandler handler = SolutionCreatorChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler EvaluatorChanged;
+    private void OnEvaluatorChanged() {
+      EventHandler handler = EvaluatorChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler OperatorsChanged;
+    private void OnOperatorsChanged() {
+      EventHandler handler = OperatorsChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler Reset;
+    private void OnReset() {
+      EventHandler handler = Reset;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    private void SolutionCreatorParameter_ValueChanged(object sender, EventArgs e) {
+      OnSolutionCreatorChanged();
+    }
+    private void EvaluatorParameter_ValueChanged(object sender, EventArgs e) {
+      OnEvaluatorChanged();
+    }
+    private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
+      // TODO: Following code is not yet approved behavior, but it's the best effort I can make here regarding wiring
+      string qualityName = Evaluator.QualityParameter.ActualName;
+      foreach (IOperator op in OperatorsParameter.Value) {
+        foreach (ILookupParameter<DoubleValue> param in op.Parameters.OfType<ILookupParameter<DoubleValue>>()) {
+          if (param.Name.Equals("Quality")) param.ActualName = qualityName;
+        }
+        foreach (IScopeTreeLookupParameter<DoubleValue> param in op.Parameters.OfType<IScopeTreeLookupParameter<DoubleValue>>()) {
+          if (param.Name.Equals("Quality")) param.ActualName = qualityName;
+        }
+      }
+    }
+    private void OperatorsParameter_ValueChanged(object sender, EventArgs e) {
+      OnOperatorsChanged();
+    }
+    private void OperatorsParameter_Value_ItemsAdded(object sender, EventArgs e) {
+      OnOperatorsChanged();
+    }
+    private void OperatorsParameter_Value_ItemsRemoved(object sender, EventArgs e) {
+      OnOperatorsChanged();
+    }
+    private void OperatorsParameter_Value_CollectionReset(object sender, EventArgs e) {
+      OnOperatorsChanged();
+    }
+    #endregion
+
+    #region Helpers
+    private void InitializeOperators() {
+      ItemList<IOperator> operators = OperatorsParameter.Value;
+      operators.Add(new BestExternalEvaluationSolutionAnalyzer());
+      ParameterizeAnalyzers();
+    }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AttachEventHandlers() {
+      SolutionCreatorParameter.ValueChanged += new EventHandler(SolutionCreatorParameter_ValueChanged);
+      EvaluatorParameter.ValueChanged += new EventHandler(EvaluatorParameter_ValueChanged);
+      Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
+      OperatorsParameter.ValueChanged += new System.EventHandler(OperatorsParameter_ValueChanged);
+      OperatorsParameter.Value.ItemsAdded += new CollectionItemsChangedEventHandler<IndexedItem<IOperator>>(OperatorsParameter_Value_ItemsAdded);
+      OperatorsParameter.Value.ItemsRemoved += new CollectionItemsChangedEventHandler<IndexedItem<IOperator>>(OperatorsParameter_Value_ItemsRemoved);
+      OperatorsParameter.Value.CollectionReset += new CollectionItemsChangedEventHandler<IndexedItem<IOperator>>(OperatorsParameter_Value_CollectionReset);
+    }
+    private void ParameterizeAnalyzers() {
+      BestExternalEvaluationSolutionAnalyzer.ResultsParameter.ActualName = "Results";
+      BestExternalEvaluationSolutionAnalyzer.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
+      BestExternalEvaluationSolutionAnalyzer.BestKnownQualityParameter.ActualName = BestKnownQualityParameter.Name;
+      BestExternalEvaluationSolutionAnalyzer.BestKnownSolutionParameter.ActualName = BestKnownSolutionParameter.Name;
+      BestExternalEvaluationSolutionAnalyzer.MaximizationParameter.ActualName = MaximizationParameter.Name;
+    }
+    private void ParameterizeEvaluator() {
+      Evaluator.DriverParameter.ActualName = DriverParameter.Name;
+    }
+    #endregion
   }
 }

trunk/sources/HeuristicLab.Problems.ExternalEvaluation/3.3/ExternalEvaluationSolutionCreator.cs

@@ -33 +33 @@
   [StorableClass]
   public class ExternalEvaluationSolutionCreator : CheckedMultiOperator<IOperator>, ISolutionCreator {
+    public override IOperation Apply() {
+      OperationCollection result = new OperationCollection();
+      foreach (IOperator op in Operators.CheckedItems.OrderBy(x => x.Index).Select(x => x.Value)) {
+        result.Add(ExecutionContext.CreateOperation(op));
+      }
+      result.Add(base.Apply());
+      return result;
+    }
   }
 }

trunk/sources/HeuristicLab.Problems.ExternalEvaluation/3.3/HeuristicLab.Problems.ExternalEvaluation-3.3.csproj

@@ -79 +79 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Analyzers\BestExternalEvaluationSolutionAnalyzer.cs" />
     <Compile Include="Drivers\ExternalEvaluationDriver.cs" />
     <Compile Include="Drivers\ExternalEvaluationProcessDriver.cs" />

trunk/sources/HeuristicLab.Problems.ExternalEvaluation/3.3/Interfaces/IExternalEvaluationProblemEvaluator.cs

@@ -25 +25 @@
 using System.Text;
 using HeuristicLab.Optimization;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
 
 namespace HeuristicLab.Problems.ExternalEvaluation {
   public interface IExternalEvaluationProblemEvaluator : ISingleObjectiveEvaluator {
+    IValueLookupParameter<IExternalEvaluationDriver> DriverParameter { get; }
   }
 }