Free cookie consent management tool by TermsFeed Policy Generator

source: branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Operators/CovariantParsimonyPressure.cs @ 5265

Last change on this file since 5265 was 5265, checked in by gkronber, 13 years ago

changed project files and solution file to make the branch compatible with current trunk version. #1142

File size: 11.8 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2010 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.Linq;
24using HeuristicLab.Core;
25using HeuristicLab.Data;
26using HeuristicLab.Operators;
27using HeuristicLab.Optimization;
28using HeuristicLab.Parameters;
29using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
30using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
31using System.Collections.Generic;
32using HeuristicLab.Problems.DataAnalysis.Evaluators;
33using HeuristicLab.Analysis;
34
35namespace HeuristicLab.Problems.DataAnalysis.Operators {
36  [Item("Covariant Parsimony Pressure", "Covariant Parsimony Pressure.")]
37  [StorableClass]
38  public class CovariantParsimonyPressure : SingleSuccessorOperator {
39    public IScopeTreeLookupParameter<SymbolicExpressionTree> SymbolicExpressionTreeParameter {
40      get { return (IScopeTreeLookupParameter<SymbolicExpressionTree>)Parameters["SymbolicExpressionTree"]; }
41    }
42    public IScopeTreeLookupParameter<DoubleValue> QualityParameter {
43      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
44    }
45    public IScopeTreeLookupParameter<DoubleValue> AdjustedQualityParameter {
46      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["AdjustedQuality"]; }
47    }
48    public ILookupParameter<BoolValue> MaximizationParameter {
49      get { return (ILookupParameter<BoolValue>)Parameters["Maximization"]; }
50    }
51    public IValueLookupParameter<DoubleValue> KParameter {
52      get { return (IValueLookupParameter<DoubleValue>)Parameters["K"]; }
53    }
54    public ILookupParameter<DoubleValue> CParameter {
55      get { return (ILookupParameter<DoubleValue>)Parameters["C"]; }
56    }
57    public ILookupParameter<IntValue> GenerationsParameter {
58      get { return (ILookupParameter<IntValue>)Parameters["Generations"]; }
59    }
60    public IValueLookupParameter<IntValue> FirstGenerationParameter {
61      get { return (IValueLookupParameter<IntValue>)Parameters["FirstGenerationParameter"]; }
62    }
63    public IValueLookupParameter<BoolValue> ApplyParsimonyPressureParameter {
64      get { return (IValueLookupParameter<BoolValue>)Parameters["ApplyParsimonyPressure"]; }
65    }
66    public ILookupParameter<DoubleValue> LengthCorrelationParameter {
67      get { return (ILookupParameter<DoubleValue>)Parameters["Correlation(Length, AdjustedFitness)"]; }
68    }
69    public ILookupParameter<DoubleValue> FitnessCorrelationParameter {
70      get { return (ILookupParameter<DoubleValue>)Parameters["Correlation(Fitness, AdjustedFitness)"]; }
71    }
72    public IValueLookupParameter<PercentValue> ComplexityAdaptionParameter {
73      get { return (IValueLookupParameter<PercentValue>)Parameters["ComplexityAdaption"]; }
74    }
75    public IValueLookupParameter<BoolValue> InvertComplexityAdaptionParameter {
76      get { return (IValueLookupParameter<BoolValue>)Parameters["InvertComplexityAdaption"]; }
77    }
78    public IValueLookupParameter<DoubleValue> MinAverageSizeParameter {
79      get { return (IValueLookupParameter<DoubleValue>)Parameters["MinAverageSize"]; }
80    }
81
82    public CovariantParsimonyPressure(bool deserializing) : base(deserializing) { }
83    public CovariantParsimonyPressure()
84      : base() {
85      Parameters.Add(new ScopeTreeLookupParameter<SymbolicExpressionTree>("SymbolicExpressionTree"));
86      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality"));
87      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("AdjustedQuality"));
88      Parameters.Add(new LookupParameter<BoolValue>("Maximization"));
89      Parameters.Add(new ValueLookupParameter<DoubleValue>("K", new DoubleValue(1.0)));
90      Parameters.Add(new LookupParameter<IntValue>("Generations"));
91      Parameters.Add(new ValueLookupParameter<IntValue>("FirstGenerationParameter", new IntValue(1)));
92      Parameters.Add(new ValueLookupParameter<BoolValue>("ApplyParsimonyPressure"));
93      Parameters.Add(new ValueLookupParameter<PercentValue>("ComplexityAdaption", new PercentValue(-0.01)));
94      Parameters.Add(new LookupParameter<DoubleValue>("Correlation(Length, AdjustedFitness)"));
95      Parameters.Add(new LookupParameter<DoubleValue>("Correlation(Fitness, AdjustedFitness)"));
96      Parameters.Add(new ValueLookupParameter<DoubleValue>("MinAverageSize", new DoubleValue(15)));
97      Parameters.Add(new LookupParameter<DoubleValue>("C"));
98      Parameters.Add(new ValueLookupParameter<BoolValue>("InvertComplexityAdaption"));
99    }
100
101    [StorableHook(Persistence.Default.CompositeSerializers.Storable.HookType.AfterDeserialization)]
102    private void AfterDeserialization() {
103      if (!Parameters.ContainsKey("Maximization"))
104        Parameters.Add(new LookupParameter<BoolValue>("Maximization"));
105      if (!Parameters.ContainsKey("K"))
106        Parameters.Add(new ValueLookupParameter<DoubleValue>("K", new DoubleValue(1.0)));
107      if (!Parameters.ContainsKey("AdjustedQuality")) {
108        Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("AdjustedQuality"));
109      }
110      if (!Parameters.ContainsKey("Generations")) {
111        Parameters.Add(new LookupParameter<IntValue>("Generations"));
112      }
113      if (!Parameters.ContainsKey("FirstGenerationParameter")) {
114        Parameters.Add(new ValueLookupParameter<IntValue>("FirstGenerationParameter", new IntValue(1)));
115      }
116      if (!Parameters.ContainsKey("ApplyParsimonyPressure")) {
117        Parameters.Add(new ValueLookupParameter<BoolValue>("ApplyParsimonyPressure"));
118      }
119      if (!Parameters.ContainsKey("ComplexityAdaption")) {
120        Parameters.Add(new ValueLookupParameter<PercentValue>("ComplexityAdaption", new PercentValue(-0.01)));
121      }
122      if (!Parameters.ContainsKey("MinAverageSize")) {
123        Parameters.Add(new ValueLookupParameter<DoubleValue>("MinAverageSize", new DoubleValue(15)));
124      }
125      if (!Parameters.ContainsKey("C")) {
126        Parameters.Add(new LookupParameter<DoubleValue>("C"));
127      }
128      if (!Parameters.ContainsKey("InvertComplexityAdaption")) {
129        Parameters.Add(new ValueLookupParameter<BoolValue>("InvertComplexityAdaption"));
130      }
131    }
132
133    public override IOperation Apply() {
134      ItemArray<SymbolicExpressionTree> trees = SymbolicExpressionTreeParameter.ActualValue;
135      ItemArray<DoubleValue> qualities = QualityParameter.ActualValue;
136      // always apply Parsimony pressure if overfitting has been detected
137      // otherwise appliy PP only when we are currently overfitting
138      if (GenerationsParameter.ActualValue != null && GenerationsParameter.ActualValue.Value >= FirstGenerationParameter.ActualValue.Value &&
139           ApplyParsimonyPressureParameter.ActualValue.Value == true) {
140        var lengths = from tree in trees
141                      select tree.Size;
142        double k = KParameter.ActualValue.Value;
143
144        // calculate cov(f, l) and cov(l, l^k)
145        OnlineCovarianceEvaluator lengthFitnessCovEvaluator = new OnlineCovarianceEvaluator();
146        OnlineCovarianceEvaluator lengthAdjLengthCovEvaluator = new OnlineCovarianceEvaluator();
147        OnlineMeanAndVarianceCalculator lengthMeanCalculator = new OnlineMeanAndVarianceCalculator();
148        OnlineMeanAndVarianceCalculator fitnessMeanCalculator = new OnlineMeanAndVarianceCalculator();
149        OnlineMeanAndVarianceCalculator adjLengthMeanCalculator = new OnlineMeanAndVarianceCalculator();
150        var lengthEnumerator = lengths.GetEnumerator();
151        var qualityEnumerator = qualities.GetEnumerator();
152        while (lengthEnumerator.MoveNext() & qualityEnumerator.MoveNext()) {
153          double fitness = qualityEnumerator.Current.Value;
154          if (!MaximizationParameter.ActualValue.Value) {
155            // use f = 1 / (1 + quality) for minimization problems
156            fitness = 1.0 / (1.0 + fitness);
157          }
158          lengthFitnessCovEvaluator.Add(lengthEnumerator.Current, fitness);
159          lengthAdjLengthCovEvaluator.Add(lengthEnumerator.Current, Math.Pow(lengthEnumerator.Current, k));
160          lengthMeanCalculator.Add(lengthEnumerator.Current);
161          fitnessMeanCalculator.Add(fitness);
162          adjLengthMeanCalculator.Add(Math.Pow(lengthEnumerator.Current, k));
163        }
164
165        //double sizeAdaption = lengthMeanCalculator.Mean * ComplexityAdaptionParameter.ActualValue.Value;
166        double sizeAdaption = 100.0 * ComplexityAdaptionParameter.ActualValue.Value;
167        if (InvertComplexityAdaptionParameter.ActualValue != null && InvertComplexityAdaptionParameter.ActualValue.Value) {
168          sizeAdaption = -sizeAdaption;
169        }
170        if (lengthMeanCalculator.Mean + sizeAdaption < MinAverageSizeParameter.ActualValue.Value)
171          sizeAdaption = MinAverageSizeParameter.ActualValue.Value - lengthMeanCalculator.Mean;
172
173        //            cov(l, f) - (g(t+1) - mu(t)) avgF
174        // c(t) =  --------------------------------------------
175        //           cov(l, l^k) - (g(t+1) - mu(t)) E[l^k]
176        double c = lengthFitnessCovEvaluator.Covariance - sizeAdaption * fitnessMeanCalculator.Mean;
177        c /= lengthAdjLengthCovEvaluator.Covariance - sizeAdaption * adjLengthMeanCalculator.Mean;
178
179        CParameter.ActualValue = new DoubleValue(c);
180
181        // adjust fitness
182        bool maximization = MaximizationParameter.ActualValue.Value;
183
184        lengthEnumerator = lengths.GetEnumerator();
185        qualityEnumerator = qualities.GetEnumerator();
186        int i = 0;
187        ItemArray<DoubleValue> adjQualities = new ItemArray<DoubleValue>(qualities.Length);
188
189        while (lengthEnumerator.MoveNext() & qualityEnumerator.MoveNext()) {
190          adjQualities[i++] = new DoubleValue(qualityEnumerator.Current.Value - c * Math.Pow(lengthEnumerator.Current, k));
191        }
192        AdjustedQualityParameter.ActualValue = adjQualities;
193        double[] lengthArr = lengths.Select(x => (double)x).ToArray<double>();
194
195        double[] adjFitess = (from f in AdjustedQualityParameter.ActualValue
196                              select f.Value).ToArray<double>();
197        double[] fitnessArr = (from f in QualityParameter.ActualValue
198                               let normFit = maximization ? f.Value : 1.0 / (1.0 + f.Value)
199                               select normFit).ToArray<double>();
200
201        LengthCorrelationParameter.ActualValue = new DoubleValue(alglib.spearmancorr2(lengthArr, adjFitess, lengthArr.Length));
202        FitnessCorrelationParameter.ActualValue = new DoubleValue(alglib.spearmancorr2(fitnessArr, adjFitess, lengthArr.Length));
203
204      } else {
205        CParameter.ActualValue = new DoubleValue(0.0);
206        // adjusted fitness is equal to fitness
207        AdjustedQualityParameter.ActualValue = (ItemArray<DoubleValue>)QualityParameter.ActualValue.Clone();
208        FitnessCorrelationParameter.ActualValue = new DoubleValue(1.0);
209
210        double[] lengths = (from tree in trees
211                            select (double)tree.Size).ToArray<double>();
212
213        double[] fitess = (from f in AdjustedQualityParameter.ActualValue
214                           select f.Value).ToArray<double>();
215
216        LengthCorrelationParameter.ActualValue = new DoubleValue(alglib.spearmancorr2(lengths, fitess, lengths.Length));
217      }
218      return base.Apply();
219    }
220  }
221}
Note: See TracBrowser for help on using the repository browser.