Free cookie consent management tool by TermsFeed Policy Generator

source: branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionPruningOperator.cs @ 12394

Last change on this file since 12394 was 12208, checked in by bburlacu, 10 years ago

#1772: Merged trunk and worked on the graph view.

File size: 11.2 KB
Line 
1#region License Information
2
3/* HeuristicLab
4 * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
5 *
6 * This file is part of HeuristicLab.
7 *
8 * HeuristicLab is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * (at your option) any later version.
12 *
13 * HeuristicLab is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
20 */
21
22#endregion
23
24using System.Linq;
25using HeuristicLab.Common;
26using HeuristicLab.Core;
27using HeuristicLab.Data;
28using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
29using HeuristicLab.Operators;
30using HeuristicLab.Parameters;
31using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
32
33namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
34  [StorableClass]
35  [Item("SymbolicExpressionTreePruningOperator", "An operator that replaces introns with constant values in a symbolic expression tree.")]
36  public abstract class SymbolicDataAnalysisExpressionPruningOperator : SingleSuccessorOperator {
37    #region parameter names
38    private const string ProblemDataParameterName = "ProblemData";
39    private const string SymbolicDataAnalysisModelParameterName = "SymbolicDataAnalysisModel";
40    private const string ImpactValuesCalculatorParameterName = "ImpactValuesCalculator";
41    private const string PrunedSubtreesParameterName = "PrunedSubtrees";
42    private const string PrunedTreesParameterName = "PrunedTrees";
43    private const string FitnessCalculationPartitionParameterName = "FitnessCalculationPartition";
44    private const string NodeImpactThresholdParameterName = "ImpactThreshold";
45    private const string PruneOnlyZeroImpactNodesParameterName = "PruneOnlyZeroImpactNodes";
46    private const string SymbolicExpressionTreeParameterName = "SymbolicExpressionTree"; // the tree to be pruned
47    private const string QualityParameterName = "Quality"; // the quality
48    private const string EstimationLimitsParameterName = "EstimationLimits";
49    private const string InterpreterParameterName = "SymbolicExpressionTreeInterpreter";
50    #endregion
51
52    #region parameter properties
53    public ILookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter {
54      get { return (ILookupParameter<ISymbolicExpressionTree>)Parameters[SymbolicExpressionTreeParameterName]; }
55    }
56    public ILookupParameter<DoubleValue> QualityParameter {
57      get { return (ILookupParameter<DoubleValue>)Parameters[QualityParameterName]; }
58    }
59    public ILookupParameter<IDataAnalysisProblemData> ProblemDataParameter {
60      get { return (ILookupParameter<IDataAnalysisProblemData>)Parameters[ProblemDataParameterName]; }
61    }
62    public IValueParameter<ISymbolicDataAnalysisSolutionImpactValuesCalculator> ImpactValuesCalculatorParameter {
63      get { return (IValueParameter<ISymbolicDataAnalysisSolutionImpactValuesCalculator>)Parameters[ImpactValuesCalculatorParameterName]; }
64    }
65    public ILookupParameter<IntRange> FitnessCalculationPartitionParameter {
66      get { return (ILookupParameter<IntRange>)Parameters[FitnessCalculationPartitionParameterName]; }
67    }
68    public ILookupParameter<IntValue> PrunedSubtreesParameter {
69      get { return (ILookupParameter<IntValue>)Parameters[PrunedSubtreesParameterName]; }
70    }
71    public ILookupParameter<IntValue> PrunedTreesParameter {
72      get { return (ILookupParameter<IntValue>)Parameters[PrunedTreesParameterName]; }
73    }
74    public IFixedValueParameter<DoubleValue> NodeImpactThresholdParameter {
75      get { return (IFixedValueParameter<DoubleValue>)Parameters[NodeImpactThresholdParameterName]; }
76    }
77    public IFixedValueParameter<BoolValue> PruneOnlyZeroImpactNodesParameter {
78      get { return (IFixedValueParameter<BoolValue>)Parameters[PruneOnlyZeroImpactNodesParameterName]; }
79    }
80    public ILookupParameter<DoubleLimit> EstimationLimitsParameter {
81      get { return (ILookupParameter<DoubleLimit>)Parameters[EstimationLimitsParameterName]; }
82    }
83    public ILookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter> InterpreterParameter {
84      get { return (ILookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>)Parameters[InterpreterParameterName]; }
85    }
86    #endregion
87
88    #region properties
89    protected IDataAnalysisProblemData ProblemData { get { return ProblemDataParameter.ActualValue; } }
90    protected ISymbolicDataAnalysisSolutionImpactValuesCalculator ImpactValuesCalculator { get { return ImpactValuesCalculatorParameter.Value; } }
91    protected IntRange FitnessCalculationPartition { get { return FitnessCalculationPartitionParameter.ActualValue; } }
92    protected bool PruneOnlyZeroImpactNodes {
93      get { return PruneOnlyZeroImpactNodesParameter.Value.Value; }
94      set { PruneOnlyZeroImpactNodesParameter.Value.Value = value; }
95    }
96    protected double NodeImpactThreshold {
97      get { return NodeImpactThresholdParameter.Value.Value; }
98      set { NodeImpactThresholdParameter.Value.Value = value; }
99    }
100    protected ISymbolicExpressionTree SymbolicExpressionTree { get { return SymbolicExpressionTreeParameter.ActualValue; } }
101    protected DoubleValue Quality { get { return QualityParameter.ActualValue; } }
102    protected DoubleLimit EstimationLimits { get { return EstimationLimitsParameter.ActualValue; } }
103    protected ISymbolicDataAnalysisExpressionTreeInterpreter Interpreter { get { return InterpreterParameter.ActualValue; } }
104    #endregion
105
106    [StorableConstructor]
107    protected SymbolicDataAnalysisExpressionPruningOperator(bool deserializing) : base(deserializing) { }
108    protected SymbolicDataAnalysisExpressionPruningOperator(SymbolicDataAnalysisExpressionPruningOperator original, Cloner cloner)
109      : base(original, cloner) { }
110
111    protected SymbolicDataAnalysisExpressionPruningOperator(ISymbolicDataAnalysisSolutionImpactValuesCalculator impactValuesCalculator) {
112      #region add parameters
113      Parameters.Add(new LookupParameter<IDataAnalysisProblemData>(ProblemDataParameterName));
114      Parameters.Add(new LookupParameter<ISymbolicDataAnalysisModel>(SymbolicDataAnalysisModelParameterName));
115      Parameters.Add(new LookupParameter<IntRange>(FitnessCalculationPartitionParameterName));
116      Parameters.Add(new LookupParameter<IntValue>(PrunedSubtreesParameterName, "A counter of how many subtrees were replaced."));
117      Parameters.Add(new LookupParameter<IntValue>(PrunedTreesParameterName, "A counter of how many trees were pruned."));
118      Parameters.Add(new FixedValueParameter<BoolValue>(PruneOnlyZeroImpactNodesParameterName, "Specify whether or not only zero impact nodes should be pruned."));
119      Parameters.Add(new FixedValueParameter<DoubleValue>(NodeImpactThresholdParameterName, "Specifies an impact value threshold below which nodes should be pruned."));
120      Parameters.Add(new LookupParameter<DoubleLimit>(EstimationLimitsParameterName));
121      Parameters.Add(new LookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>(InterpreterParameterName));
122      Parameters.Add(new LookupParameter<ISymbolicExpressionTree>(SymbolicExpressionTreeParameterName));
123      Parameters.Add(new LookupParameter<DoubleValue>(QualityParameterName));
124      Parameters.Add(new ValueParameter<ISymbolicDataAnalysisSolutionImpactValuesCalculator>(ImpactValuesCalculatorParameterName, impactValuesCalculator));
125      #endregion
126    }
127
128    protected abstract ISymbolicDataAnalysisModel CreateModel(ISymbolicExpressionTree tree, ISymbolicDataAnalysisExpressionTreeInterpreter interpreter, IDataAnalysisProblemData problemData, DoubleLimit estimationLimits);
129
130    protected abstract double Evaluate(IDataAnalysisModel model);
131
132    public override IOperation Apply() {
133      var model = CreateModel(SymbolicExpressionTree, Interpreter, ProblemData, EstimationLimits);
134      var nodes = SymbolicExpressionTree.Root.GetSubtree(0).GetSubtree(0).IterateNodesPrefix().ToList();
135      var rows = Enumerable.Range(FitnessCalculationPartition.Start, FitnessCalculationPartition.Size);
136      var prunedSubtrees = 0;
137      var prunedTrees = 0;
138
139      double quality = Evaluate(model);
140
141      for (int i = 0; i < nodes.Count; ++i) {
142        var node = nodes[i];
143        if (node is ConstantTreeNode) continue;
144
145        double impactValue, replacementValue;
146        ImpactValuesCalculator.CalculateImpactAndReplacementValues(model, node, ProblemData, rows, out impactValue, out replacementValue, quality);
147
148        if (PruneOnlyZeroImpactNodes) {
149          if (!impactValue.IsAlmost(0.0)) continue;
150        } else if (NodeImpactThreshold < impactValue) {
151          continue;
152        }
153
154        var constantNode = (ConstantTreeNode)node.Grammar.GetSymbol("Constant").CreateTreeNode();
155        constantNode.Value = replacementValue;
156
157        ReplaceWithConstant(node, constantNode);
158        i += node.GetLength() - 1; // skip subtrees under the node that was folded
159
160        quality -= impactValue;
161
162        prunedSubtrees++;
163      }
164
165      if (prunedSubtrees > 0) prunedTrees = 1;
166      PrunedSubtreesParameter.ActualValue = new IntValue(prunedSubtrees);
167      PrunedTreesParameter.ActualValue = new IntValue(prunedTrees);
168
169      return base.Apply();
170    }
171
172    public ISymbolicExpressionTree Prune(ISymbolicExpressionTree tree, ISymbolicDataAnalysisExpressionTreeInterpreter interpreter, IDataAnalysisProblemData problemData, DoubleLimit estimationLimits) {
173      var model = CreateModel((ISymbolicExpressionTree)tree.Clone(), Interpreter, ProblemData, EstimationLimits);
174      var nodes = SymbolicExpressionTree.Root.GetSubtree(0).GetSubtree(0).IterateNodesPrefix().ToList();
175      var rows = Enumerable.Range(FitnessCalculationPartition.Start, FitnessCalculationPartition.Size);
176
177      double quality = Evaluate(model);
178
179      for (int i = 0; i < nodes.Count; ++i) {
180        var node = nodes[i];
181        if (node is ConstantTreeNode) continue;
182
183        double impactValue, replacementValue;
184        ImpactValuesCalculator.CalculateImpactAndReplacementValues(model, node, ProblemData, rows, out impactValue, out replacementValue, quality);
185
186        if (PruneOnlyZeroImpactNodes) {
187          if (!impactValue.IsAlmost(0.0)) continue;
188        } else if (NodeImpactThreshold < impactValue) {
189          continue;
190        }
191
192        var constantNode = (ConstantTreeNode)node.Grammar.GetSymbol("Constant").CreateTreeNode();
193        constantNode.Value = replacementValue;
194
195        ReplaceWithConstant(node, constantNode);
196        i += node.GetLength() - 1; // skip subtrees under the node that was folded
197
198        quality -= impactValue;
199      }
200      return model.SymbolicExpressionTree;
201    }
202
203    protected static void ReplaceWithConstant(ISymbolicExpressionTreeNode original, ISymbolicExpressionTreeNode replacement) {
204      var parent = original.Parent;
205      var i = parent.IndexOfSubtree(original);
206      parent.RemoveSubtree(i);
207      parent.InsertSubtree(i, replacement);
208    }
209  }
210}
Note: See TracBrowser for help on using the repository browser.