Free cookie consent management tool by TermsFeed Policy Generator

source: branches/PersistenceSpeedUp/HeuristicLab.Problems.ExternalEvaluation/3.3/ExternalEvaluationProblem.cs @ 6228

Last change on this file since 6228 was 6228, checked in by epitzer, 13 years ago

check hooks by method name only (#1530)

File size: 12.2 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4 *
5 * This file is part of HeuristicLab.
6 *
7 * HeuristicLab is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * HeuristicLab is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
19 */
20#endregion
21
22using System;
23using System.Collections.Generic;
24using System.Drawing;
25using System.Linq;
26using HeuristicLab.Analysis;
27using HeuristicLab.Collections;
28using HeuristicLab.Common;
29using HeuristicLab.Core;
30using HeuristicLab.Data;
31using HeuristicLab.Optimization;
32using HeuristicLab.Optimization.Operators;
33using HeuristicLab.Parameters;
34using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
35
36namespace HeuristicLab.Problems.ExternalEvaluation {
37  [Item("External Evaluation Problem", "A problem that is evaluated in a different process.")]
38  [Creatable("Problems")]
39  [StorableClass]
40  public sealed class ExternalEvaluationProblem : ParameterizedNamedItem, ISingleObjectiveHeuristicOptimizationProblem, IStorableContent {
41    public string Filename { get; set; }
42
43    public override Image ItemImage {
44      get { return HeuristicLab.Common.Resources.VSImageLibrary.Type; }
45    }
46
47    public new ParameterCollection Parameters {
48      get { return base.Parameters; }
49    }
50    IKeyedItemCollection<string, IParameter> IParameterizedItem.Parameters {
51      get { return Parameters; }
52    }
53
54    #region Parameters
55    public IValueParameter<CheckedItemCollection<IEvaluationServiceClient>> ClientsParameter {
56      get { return (IValueParameter<CheckedItemCollection<IEvaluationServiceClient>>)Parameters["Clients"]; }
57    }
58    public IValueParameter<IExternalEvaluationProblemEvaluator> EvaluatorParameter {
59      get { return (IValueParameter<IExternalEvaluationProblemEvaluator>)Parameters["Evaluator"]; }
60    }
61    public ValueParameter<BoolValue> MaximizationParameter {
62      get { return (ValueParameter<BoolValue>)Parameters["Maximization"]; }
63    }
64    IParameter ISingleObjectiveHeuristicOptimizationProblem.MaximizationParameter {
65      get { return MaximizationParameter; }
66    }
67    public ValueParameter<ISolutionCreator> SolutionCreatorParameter {
68      get { return (ValueParameter<ISolutionCreator>)Parameters["SolutionCreator"]; }
69    }
70    IParameter IHeuristicOptimizationProblem.SolutionCreatorParameter {
71      get { return SolutionCreatorParameter; }
72    }
73    IParameter IHeuristicOptimizationProblem.EvaluatorParameter {
74      get { return EvaluatorParameter; }
75    }
76    public OptionalValueParameter<DoubleValue> BestKnownQualityParameter {
77      get { return (OptionalValueParameter<DoubleValue>)Parameters["BestKnownQuality"]; }
78    }
79    IParameter ISingleObjectiveHeuristicOptimizationProblem.BestKnownQualityParameter {
80      get { return BestKnownQualityParameter; }
81    }
82    public OptionalValueParameter<IScope> BestKnownSolutionParameter {
83      get { return (OptionalValueParameter<IScope>)Parameters["BestKnownSolution"]; }
84    }
85    public ValueParameter<ItemList<IOperator>> OperatorsParameter {
86      get { return (ValueParameter<ItemList<IOperator>>)Parameters["Operators"]; }
87    }
88    public OptionalValueParameter<EvaluationCache> CacheParameter {
89      get { return (OptionalValueParameter<EvaluationCache>)Parameters["Cache"]; }
90    }
91    #endregion
92
93    #region Properties
94    public BoolValue Maximization {
95      get { return MaximizationParameter.Value; }
96      set { MaximizationParameter.Value = value; }
97    }
98    public ISolutionCreator SolutionCreator {
99      get { return SolutionCreatorParameter.Value; }
100      set { SolutionCreatorParameter.Value = value; }
101    }
102    ISolutionCreator IHeuristicOptimizationProblem.SolutionCreator {
103      get { return SolutionCreatorParameter.Value; }
104    }
105    public IExternalEvaluationProblemEvaluator Evaluator {
106      get { return EvaluatorParameter.Value; }
107      set { EvaluatorParameter.Value = value; }
108    }
109    ISingleObjectiveEvaluator ISingleObjectiveHeuristicOptimizationProblem.Evaluator {
110      get { return EvaluatorParameter.Value; }
111    }
112    IEvaluator IHeuristicOptimizationProblem.Evaluator {
113      get { return EvaluatorParameter.Value; }
114    }
115    public DoubleValue BestKnownQuality {
116      get { return BestKnownQualityParameter.Value; }
117      set { BestKnownQualityParameter.Value = value; }
118    }
119    public IEnumerable<IOperator> Operators {
120      get { return OperatorsParameter.Value; }
121    }
122    private BestScopeSolutionAnalyzer BestScopeSolutionAnalyzer {
123      get { return OperatorsParameter.Value.OfType<BestScopeSolutionAnalyzer>().FirstOrDefault(); }
124    }
125    #endregion
126
127    [StorableConstructor]
128    private ExternalEvaluationProblem(bool deserializing) : base(deserializing) { }
129
130    private ExternalEvaluationProblem(ExternalEvaluationProblem original, Cloner cloner)
131      : base(original, cloner) {
132      AttachEventHandlers();
133    }
134    public override IDeepCloneable Clone(Cloner cloner) {
135      return new ExternalEvaluationProblem(this, cloner);
136    }
137    public ExternalEvaluationProblem()
138      : base() {
139      ExternalEvaluator evaluator = new ExternalEvaluator();
140      UserDefinedSolutionCreator solutionCreator = new UserDefinedSolutionCreator();
141
142      Parameters.Add(new ValueParameter<CheckedItemCollection<IEvaluationServiceClient>>("Clients", "The clients that are used to communicate with the external application.", new CheckedItemCollection<IEvaluationServiceClient>() { new EvaluationServiceClient() }));
143      Parameters.Add(new ValueParameter<IExternalEvaluationProblemEvaluator>("Evaluator", "The evaluator that collects the values to exchange.", evaluator));
144      Parameters.Add(new ValueParameter<ISolutionCreator>("SolutionCreator", "An operator to create the solution components.", solutionCreator));
145      Parameters.Add(new ValueParameter<BoolValue>("Maximization", "Set to false as most test functions are minimization problems.", new BoolValue(false)));
146      Parameters.Add(new OptionalValueParameter<DoubleValue>("BestKnownQuality", "The quality of the best known solution of this problem."));
147      Parameters.Add(new OptionalValueParameter<IScope>("BestKnownSolution", "The best known solution for this external evaluation problem."));
148      Parameters.Add(new ValueParameter<ItemList<IOperator>>("Operators", "The operators that are passed to the algorithm.", new ItemList<IOperator>()));
149      Parameters.Add(new OptionalValueParameter<EvaluationCache>("Cache", "Cache of previously evaluated solutions."));
150
151      InitializeOperators();
152      AttachEventHandlers();
153    }
154    [StorableHook(HookType.AfterDeserialization)]
155    private void AfterDeserialization() {
156      AttachEventHandlers();
157      // BackwardsCompatibility3.3
158      #region Backwards compatible code, remove with 3.4
159      if (!Parameters.ContainsKey("Clients")) {
160        Parameters.Add(new ValueParameter<CheckedItemCollection<IEvaluationServiceClient>>("Clients", "The clients that are used to communicate with the external application.", new CheckedItemCollection<IEvaluationServiceClient>() { new EvaluationServiceClient() }));
161        if (Parameters.ContainsKey("Client")) {
162          var client = ((IValueParameter<IEvaluationServiceClient>)Parameters["Client"]).Value;
163          if (client != null)
164            ClientsParameter.Value = new CheckedItemCollection<IEvaluationServiceClient>() { client };
165          Parameters.Remove("Client");
166        }
167      }
168      #endregion
169    }
170
171    #region Events
172    public event EventHandler SolutionCreatorChanged;
173    private void OnSolutionCreatorChanged() {
174      EventHandler handler = SolutionCreatorChanged;
175      if (handler != null) handler(this, EventArgs.Empty);
176    }
177    public event EventHandler EvaluatorChanged;
178    private void OnEvaluatorChanged() {
179      EventHandler handler = EvaluatorChanged;
180      if (handler != null) handler(this, EventArgs.Empty);
181    }
182    public event EventHandler OperatorsChanged;
183    private void OnOperatorsChanged() {
184      EventHandler handler = OperatorsChanged;
185      if (handler != null) handler(this, EventArgs.Empty);
186    }
187    public event EventHandler Reset;
188    private void OnReset() {
189      EventHandler handler = Reset;
190      if (handler != null) handler(this, EventArgs.Empty);
191    }
192
193    private void SolutionCreatorParameter_ValueChanged(object sender, EventArgs e) {
194      OnSolutionCreatorChanged();
195    }
196    private void EvaluatorParameter_ValueChanged(object sender, EventArgs e) {
197      Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
198      ParameterizeOperators();
199      OnEvaluatorChanged();
200    }
201    private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
202      ParameterizeOperators();
203    }
204    private void OperatorsParameter_ValueChanged(object sender, EventArgs e) {
205      OnOperatorsChanged();
206    }
207    private void OperatorsParameter_Value_ItemsAdded(object sender, EventArgs e) {
208      OnOperatorsChanged();
209    }
210    private void OperatorsParameter_Value_ItemsRemoved(object sender, EventArgs e) {
211      OnOperatorsChanged();
212    }
213    private void OperatorsParameter_Value_CollectionReset(object sender, EventArgs e) {
214      OnOperatorsChanged();
215    }
216    #endregion
217
218    #region Helper
219    private void AttachEventHandlers() {
220      SolutionCreatorParameter.ValueChanged += new EventHandler(SolutionCreatorParameter_ValueChanged);
221      EvaluatorParameter.ValueChanged += new EventHandler(EvaluatorParameter_ValueChanged);
222      Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
223      OperatorsParameter.ValueChanged += new EventHandler(OperatorsParameter_ValueChanged);
224      OperatorsParameter.Value.ItemsAdded += new CollectionItemsChangedEventHandler<IndexedItem<IOperator>>(OperatorsParameter_Value_ItemsAdded);
225      OperatorsParameter.Value.ItemsRemoved += new CollectionItemsChangedEventHandler<IndexedItem<IOperator>>(OperatorsParameter_Value_ItemsRemoved);
226      OperatorsParameter.Value.CollectionReset += new CollectionItemsChangedEventHandler<IndexedItem<IOperator>>(OperatorsParameter_Value_CollectionReset);
227    }
228    private void InitializeOperators() {
229      ItemList<IOperator> operators = OperatorsParameter.Value;
230      operators.Add(new BestScopeSolutionAnalyzer());
231      ParameterizeAnalyzers();
232    }
233    private void ParameterizeAnalyzers() {
234      BestScopeSolutionAnalyzer.ResultsParameter.ActualName = "Results";
235      BestScopeSolutionAnalyzer.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
236      BestScopeSolutionAnalyzer.BestKnownQualityParameter.ActualName = BestKnownQualityParameter.Name;
237      BestScopeSolutionAnalyzer.BestKnownSolutionParameter.ActualName = BestKnownSolutionParameter.Name;
238      BestScopeSolutionAnalyzer.MaximizationParameter.ActualName = MaximizationParameter.Name;
239    }
240    private void ParameterizeEvaluator() {
241      Evaluator.ClientsParameter.ActualName = ClientsParameter.Name;
242    }
243    private void ParameterizeOperators() {
244      // This is a best effort approach to wiring
245      string qualityName = Evaluator.QualityParameter.ActualName;
246      foreach (IOperator op in OperatorsParameter.Value) {
247        foreach (ILookupParameter<DoubleValue> param in op.Parameters.OfType<ILookupParameter<DoubleValue>>()) {
248          if (param.Name.Equals("Quality")) param.ActualName = qualityName;
249        }
250        foreach (IScopeTreeLookupParameter<DoubleValue> param in op.Parameters.OfType<IScopeTreeLookupParameter<DoubleValue>>()) {
251          if (param.Name.Equals("Quality")) param.ActualName = qualityName;
252        }
253      }
254    }
255    #endregion
256  }
257}
Note: See TracBrowser for help on using the repository browser.