Free cookie consent management tool by TermsFeed Policy Generator

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, 4 years 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
RevLine 
[10753]1#region License Information
2/* HeuristicLab
[17226]3 * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
[10753]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
[16692]22using System;
[11786]23using System.Collections.Generic;
[10753]24using System.Linq;
[17320]25using System.Threading;
[16751]26using HEAL.Attic;
[10753]27using HeuristicLab.Common;
28using HeuristicLab.Core;
[11753]29using HeuristicLab.Data;
30using HeuristicLab.Parameters;
[10753]31
[11949]32namespace HeuristicLab.Optimization {
[16723]33  [StorableType("2697320D-0259-44BB-BD71-7EE1B10F664C")]
[16751]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 {
[11990]40
[17356]41    [Storable] protected IValueParameter<DoubleValue> BestKnownQualityParameter { get; private set; }
42    [Storable] protected IValueParameter<BoolValue> MaximizationParameter { get; private set; }
[11990]43
44    public double BestKnownQuality {
45      get {
46        if (BestKnownQualityParameter.Value == null) return double.NaN;
47        return BestKnownQualityParameter.Value.Value;
48      }
49      set {
[13437]50        if (double.IsNaN(value)) {
51          BestKnownQualityParameter.Value = null;
52          return;
53        }
[11990]54        if (BestKnownQualityParameter.Value == null) BestKnownQualityParameter.Value = new DoubleValue(value);
55        else BestKnownQualityParameter.Value.Value = value;
56      }
57    }
58
[17270]59    public bool Maximization {
60      get { return MaximizationParameter.Value.Value; }
61      protected set {
[17317]62        if (Maximization == value) return;
63        MaximizationParameter.ForceValue(new BoolValue(value, @readonly: true));
64        OnMaximizationChanged();
[17270]65      }
66    }
67
[10753]68    [StorableConstructor]
[16723]69    protected SingleObjectiveProblem(StorableConstructorFlag _) : base(_) { }
[10753]70
[16751]71    protected SingleObjectiveProblem(SingleObjectiveProblem<TEncoding, TEncodedSolution> original, Cloner cloner)
[10753]72      : base(original, cloner) {
[17270]73      BestKnownQualityParameter = cloner.Clone(original.BestKnownQualityParameter);
74      MaximizationParameter = cloner.Clone(original.MaximizationParameter);
[11739]75      ParameterizeOperators();
[10753]76    }
[17279]77
[16806]78    protected SingleObjectiveProblem() : base() {
[10753]79
[17279]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
[11753]86      Operators.Add(Evaluator);
[16751]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>());
[10753]92
[11739]93      ParameterizeOperators();
[10753]94    }
95
[16806]96    protected SingleObjectiveProblem(TEncoding encoding) : base(encoding) {
[17270]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."));
[13396]99
100      Operators.Add(Evaluator);
[16751]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>());
[13396]106
107      ParameterizeOperators();
108    }
109
[10753]110    [StorableHook(HookType.AfterDeserialization)]
111    private void AfterDeserialization() {
[11739]112      ParameterizeOperators();
[10753]113    }
114
[17382]115    public ISingleObjectiveEvaluationResult Evaluate(TEncodedSolution solution, IRandom random) {
[17320]116      return Evaluate(solution, random, CancellationToken.None);
117    }
[17382]118    public abstract ISingleObjectiveEvaluationResult Evaluate(TEncodedSolution solution, IRandom random, CancellationToken cancellationToken);
[17363]119
[17366]120    public void Evaluate(ISingleObjectiveSolutionContext<TEncodedSolution> solutionContext, IRandom random) {
[17363]121      Evaluate(solutionContext, random, CancellationToken.None);
122    }
123    public virtual void Evaluate(ISingleObjectiveSolutionContext<TEncodedSolution> solutionContext, IRandom random, CancellationToken cancellationToken) {
[17382]124      var evaluationResult = Evaluate(solutionContext.EncodedSolution, random, cancellationToken);
125      solutionContext.EvaluationResult = evaluationResult;
[17363]126    }
127
[16751]128    public virtual void Analyze(TEncodedSolution[] solutions, double[] qualities, ResultCollection results, IRandom random) { }
[17363]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) {
[16751]136      return Enumerable.Empty<TEncodedSolution>();
[11786]137    }
[17363]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    }
[10753]141
[17279]142    public static bool IsBetter(bool maximization, double quality, double bestQuality) {
143      return (maximization && quality > bestQuality || !maximization && quality < bestQuality);
144    }
145
[13336]146    public virtual bool IsBetter(double quality, double bestQuality) {
[17279]147      return IsBetter(Maximization, quality, bestQuality);
[11970]148    }
149
[17363]150    //TODO refactor to solution contexts
[17522]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    }
[16751]155    protected Tuple<TEncodedSolution, double> GetBestSolution(TEncodedSolution[] solutions, double[] qualities) {
[16692]156      return GetBestSolution(solutions, qualities, Maximization);
157    }
[16751]158    public static Tuple<TEncodedSolution, double> GetBestSolution(TEncodedSolution[] solutions, double[] qualities, bool maximization) {
[16692]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      }
[16801]174      base.OnOperatorsChanged();
[16692]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
[11396]188    protected override void OnEvaluatorChanged() {
189      base.OnEvaluatorChanged();
[11739]190      ParameterizeOperators();
[11396]191    }
192
[11786]193    private void ParameterizeOperators() {
[16751]194      foreach (var op in Operators.OfType<ISingleObjectiveEvaluationOperator<TEncodedSolution>>())
[17363]195        op.Evaluate = Evaluate;
[16751]196      foreach (var op in Operators.OfType<ISingleObjectiveAnalysisOperator<TEncodedSolution>>())
[17363]197        op.Analyze = Analyze;
[16751]198      foreach (var op in Operators.OfType<INeighborBasedOperator<TEncodedSolution>>())
[17363]199        op.GetNeighbors = GetNeighbors;
[11393]200    }
201
[11753]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
[17317]213
214    public event EventHandler MaximizationChanged;
215    protected void OnMaximizationChanged() {
216      MaximizationChanged?.Invoke(this, EventArgs.Empty);
217    }
[10753]218  }
219}
Note: See TracBrowser for help on using the repository browser.