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

Last change on this file since 9303 was 9303, checked in by abeham, 7 years ago

#1961: Improved performance slightly (thx to mkommend)

File size: 7.0 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 IValueParameter<IntValue> MaxTriesParameter {
76      get { return (IValueParameter<IntValue>)Parameters["MaxTries"]; }
77    }
78    #endregion
79
80    [StorableConstructor]
81    private CMAMutator(bool deserializing) : base(deserializing) { }
82    private CMAMutator(CMAMutator original, Cloner cloner) : base(original, cloner) { }
83    public CMAMutator()
84      : base() {
85      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
86      Parameters.Add(new LookupParameter<IntValue>("PopulationSize", "The population size (lambda) determines how many offspring should be created."));
87      Parameters.Add(new LookupParameter<IntValue>("Iterations", "The current iteration that is being processed."));
88      Parameters.Add(new ValueLookupParameter<IntValue>("MaximumIterations", "The maximum number of iterations to be processed."));
89      Parameters.Add(new LookupParameter<RealVector>("Mean", "The current mean solution."));
90      Parameters.Add(new ScopeTreeLookupParameter<RealVector>("RealVector", "The solution vector of real values."));
91      Parameters.Add(new ValueLookupParameter<DoubleMatrix>("Bounds", "The bounds for the dimensions."));
92      Parameters.Add(new LookupParameter<CMAParameters>("StrategyParameters", "The CMA-ES strategy parameters used for mutation."));
93      Parameters.Add(new ValueParameter<IntValue>("MaxTries", "The maximum number of tries a mutation should be performed if it was outside the bounds.", new IntValue(1000)));
94    }
95
96    public override IDeepCloneable Clone(Cloner cloner) {
97      return new CMAMutator(this, cloner);
98    }
99
100    public override IOperation Apply() {
101      var maxTries = MaxTriesParameter.Value.Value;
102      var random = RandomParameter.ActualValue;
103      var lambda = PopulationSizeParameter.ActualValue.Value;
104      var xmean = MeanParameter.ActualValue;
105      var arx = RealVectorParameter.ActualValue;
106      var sp = StrategyParametersParameter.ActualValue;
107      var iterations = IterationsParameter.ActualValue.Value;
108      var initialIterations = sp.InitialIterations;
109      var bounds = BoundsParameter.ActualValue;
110
111      if (arx == null || arx.Length == 0) {
112        arx = new ItemArray<RealVector>(lambda);
113        for (int i = 0; i < lambda; i++) arx[i] = new RealVector(xmean.Length);
114        RealVectorParameter.ActualValue = arx;
115      }
116      var nd = new NormalDistributedRandom(random, 0, 1);
117
118      var length = arx[0].Length;
119
120      for (int i = 0; i < lambda; i++) {
121        int tries = 0;
122        bool inRange;
123        if (initialIterations > iterations) {
124          for (int k = 0; k < length; k++) {
125            do {
126              arx[i][k] = xmean[k] + sp.Sigma * sp.D[k] * nd.NextDouble();
127              inRange = bounds[k % bounds.Rows, 0] <= arx[i][k] && arx[i][k] <= bounds[k % bounds.Rows, 1];
128              if (!inRange) tries++;
129            } while (!inRange && tries < maxTries);
130            if (!inRange && maxTries > 1) {
131              if (bounds[k % bounds.Rows, 0] > arx[i][k]) arx[i][k] = bounds[k % bounds.Rows, 0];
132              else if (bounds[k % bounds.Rows, 1] < arx[i][k]) arx[i][k] = bounds[k % bounds.Rows, 1];
133            }
134          }
135        } else {
136          var B = sp.B;
137          do {
138            tries++;
139            inRange = true;
140            var artmp = new double[length];
141            for (int k = 0; k < length; ++k) {
142              artmp[k] = sp.D[k] * nd.NextDouble();
143            }
144
145            for (int k = 0; k < length; k++) {
146              var sum = 0.0;
147              for (int j = 0; j < length; j++)
148                sum += B[k, j] * artmp[j];
149              arx[i][k] = xmean[k] + sp.Sigma * sum; // m + sig * Normal(0,C)
150              if (bounds[k % bounds.Rows, 0] > arx[i][k] || arx[i][k] > bounds[k % bounds.Rows, 1])
151                inRange = false;
152            }
153          } while (!inRange && tries < maxTries);
154          if (!inRange && maxTries > 1) {
155            for (int k = 0; k < length; k++) {
156              if (bounds[k % bounds.Rows, 0] > arx[i][k]) arx[i][k] = bounds[k % bounds.Rows, 0];
157              else if (bounds[k % bounds.Rows, 1] < arx[i][k]) arx[i][k] = bounds[k % bounds.Rows, 1];
158            }
159          }
160        }
161      }
162      return base.Apply();
163    }
164  }
165}
Note: See TracBrowser for help on using the repository browser.