source: branches/CMAES/HeuristicLab.Algorithms.CMAEvolutionStrategy/3.3/CMAOperators/CMAMutator.cs @ 9709

Last change on this file since 9709 was 9709, checked in by abeham, 6 years ago

#1961: implemented reviewer comments

File size: 7.5 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2013 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 HeuristicLab.Common;
24using HeuristicLab.Core;
25using HeuristicLab.Data;
26using HeuristicLab.Encodings.RealVectorEncoding;
27using HeuristicLab.Operators;
28using HeuristicLab.Optimization;
29using HeuristicLab.Parameters;
30using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
31using HeuristicLab.Random;
32
33namespace HeuristicLab.Algorithms.CMAEvolutionStrategy {
34  [Item("CMAMutator", "Mutates the solution vector according to the CMA-ES scheme.")]
35  [StorableClass]
36  public sealed class CMAMutator : SingleSuccessorOperator, IStochasticOperator, ICMAManipulator, IIterationBasedOperator {
37
38    public Type CMAType {
39      get { return typeof(CMAParameters); }
40    }
41
42    #region Parameter Properties
43    public ILookupParameter<IRandom> RandomParameter {
44      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
45    }
46
47    public ILookupParameter<IntValue> PopulationSizeParameter {
48      get { return (ILookupParameter<IntValue>)Parameters["PopulationSize"]; }
49    }
50
51    public ILookupParameter<IntValue> IterationsParameter {
52      get { return (ILookupParameter<IntValue>)Parameters["Iterations"]; }
53    }
54
55    public IValueLookupParameter<IntValue> MaximumIterationsParameter {
56      get { return (IValueLookupParameter<IntValue>)Parameters["MaximumIterations"]; }
57    }
58
59    public ILookupParameter<RealVector> MeanParameter {
60      get { return (ILookupParameter<RealVector>)Parameters["Mean"]; }
61    }
62
63    public IScopeTreeLookupParameter<RealVector> RealVectorParameter {
64      get { return (IScopeTreeLookupParameter<RealVector>)Parameters["RealVector"]; }
65    }
66
67    public IValueLookupParameter<DoubleMatrix> BoundsParameter {
68      get { return (IValueLookupParameter<DoubleMatrix>)Parameters["Bounds"]; }
69    }
70
71    public ILookupParameter<CMAParameters> StrategyParametersParameter {
72      get { return (ILookupParameter<CMAParameters>)Parameters["StrategyParameters"]; }
73    }
74
75    public IFixedValueParameter<IntValue> MaxTriesParameter {
76      get { return (IFixedValueParameter<IntValue>)Parameters["MaxTries"]; }
77    }
78
79    public IFixedValueParameter<BoolValue> TruncateAtBoundsParameter {
80      get { return (IFixedValueParameter<BoolValue>)Parameters["TruncateAtBounds"]; }
81    }
82    #endregion
83
84    [StorableConstructor]
85    private CMAMutator(bool deserializing) : base(deserializing) { }
86    private CMAMutator(CMAMutator original, Cloner cloner) : base(original, cloner) { }
87    public CMAMutator()
88      : base() {
89      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
90      Parameters.Add(new LookupParameter<IntValue>("PopulationSize", "The population size (lambda) determines how many offspring should be created."));
91      Parameters.Add(new LookupParameter<IntValue>("Iterations", "The current iteration that is being processed."));
92      Parameters.Add(new ValueLookupParameter<IntValue>("MaximumIterations", "The maximum number of iterations to be processed."));
93      Parameters.Add(new LookupParameter<RealVector>("Mean", "The current mean solution."));
94      Parameters.Add(new ScopeTreeLookupParameter<RealVector>("RealVector", "The solution vector of real values."));
95      Parameters.Add(new ValueLookupParameter<DoubleMatrix>("Bounds", "The bounds for the dimensions."));
96      Parameters.Add(new LookupParameter<CMAParameters>("StrategyParameters", "The CMA-ES strategy parameters used for mutation."));
97      Parameters.Add(new FixedValueParameter<IntValue>("MaxTries", "The maximum number of tries a mutation should be performed if it was outside the bounds.", new IntValue(100)));
98      Parameters.Add(new FixedValueParameter<BoolValue>("TruncateAtBounds", "Whether the point should be truncated at the bounds if none of the tries resulted in a point within the bounds.", new BoolValue(true)));
99    }
100
101    public override IDeepCloneable Clone(Cloner cloner) {
102      return new CMAMutator(this, cloner);
103    }
104
105    public override IOperation Apply() {
106      var maxTries = MaxTriesParameter.Value.Value;
107      var truncateAtBounds = TruncateAtBoundsParameter.Value.Value;
108      var random = RandomParameter.ActualValue;
109      var lambda = PopulationSizeParameter.ActualValue.Value;
110      var xmean = MeanParameter.ActualValue;
111      var arx = RealVectorParameter.ActualValue;
112      var sp = StrategyParametersParameter.ActualValue;
113      var iterations = IterationsParameter.ActualValue.Value;
114      var initialIterations = sp.InitialIterations;
115      var bounds = BoundsParameter.ActualValue;
116
117      if (arx == null || arx.Length == 0) {
118        arx = new ItemArray<RealVector>(lambda);
119        for (int i = 0; i < lambda; i++) arx[i] = new RealVector(xmean.Length);
120        RealVectorParameter.ActualValue = arx;
121      }
122      var nd = new NormalDistributedRandom(random, 0, 1);
123
124      var length = arx[0].Length;
125
126      for (int i = 0; i < lambda; i++) {
127        int tries = 0;
128        bool inRange;
129        if (initialIterations > iterations) {
130          for (int k = 0; k < length; k++) {
131            do {
132              arx[i][k] = xmean[k] + sp.Sigma * sp.D[k] * nd.NextDouble();
133              inRange = bounds[k % bounds.Rows, 0] <= arx[i][k] && arx[i][k] <= bounds[k % bounds.Rows, 1];
134              if (!inRange) tries++;
135            } while (!inRange && tries < maxTries);
136            if (!inRange && truncateAtBounds) {
137              if (bounds[k % bounds.Rows, 0] > arx[i][k]) arx[i][k] = bounds[k % bounds.Rows, 0];
138              else if (bounds[k % bounds.Rows, 1] < arx[i][k]) arx[i][k] = bounds[k % bounds.Rows, 1];
139            }
140          }
141        } else {
142          var B = sp.B;
143          do {
144            tries++;
145            inRange = true;
146            var artmp = new double[length];
147            for (int k = 0; k < length; ++k) {
148              artmp[k] = sp.D[k] * nd.NextDouble();
149            }
150
151            for (int k = 0; k < length; k++) {
152              var sum = 0.0;
153              for (int j = 0; j < length; j++)
154                sum += B[k, j] * artmp[j];
155              arx[i][k] = xmean[k] + sp.Sigma * sum; // m + sig * Normal(0,C)
156              if (bounds[k % bounds.Rows, 0] > arx[i][k] || arx[i][k] > bounds[k % bounds.Rows, 1])
157                inRange = false;
158            }
159          } while (!inRange && tries < maxTries);
160          if (!inRange && truncateAtBounds) {
161            for (int k = 0; k < length; k++) {
162              if (bounds[k % bounds.Rows, 0] > arx[i][k]) arx[i][k] = bounds[k % bounds.Rows, 0];
163              else if (bounds[k % bounds.Rows, 1] < arx[i][k]) arx[i][k] = bounds[k % bounds.Rows, 1];
164            }
165          }
166        }
167      }
168      return base.Apply();
169    }
170  }
171}
Note: See TracBrowser for help on using the repository browser.