source: branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/SingleObjectiveProblem.cs @ 17522

Last change on this file since 17522 was 17522, checked in by abeham, 3 months ago

#2521 WIP refactoring:

  1. Introduce nicer type IResultDefinition for API users to avoid complex IParameter interface (hide ActualValue)
  2. Change result parameter to contexts (need quality and solution): only implemented for BinaryVectorProblem
File size: 10.2 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 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.Linq;
25using System.Threading;
26using HEAL.Attic;
27using HeuristicLab.Common;
28using HeuristicLab.Core;
29using HeuristicLab.Data;
30using HeuristicLab.Parameters;
31
32namespace HeuristicLab.Optimization {
33  [StorableType("2697320D-0259-44BB-BD71-7EE1B10F664C")]
34  public abstract class SingleObjectiveProblem<TEncoding, TEncodedSolution> :
35    Problem<TEncoding, TEncodedSolution, SingleObjectiveEvaluator<TEncodedSolution>>,
36    ISingleObjectiveProblem<TEncoding, TEncodedSolution>,
37    ISingleObjectiveProblemDefinition<TEncoding, TEncodedSolution>
38    where TEncoding : class, IEncoding<TEncodedSolution>
39    where TEncodedSolution : class, IEncodedSolution {
40
41    [Storable] protected IValueParameter<DoubleValue> BestKnownQualityParameter { get; private set; }
42    [Storable] protected IValueParameter<BoolValue> MaximizationParameter { get; private set; }
43
44    public double BestKnownQuality {
45      get {
46        if (BestKnownQualityParameter.Value == null) return double.NaN;
47        return BestKnownQualityParameter.Value.Value;
48      }
49      set {
50        if (double.IsNaN(value)) {
51          BestKnownQualityParameter.Value = null;
52          return;
53        }
54        if (BestKnownQualityParameter.Value == null) BestKnownQualityParameter.Value = new DoubleValue(value);
55        else BestKnownQualityParameter.Value.Value = value;
56      }
57    }
58
59    public bool Maximization {
60      get { return MaximizationParameter.Value.Value; }
61      protected set {
62        if (Maximization == value) return;
63        MaximizationParameter.ForceValue(new BoolValue(value, @readonly: true));
64        OnMaximizationChanged();
65      }
66    }
67
68    [StorableConstructor]
69    protected SingleObjectiveProblem(StorableConstructorFlag _) : base(_) { }
70
71    protected SingleObjectiveProblem(SingleObjectiveProblem<TEncoding, TEncodedSolution> original, Cloner cloner)
72      : base(original, cloner) {
73      BestKnownQualityParameter = cloner.Clone(original.BestKnownQualityParameter);
74      MaximizationParameter = cloner.Clone(original.MaximizationParameter);
75      ParameterizeOperators();
76    }
77
78    protected SingleObjectiveProblem() : base() {
79
80      MaximizationParameter = new ValueParameter<BoolValue>("Maximization", "Whether the problem should be maximized (True) or minimized (False).", new BoolValue(false).AsReadOnly()) { Hidden = true, ReadOnly = true };
81      BestKnownQualityParameter = new OptionalValueParameter<DoubleValue>("BestKnownQuality", "The quality of the best known solution of this problem.");
82
83      Parameters.Add(MaximizationParameter);
84      Parameters.Add(BestKnownQualityParameter);
85
86      Operators.Add(Evaluator);
87      Operators.Add(new SingleObjectiveAnalyzer<TEncodedSolution>());
88      Operators.Add(new SingleObjectiveImprover<TEncodedSolution>());
89      Operators.Add(new SingleObjectiveMoveEvaluator<TEncodedSolution>());
90      Operators.Add(new SingleObjectiveMoveGenerator<TEncodedSolution>());
91      Operators.Add(new SingleObjectiveMoveMaker<TEncodedSolution>());
92
93      ParameterizeOperators();
94    }
95
96    protected SingleObjectiveProblem(TEncoding encoding) : base(encoding) {
97      Parameters.Add(MaximizationParameter = new ValueParameter<BoolValue>("Maximization", "Set to false if the problem should be minimized.", new BoolValue(false).AsReadOnly()) { Hidden = true, ReadOnly = true });
98      Parameters.Add(BestKnownQualityParameter = new OptionalValueParameter<DoubleValue>("BestKnownQuality", "The quality of the best known solution of this problem."));
99
100      Operators.Add(Evaluator);
101      Operators.Add(new SingleObjectiveAnalyzer<TEncodedSolution>());
102      Operators.Add(new SingleObjectiveImprover<TEncodedSolution>());
103      Operators.Add(new SingleObjectiveMoveEvaluator<TEncodedSolution>());
104      Operators.Add(new SingleObjectiveMoveGenerator<TEncodedSolution>());
105      Operators.Add(new SingleObjectiveMoveMaker<TEncodedSolution>());
106
107      ParameterizeOperators();
108    }
109
110    [StorableHook(HookType.AfterDeserialization)]
111    private void AfterDeserialization() {
112      ParameterizeOperators();
113    }
114
115    public ISingleObjectiveEvaluationResult Evaluate(TEncodedSolution solution, IRandom random) {
116      return Evaluate(solution, random, CancellationToken.None);
117    }
118    public abstract ISingleObjectiveEvaluationResult Evaluate(TEncodedSolution solution, IRandom random, CancellationToken cancellationToken);
119
120    public void Evaluate(ISingleObjectiveSolutionContext<TEncodedSolution> solutionContext, IRandom random) {
121      Evaluate(solutionContext, random, CancellationToken.None);
122    }
123    public virtual void Evaluate(ISingleObjectiveSolutionContext<TEncodedSolution> solutionContext, IRandom random, CancellationToken cancellationToken) {
124      var evaluationResult = Evaluate(solutionContext.EncodedSolution, random, cancellationToken);
125      solutionContext.EvaluationResult = evaluationResult;
126    }
127
128    public virtual void Analyze(TEncodedSolution[] solutions, double[] qualities, ResultCollection results, IRandom random) { }
129    public virtual void Analyze(ISingleObjectiveSolutionContext<TEncodedSolution>[] solutionContexts, ResultCollection results, IRandom random) {
130      var solutions = solutionContexts.Select(c => c.EncodedSolution).ToArray();
131      var qualities = solutionContexts.Select(c => c.EvaluationResult.Quality).ToArray();
132      Analyze(solutions, qualities, results, random);
133    }
134
135    public virtual IEnumerable<TEncodedSolution> GetNeighbors(TEncodedSolution solutions, IRandom random) {
136      return Enumerable.Empty<TEncodedSolution>();
137    }
138    public virtual IEnumerable<ISingleObjectiveSolutionContext<TEncodedSolution>> GetNeighbors(ISingleObjectiveSolutionContext<TEncodedSolution> solutionContext, IRandom random) {
139      return GetNeighbors(solutionContext.EncodedSolution, random).Select(n => new SingleObjectiveSolutionContext<TEncodedSolution>(n));
140    }
141
142    public static bool IsBetter(bool maximization, double quality, double bestQuality) {
143      return (maximization && quality > bestQuality || !maximization && quality < bestQuality);
144    }
145
146    public virtual bool IsBetter(double quality, double bestQuality) {
147      return IsBetter(Maximization, quality, bestQuality);
148    }
149
150    //TODO refactor to solution contexts
151    protected ISingleObjectiveSolutionContext<TEncodedSolution> GetBest(ISingleObjectiveSolutionContext<TEncodedSolution>[] solutionContexts) {
152      return Maximization ? solutionContexts.MaxItems(x => x.EvaluationResult.Quality).First()
153        : solutionContexts.MinItems(x => x.EvaluationResult.Quality).First();
154    }
155    protected Tuple<TEncodedSolution, double> GetBestSolution(TEncodedSolution[] solutions, double[] qualities) {
156      return GetBestSolution(solutions, qualities, Maximization);
157    }
158    public static Tuple<TEncodedSolution, double> GetBestSolution(TEncodedSolution[] solutions, double[] qualities, bool maximization) {
159      var zipped = solutions.Zip(qualities, (s, q) => new { Solution = s, Quality = q });
160      var best = (maximization ? zipped.OrderByDescending(z => z.Quality) : zipped.OrderBy(z => z.Quality)).First();
161      return Tuple.Create(best.Solution, best.Quality);
162    }
163
164    protected override void OnOperatorsChanged() {
165      if (Encoding != null) {
166        PruneMultiObjectiveOperators(Encoding);
167        var combinedEncoding = Encoding as CombinedEncoding;
168        if (combinedEncoding != null) {
169          foreach (var encoding in combinedEncoding.Encodings.ToList()) {
170            PruneMultiObjectiveOperators(encoding);
171          }
172        }
173      }
174      base.OnOperatorsChanged();
175    }
176
177    private void PruneMultiObjectiveOperators(IEncoding encoding) {
178      if (encoding.Operators.Any(x => x is IMultiObjectiveOperator && !(x is ISingleObjectiveOperator)))
179        encoding.Operators = encoding.Operators.Where(x => !(x is IMultiObjectiveOperator) || x is ISingleObjectiveOperator).ToList();
180
181      foreach (var multiOp in Encoding.Operators.OfType<IMultiOperator>()) {
182        foreach (var moOp in multiOp.Operators.Where(x => x is IMultiObjectiveOperator).ToList()) {
183          multiOp.RemoveOperator(moOp);
184        }
185      }
186    }
187
188    protected override void OnEvaluatorChanged() {
189      base.OnEvaluatorChanged();
190      ParameterizeOperators();
191    }
192
193    private void ParameterizeOperators() {
194      foreach (var op in Operators.OfType<ISingleObjectiveEvaluationOperator<TEncodedSolution>>())
195        op.Evaluate = Evaluate;
196      foreach (var op in Operators.OfType<ISingleObjectiveAnalysisOperator<TEncodedSolution>>())
197        op.Analyze = Analyze;
198      foreach (var op in Operators.OfType<INeighborBasedOperator<TEncodedSolution>>())
199        op.GetNeighbors = GetNeighbors;
200    }
201
202    #region ISingleObjectiveHeuristicOptimizationProblem Members
203    IParameter ISingleObjectiveHeuristicOptimizationProblem.MaximizationParameter {
204      get { return Parameters["Maximization"]; }
205    }
206    IParameter ISingleObjectiveHeuristicOptimizationProblem.BestKnownQualityParameter {
207      get { return Parameters["BestKnownQuality"]; }
208    }
209    ISingleObjectiveEvaluator ISingleObjectiveHeuristicOptimizationProblem.Evaluator {
210      get { return Evaluator; }
211    }
212    #endregion
213
214    public event EventHandler MaximizationChanged;
215    protected void OnMaximizationChanged() {
216      MaximizationChanged?.Invoke(this, EventArgs.Empty);
217    }
218  }
219}
Note: See TracBrowser for help on using the repository browser.