Free cookie consent management tool by TermsFeed Policy Generator

Changeset 10469


Ignore:
Timestamp:
02/19/14 14:04:03 (10 years ago)
Author:
bburlacu
Message:

#2143: Refactored pruning analyzer and operators as per review.

Location:
trunk/sources
Files:
2 added
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification-3.4.csproj

    r10368 r10469  
    150150      <SubType>Code</SubType>
    151151    </Compile>
     152    <Compile Include="SymbolicClassificationPruningOperator.cs" />
    152153    <None Include="HeuristicLab.snk" />
    153154    <None Include="Plugin.cs.frame" />

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SymbolicClassificationPruningAnalyzer.cs

    r10418 r10469  
    2020#endregion
    2121
    22 using System;
    2322using HeuristicLab.Common;
    2423using HeuristicLab.Core;
    25 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
    2624using HeuristicLab.Parameters;
    2725using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    … …  
    3129  [StorableClass]
    3230  public sealed class SymbolicClassificationPruningAnalyzer : SymbolicDataAnalysisSingleObjectivePruningAnalyzer {
    33     private const string ModelCreatorParameterName = "ModelCreator";
    34     #region parameter properties
    35     public ILookupParameter<ISymbolicClassificationModelCreator> ModelCreatorParameter {
    36       get { return (ILookupParameter<ISymbolicClassificationModelCreator>)Parameters[ModelCreatorParameterName]; }
    37     }
    38     #endregion
    39     #region properties
    40     private ISymbolicClassificationModelCreator ModelCreator {
    41       get { return ModelCreatorParameter.ActualValue; }
    42       set { ModelCreatorParameter.ActualValue = value; }
    43     }
    44     #endregion
    45 
     31    private const string ImpactValuesCalculatorParameterName = "ImpactValuesCalculator";
     32    private const string PruningOperatorParameterName = "PruningOperator";
    4633    private SymbolicClassificationPruningAnalyzer(SymbolicClassificationPruningAnalyzer original, Cloner cloner)
    4734      : base(original, cloner) {
    … …  
    5542
    5643    public SymbolicClassificationPruningAnalyzer() {
    57       // pruning parameters
    58       Parameters.Add(new LookupParameter<ISymbolicClassificationModelCreator>(ModelCreatorParameterName));
    59       impactValuesCalculator = new SymbolicClassificationSolutionImpactValuesCalculator();
    60     }
    61 
    62     protected override ISymbolicDataAnalysisModel CreateModel(ISymbolicExpressionTree tree,
    63       ISymbolicDataAnalysisExpressionTreeInterpreter interpreter, double lowerEstimationLimit = Double.MinValue,
    64       double upperEstimationLimit = Double.MaxValue) {
    65       var model = ModelCreator.CreateSymbolicClassificationModel(tree, Interpreter, lowerEstimationLimit, upperEstimationLimit);
    66       model.RecalculateModelParameters((IClassificationProblemData)ProblemData, ProblemData.TrainingIndices);
    67       return model;
     44      Parameters.Add(new ValueParameter<SymbolicDataAnalysisSolutionImpactValuesCalculator>(ImpactValuesCalculatorParameterName, "The impact values calculator", new SymbolicClassificationSolutionImpactValuesCalculator()));
     45      Parameters.Add(new ValueParameter<SymbolicDataAnalysisExpressionPruningOperator>(PruningOperatorParameterName, "The operator used to prune trees", new SymbolicClassificationPruningOperator()));
    6846    }
    6947  }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SymbolicClassificationSolutionImpactValuesCalculator.cs

    r10273 r10469  
    2020#endregion
    2121
     22using System;
    2223using System.Collections.Generic;
    2324using HeuristicLab.Common;
     25using HeuristicLab.Core;
    2426using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
     27using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    2528
    2629namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Classification {
     30  [StorableClass]
     31  [Item("SymbolicClassificationSolutionImpactValuesCalculator", "Calculate symbolic expression tree node impact values for classification problems.")]
    2732  public class SymbolicClassificationSolutionImpactValuesCalculator : SymbolicDataAnalysisSolutionImpactValuesCalculator {
     33    public SymbolicClassificationSolutionImpactValuesCalculator() { }
     34    protected SymbolicClassificationSolutionImpactValuesCalculator(SymbolicClassificationSolutionImpactValuesCalculator original, Cloner cloner)
     35      : base(original, cloner) { }
     36    public override IDeepCloneable Clone(Cloner cloner) {
     37      return new SymbolicClassificationSolutionImpactValuesCalculator(this, cloner);
     38    }
     39    [StorableConstructor]
     40    protected SymbolicClassificationSolutionImpactValuesCalculator(bool deserializing) : base(deserializing) { }
     41
    2842    public override double CalculateReplacementValue(ISymbolicDataAnalysisModel model, ISymbolicExpressionTreeNode node, IDataAnalysisProblemData problemData, IEnumerable<int> rows) {
    2943      var classificationModel = (ISymbolicClassificationModel)model;
    … …  
    3448
    3549    public override double CalculateImpactValue(ISymbolicDataAnalysisModel model, ISymbolicExpressionTreeNode node, IDataAnalysisProblemData problemData, IEnumerable<int> rows, double originalQuality = double.NaN) {
     50      double impactValue, replacementValue;
     51      CalculateImpactAndReplacementValues(model, node, problemData, rows, out impactValue, out replacementValue, originalQuality);
     52      return impactValue;
     53    }
     54
     55    public override void CalculateImpactAndReplacementValues(ISymbolicDataAnalysisModel model, ISymbolicExpressionTreeNode node,
     56      IDataAnalysisProblemData problemData, IEnumerable<int> rows, out double impactValue, out double replacementValue,
     57      double originalQuality = Double.NaN) {
    3658      var classificationModel = (ISymbolicClassificationModel)model;
    3759      var classificationProblemData = (IClassificationProblemData)problemData;
    … …  
    4769      }
    4870
    49       var replacementValue = CalculateReplacementValue(classificationModel, node, classificationProblemData, rows);
     71      replacementValue = CalculateReplacementValue(classificationModel, node, classificationProblemData, rows);
    5072      var constantNode = new ConstantTreeNode(new Constant()) { Value = replacementValue };
    5173
    … …  
    6385      if (errorState != OnlineCalculatorError.None) newQuality = 0.0;
    6486
    65       return originalQuality - newQuality;
     87      impactValue = originalQuality - newQuality;
    6688    }
    67 
    6889  }
    6990}

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4.csproj

    r10368 r10469  
    120120    <Compile Include="Plugin.cs" />
    121121    <Compile Include="SingleObjective\ConstantOptimizationAnalyzer.cs" />
    122     <Compile Include="SingleObjective\Evaluators\SymbolicRegressionMeanRelativeErrorEvaluator.cs" />   
    123   <Compile Include="SymbolicRegressionPruningAnalyzer.cs" />   
    124   <Compile Include="SingleObjective\SymbolicRegressionSingleObjectiveValidationParetoBestSolutionAnalyzer.cs" />
     122    <Compile Include="SingleObjective\Evaluators\SymbolicRegressionMeanRelativeErrorEvaluator.cs" />
     123    <Compile Include="SymbolicRegressionPruningAnalyzer.cs" />
     124    <Compile Include="SingleObjective\SymbolicRegressionSingleObjectiveValidationParetoBestSolutionAnalyzer.cs" />
    125125    <Compile Include="SingleObjective\SymbolicRegressionSingleObjectiveTrainingParetoBestSolutionAnalyzer.cs" />
    126126    <Compile Include="SingleObjective\Evaluators\SymbolicRegressionSingleObjectiveMaxAbsoluteErrorEvaluator.cs" />
    … …  
    145145    <Compile Include="SingleObjective\Evaluators\SymbolicRegressionSingleObjectiveMeanSquaredErrorEvaluator.cs" />
    146146    <Compile Include="SingleObjective\Evaluators\SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.cs" />
     147    <Compile Include="SymbolicRegressionPruningOperator.cs" />
    147148    <Compile Include="SymbolicRegressionSolution.cs" />
    148149    <Compile Include="SymbolicRegressionSolutionImpactValuesCalculator.cs" />

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionPruningAnalyzer.cs

    r10378 r10469  
    1 using System;
     1#region License Information
     2
     3/* HeuristicLab
     4 * Copyright (C) 2002-2014 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
    224using HeuristicLab.Common;
    325using HeuristicLab.Core;
    4 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
     26using HeuristicLab.Parameters;
    527using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    628
    … …  
    931  [StorableClass]
    1032  public sealed class SymbolicRegressionPruningAnalyzer : SymbolicDataAnalysisSingleObjectivePruningAnalyzer {
     33    private const string ImpactValuesCalculatorParameterName = "ImpactValuesCalculator";
     34    private const string PruningOperatorParameterName = "PruningOperator";
    1135    private SymbolicRegressionPruningAnalyzer(SymbolicRegressionPruningAnalyzer original, Cloner cloner)
    1236      : base(original, cloner) {
    … …  
    2044
    2145    public SymbolicRegressionPruningAnalyzer() {
    22       impactValuesCalculator = new SymbolicRegressionSolutionImpactValuesCalculator();
    23     }
    24 
    25     protected override ISymbolicDataAnalysisModel CreateModel(ISymbolicExpressionTree tree,
    26       ISymbolicDataAnalysisExpressionTreeInterpreter interpreter, double lowerEstimationLimit = Double.MinValue,
    27       double upperEstimationLimit = Double.MaxValue) {
    28       return new SymbolicRegressionModel(tree, interpreter, lowerEstimationLimit, upperEstimationLimit);
     46      Parameters.Add(new ValueParameter<SymbolicDataAnalysisSolutionImpactValuesCalculator>(ImpactValuesCalculatorParameterName, "The impact values calculator", new SymbolicRegressionSolutionImpactValuesCalculator()));
     47      Parameters.Add(new ValueParameter<SymbolicDataAnalysisExpressionPruningOperator>(PruningOperatorParameterName, "The operator used to prune trees", new SymbolicRegressionPruningOperator()));
    2948    }
    3049  }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionSolutionImpactValuesCalculator.cs

    r9840 r10469  
    2020#endregion
    2121
     22using System;
    2223using System.Collections.Generic;
    2324using HeuristicLab.Common;
     25using HeuristicLab.Core;
    2426using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
     27using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    2528
    2629namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
     30  [StorableClass]
     31  [Item("SymbolicRegressionSolutionImpactValuesCalculator", "Calculate symbolic expression tree node impact values for regression problems.")]
    2732  public class SymbolicRegressionSolutionImpactValuesCalculator : SymbolicDataAnalysisSolutionImpactValuesCalculator {
     33    public SymbolicRegressionSolutionImpactValuesCalculator() { }
     34
     35    protected SymbolicRegressionSolutionImpactValuesCalculator(SymbolicRegressionSolutionImpactValuesCalculator original, Cloner cloner)
     36      : base(original, cloner) { }
     37    public override IDeepCloneable Clone(Cloner cloner) {
     38      return new SymbolicRegressionSolutionImpactValuesCalculator(this, cloner);
     39    }
     40
     41    [StorableConstructor]
     42    protected SymbolicRegressionSolutionImpactValuesCalculator(bool deserializing) : base(deserializing) { }
    2843    public override double CalculateReplacementValue(ISymbolicDataAnalysisModel model, ISymbolicExpressionTreeNode node, IDataAnalysisProblemData problemData, IEnumerable<int> rows) {
    2944      var regressionModel = (ISymbolicRegressionModel)model;
    … …  
    3449
    3550    public override double CalculateImpactValue(ISymbolicDataAnalysisModel model, ISymbolicExpressionTreeNode node, IDataAnalysisProblemData problemData, IEnumerable<int> rows, double originalQuality = double.NaN) {
     51      double impactValue, replacementValue;
     52      CalculateImpactAndReplacementValues(model, node, problemData, rows, out impactValue, out replacementValue, originalQuality);
     53      return impactValue;
     54    }
     55
     56    public override void CalculateImpactAndReplacementValues(ISymbolicDataAnalysisModel model, ISymbolicExpressionTreeNode node,
     57      IDataAnalysisProblemData problemData, IEnumerable<int> rows, out double impactValue, out double replacementValue,
     58      double originalQuality = Double.NaN) {
    3659      var regressionModel = (ISymbolicRegressionModel)model;
    3760      var regressionProblemData = (IRegressionProblemData)problemData;
    … …  
    4770      }
    4871
    49       var replacementValue = CalculateReplacementValue(regressionModel, node, regressionProblemData, rows);
     72      replacementValue = CalculateReplacementValue(regressionModel, node, regressionProblemData, rows);
    5073      var constantNode = new ConstantTreeNode(new Constant()) { Value = replacementValue };
    5174
    … …  
    6386      if (errorState != OnlineCalculatorError.None) newQuality = 0.0;
    6487
    65       return originalQuality - newQuality;
     88      impactValue = originalQuality - newQuality;
    6689    }
    67 
    6890  }
    6991}

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisSingleObjectivePruningAnalyzer.cs

    r10428 r10469  
    55using HeuristicLab.Core;
    66using HeuristicLab.Data;
    7 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
    8 using HeuristicLab.Optimization;
     7using HeuristicLab.Operators;
     8using HeuristicLab.Optimization.Operators;
    99using HeuristicLab.Parameters;
    1010using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    … …  
    1414  [Item("SymbolicDataAnalysisSingleObjectivePruningAnalyzer", "An analyzer that prunes introns from trees in single objective symbolic data analysis problems.")]
    1515  public abstract class SymbolicDataAnalysisSingleObjectivePruningAnalyzer : SymbolicDataAnalysisSingleObjectiveAnalyzer {
     16    #region parameter names
    1617    private const string ProblemDataParameterName = "ProblemData";
    17     private const string InterpreterParameterName = "SymbolicExpressionTreeInterpreter";
    18 
    1918    private const string UpdateIntervalParameterName = "UpdateInverval";
    2019    private const string UpdateCounterParameterName = "UpdateCounter";
    21 
    2220    private const string PopulationSliceParameterName = "PopulationSlice";
    2321    private const string PruningProbabilityParameterName = "PruningProbability";
    24 
    25     private const string NumberOfPrunedSubtreesParameterName = "PrunedSubtrees";
    26     private const string NumberOfPrunedTreesParameterName = "PrunedTrees";
    27 
     22    private const string TotalNumberOfPrunedSubtreesParameterName = "Number of pruned subtrees";
     23    private const string TotalNumberOfPrunedTreesParameterName = "Number of pruned trees";
    2824    private const string RandomParameterName = "Random";
    29     private const string EstimationLimitsParameterName = "EstimationLimits";
    30 
    3125    private const string PruneOnlyZeroImpactNodesParameterName = "PruneOnlyZeroImpactNodes";
    3226    private const string NodeImpactThresholdParameterName = "ImpactThreshold";
    33 
    34     private const string FitnessCalculationPartitionParameterName = "FitnessCalculationPartition";
    35 
    36     private bool reentry;
    37     [Storable]
    38     protected ISymbolicDataAnalysisSolutionImpactValuesCalculator impactValuesCalculator;
    39 
     27    private const string PruningOperatorParameterName = "PruningOperator";
     28    private const string ResultsParameterName = "Results";
     29    #endregion
     30    #region private members
     31    private DataReducer prunedSubtreesReducer;
     32    private DataReducer prunedTreesReducer;
     33    private DataTableValuesCollector valuesCollector;
     34    private ResultsCollector resultsCollector;
     35    private EmptyOperator emptyOp;
     36    #endregion
    4037    #region parameter properties
     38    public IValueParameter<SymbolicDataAnalysisExpressionPruningOperator> PruningOperatorParameter {
     39      get { return (IValueParameter<SymbolicDataAnalysisExpressionPruningOperator>)Parameters[PruningOperatorParameterName]; }
     40    }
    4141    public IFixedValueParameter<BoolValue> PruneOnlyZeroImpactNodesParameter {
    4242      get { return (IFixedValueParameter<BoolValue>)Parameters[PruneOnlyZeroImpactNodesParameterName]; }
    … …  
    4545      get { return (IFixedValueParameter<DoubleValue>)Parameters[NodeImpactThresholdParameterName]; }
    4646    }
    47     public ILookupParameter<DoubleLimit> EstimationLimitsParameter {
    48       get { return (ILookupParameter<DoubleLimit>)Parameters[EstimationLimitsParameterName]; }
    49     }
    5047    public ILookupParameter<IRandom> RandomParameter {
    5148      get { return (ILookupParameter<IRandom>)Parameters[RandomParameterName]; }
    … …  
    5350    private ILookupParameter<IDataAnalysisProblemData> ProblemDataParameter {
    5451      get { return (ILookupParameter<IDataAnalysisProblemData>)Parameters[ProblemDataParameterName]; }
    55     }
    56     public ILookupParameter<IntRange> FitnessCalculationPartitionParameter {
    57       get { return (ILookupParameter<IntRange>)Parameters[FitnessCalculationPartitionParameterName]; }
    58     }
    59     private ILookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter> InterpreterParameter {
    60       get { return (ILookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>)Parameters[InterpreterParameterName]; }
    6152    }
    6253    public IValueParameter<IntValue> UpdateIntervalParameter {
    … …  
    7263      get { return (IValueParameter<DoubleValue>)Parameters[PruningProbabilityParameterName]; }
    7364    }
    74     public IFixedValueParameter<DoubleValue> NumberOfPrunedSubtreesParameter {
    75       get { return (IFixedValueParameter<DoubleValue>)Parameters[NumberOfPrunedSubtreesParameterName]; }
    76     }
    77     public IFixedValueParameter<DoubleValue> NumberOfPrunedTreesParameter {
    78       get { return (IFixedValueParameter<DoubleValue>)Parameters[NumberOfPrunedTreesParameterName]; }
    79     }
    8065    #endregion
    8166    #region properties
     67    protected SymbolicDataAnalysisExpressionPruningOperator PruningOperator { get { return PruningOperatorParameter.Value; } }
    8268    protected IDataAnalysisProblemData ProblemData { get { return ProblemDataParameter.ActualValue; } }
    83     protected IntRange FitnessCalculationPartition { get { return FitnessCalculationPartitionParameter.ActualValue; } }
    84     protected ISymbolicDataAnalysisExpressionTreeInterpreter Interpreter { get { return InterpreterParameter.ActualValue; } }
    8569    protected IntValue UpdateInterval { get { return UpdateIntervalParameter.Value; } }
    8670    protected IntValue UpdateCounter { get { return UpdateCounterParameter.Value; } }
    8771    protected DoubleRange PopulationSlice { get { return PopulationSliceParameter.Value; } }
    8872    protected DoubleValue PruningProbability { get { return PruningProbabilityParameter.Value; } }
    89     protected DoubleValue PrunedSubtrees { get { return NumberOfPrunedSubtreesParameter.Value; } }
    90     protected DoubleValue PrunedTrees { get { return NumberOfPrunedTreesParameter.Value; } }
    91     protected DoubleLimit EstimationLimits { get { return EstimationLimitsParameter.ActualValue; } }
    9273    protected IRandom Random { get { return RandomParameter.ActualValue; } }
    9374    protected DoubleValue NodeImpactThreshold { get { return NodeImpactThresholdParameter.Value; } }
    9475    protected BoolValue PruneOnlyZeroImpactNodes { get { return PruneOnlyZeroImpactNodesParameter.Value; } }
    9576    #endregion
    96 
    9777    #region IStatefulItem members
    9878    public override void InitializeState() {
    9979      base.InitializeState();
    10080      UpdateCounter.Value = 0;
    101       PrunedSubtrees.Value = 0;
    102       PrunedTrees.Value = 0;
    10381    }
    10482    public override void ClearState() {
    10583      base.ClearState();
    10684      UpdateCounter.Value = 0;
    107       PrunedSubtrees.Value = 0;
    108       PrunedTrees.Value = 0;
    10985    }
    11086    #endregion
    … …  
    11288    [StorableConstructor]
    11389    protected SymbolicDataAnalysisSingleObjectivePruningAnalyzer(bool deserializing) : base(deserializing) { }
    114     [StorableHook(HookType.AfterDeserialization)]
    115     private void AfterDeserialization() {
    116       if (!Parameters.ContainsKey(FitnessCalculationPartitionParameterName))
    117         Parameters.Add(new LookupParameter<IntRange>(FitnessCalculationPartitionParameterName, ""));
    118     }
    11990    protected SymbolicDataAnalysisSingleObjectivePruningAnalyzer(SymbolicDataAnalysisSingleObjectivePruningAnalyzer original, Cloner cloner)
    12091      : base(original, cloner) {
    121       impactValuesCalculator = original.impactValuesCalculator;
     92      this.prunedSubtreesReducer = (DataReducer)original.prunedSubtreesReducer.Clone();
     93      this.prunedTreesReducer = (DataReducer)original.prunedTreesReducer.Clone();
     94      this.valuesCollector = (DataTableValuesCollector)original.valuesCollector.Clone();
     95      this.resultsCollector = (ResultsCollector)original.resultsCollector.Clone();
    12296    }
    12397    protected SymbolicDataAnalysisSingleObjectivePruningAnalyzer() {
     98      #region add parameters
    12499      Parameters.Add(new ValueParameter<DoubleRange>(PopulationSliceParameterName, new DoubleRange(0.75, 1)));
    125100      Parameters.Add(new ValueParameter<DoubleValue>(PruningProbabilityParameterName, new DoubleValue(0.5)));
    126       // analyzer parameters
    127101      Parameters.Add(new ValueParameter<IntValue>(UpdateIntervalParameterName, "The interval in which the tree length analysis should be applied.", new IntValue(1)));
    128102      Parameters.Add(new ValueParameter<IntValue>(UpdateCounterParameterName, "The value which counts how many times the operator was called", new IntValue(0)));
    129103      Parameters.Add(new LookupParameter<IRandom>(RandomParameterName));
    130104      Parameters.Add(new LookupParameter<IDataAnalysisProblemData>(ProblemDataParameterName));
    131       Parameters.Add(new LookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>(InterpreterParameterName));
    132 
    133       Parameters.Add(new FixedValueParameter<DoubleValue>(NumberOfPrunedSubtreesParameterName, new DoubleValue(0)));
    134       Parameters.Add(new FixedValueParameter<DoubleValue>(NumberOfPrunedTreesParameterName, new DoubleValue(0)));
    135       Parameters.Add(new LookupParameter<DoubleLimit>(EstimationLimitsParameterName));
    136105      Parameters.Add(new FixedValueParameter<DoubleValue>(NodeImpactThresholdParameterName, new DoubleValue(0.0)));
    137106      Parameters.Add(new FixedValueParameter<BoolValue>(PruneOnlyZeroImpactNodesParameterName, new BoolValue(false)));
    138       Parameters.Add(new LookupParameter<IntRange>(FitnessCalculationPartitionParameterName, ""));
     107      #endregion
     108    }
     109
     110    private void InitializeOperators() {
     111      prunedSubtreesReducer = new DataReducer();
     112      prunedSubtreesReducer.ParameterToReduce.ActualName = PruningOperator.PrunedSubtreesParameter.ActualName;
     113      prunedSubtreesReducer.ReductionOperation.Value = new ReductionOperation(ReductionOperations.Sum); // sum all the pruned subtrees parameter values
     114      prunedSubtreesReducer.TargetOperation.Value = new ReductionOperation(ReductionOperations.Assign); // asign the sum to the target parameter
     115      prunedSubtreesReducer.TargetParameter.ActualName = TotalNumberOfPrunedSubtreesParameterName;
     116
     117      prunedTreesReducer = new DataReducer();
     118      prunedTreesReducer.ParameterToReduce.ActualName = PruningOperator.PrunedTreesParameter.ActualName;
     119      prunedTreesReducer.ReductionOperation.Value = new ReductionOperation(ReductionOperations.Sum);
     120      prunedTreesReducer.TargetOperation.Value = new ReductionOperation(ReductionOperations.Assign);
     121      prunedTreesReducer.TargetParameter.ActualName = TotalNumberOfPrunedTreesParameterName;
     122
     123      valuesCollector = new DataTableValuesCollector();
     124      valuesCollector.CollectedValues.Add(new LookupParameter<IntValue>(TotalNumberOfPrunedSubtreesParameterName));
     125      valuesCollector.CollectedValues.Add(new LookupParameter<IntValue>(TotalNumberOfPrunedTreesParameterName));
     126      valuesCollector.DataTableParameter.ActualName = "Population pruning";
     127
     128      resultsCollector = new ResultsCollector();
     129      resultsCollector.CollectedValues.Add(new LookupParameter<DataTable>("Population pruning"));
     130      resultsCollector.ResultsParameter.ActualName = ResultsParameterName;
     131
     132      emptyOp = new EmptyOperator();
     133    }
     134
     135    //
     136    /// <summary>
     137    /// Computes the closed interval bounding the portion of the population that is to be pruned.
     138    /// </summary>
     139    /// <returns>Returns an int range [start, end]</returns>
     140    private IntRange GetSliceBounds() {
     141      var count = ExecutionContext.Scope.SubScopes.Count;
     142      var start = (int)Math.Round(PopulationSlice.Start * count);
     143      var end = (int)Math.Round(PopulationSlice.End * count);
     144      if (end > count) end = count;
     145
     146      if (start >= end) throw new ArgumentOutOfRangeException("Invalid PopulationSlice bounds.");
     147      return new IntRange(start, end);
     148    }
     149
     150    private IOperation CreatePruningOperation() {
     151      var oc = new OperationCollection { Parallel = true };
     152      var range = GetSliceBounds();
     153      var qualities = Quality.Select(x => x.Value).ToArray();
     154      var indices = Enumerable.Range(0, qualities.Length).ToArray();
     155      Array.Sort(qualities, indices);
     156      if (!Maximization.Value) Array.Reverse(indices);
     157
     158      var subscopes = ExecutionContext.Scope.SubScopes;
     159
     160      for (int i = 0; i < subscopes.Count; ++i) {
     161        IOperator op;
     162        if (range.Start <= i && i < range.End && Random.NextDouble() <= PruningProbability.Value)
     163          op = PruningOperator;
     164        else op = emptyOp;
     165        var index = indices[i];
     166        var subscope = subscopes[index];
     167        oc.Add(ExecutionContext.CreateChildOperation(op, subscope));
     168      }
     169      return oc;
    139170    }
    140171
    141172    public override IOperation Apply() {
    142       if (reentry) {
    143         UpdateCounter.Value++;
     173      UpdateCounter.Value++;
     174      if (UpdateCounter.Value != UpdateInterval.Value) return base.Apply();
     175      UpdateCounter.Value = 0;
    144176
    145         if (UpdateCounter.Value != UpdateInterval.Value) return base.Apply();
    146         UpdateCounter.Value = 0;
     177      if (prunedSubtreesReducer == null || prunedTreesReducer == null || valuesCollector == null || resultsCollector == null) { InitializeOperators(); }
    147178
    148         var trees = SymbolicExpressionTreeParameter.ActualValue.ToList();
    149         var qualities = QualityParameter.ActualValue.ToList();
     179      var prune = CreatePruningOperation();
     180      var reducePrunedSubtrees = ExecutionContext.CreateChildOperation(prunedSubtreesReducer);
     181      var reducePrunedTrees = ExecutionContext.CreateChildOperation(prunedTreesReducer);
     182      var collectValues = ExecutionContext.CreateChildOperation(valuesCollector);
     183      var collectResults = ExecutionContext.CreateChildOperation(resultsCollector);
    150184
    151         var population = trees.Zip(qualities, (tree, quality) => new { Tree = tree, Quality = quality }).ToList();
    152         Func<double, double, int> compare = (a, b) => Maximization.Value ? a.CompareTo(b) : b.CompareTo(a);
    153         population.Sort((a, b) => compare(a.Quality.Value, b.Quality.Value));
    154 
    155         var start = (int)Math.Round(PopulationSlice.Start * trees.Count);
    156         var end = (int)Math.Round(PopulationSlice.End * trees.Count);
    157 
    158         if (end == population.Count) end--;
    159 
    160         if (start >= end || end >= population.Count) throw new Exception("Invalid PopulationSlice bounds.");
    161 
    162         PrunedSubtrees.Value = 0;
    163         PrunedTrees.Value = 0;
    164 
    165         reentry = false;
    166 
    167         var operations = new OperationCollection { Parallel = true };
    168         foreach (var p in population.Skip(start).Take(end)) {
    169           if (Random.NextDouble() > PruningProbability.Value) continue;
    170           var op = new SymbolicDataAnalysisExpressionPruningOperator {
    171             Model = CreateModel(p.Tree, Interpreter, EstimationLimits.Lower, EstimationLimits.Upper),
    172             ImpactsCalculator = impactValuesCalculator,
    173             ProblemData = ProblemData,
    174             Random = Random,
    175             PruneOnlyZeroImpactNodes = PruneOnlyZeroImpactNodes.Value,
    176             NodeImpactThreshold = NodeImpactThreshold.Value,
    177             FitnessCalculationPartition = FitnessCalculationPartition
    178           };
    179           operations.Add(ExecutionContext.CreateChildOperation(op, ExecutionContext.Scope));
    180         }
    181         return new OperationCollection { operations, ExecutionContext.CreateOperation(this) };
    182       }
    183 
    184       DataTable table;
    185 
    186       if (ResultCollection.ContainsKey("Population Pruning")) {
    187         table = (DataTable)ResultCollection["Population Pruning"].Value;
    188       } else {
    189         table = new DataTable("Population Pruning");
    190         table.Rows.Add(new DataRow("Pruned Trees") { VisualProperties = { StartIndexZero = true } });
    191         table.Rows.Add(new DataRow("Pruned Subtrees") { VisualProperties = { StartIndexZero = true } });
    192         ResultCollection.Add(new Result("Population Pruning", table));
    193       }
    194 
    195       table.Rows["Pruned Trees"].Values.Add(PrunedTrees.Value);
    196       table.Rows["Pruned Subtrees"].Values.Add(PrunedSubtrees.Value);
    197 
    198       reentry = true;
    199 
    200       return base.Apply();
     185      return new OperationCollection { prune, reducePrunedSubtrees, reducePrunedTrees, collectValues, collectResults, base.Apply() };
    201186    }
    202 
    203     protected abstract ISymbolicDataAnalysisModel CreateModel(ISymbolicExpressionTree tree, ISymbolicDataAnalysisExpressionTreeInterpreter interpreter,
    204       double lowerEstimationLimit = double.MinValue, double upperEstimationLimit = double.MaxValue);
    205187  }
    206188}

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/ISymbolicDataAnalysisImpactValuesCalculator.cs

    r8946 r10469  
    11using System.Collections.Generic;
     2using HeuristicLab.Core;
    23using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
    34
    45namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
    5   public interface ISymbolicDataAnalysisSolutionImpactValuesCalculator {
     6  public interface ISymbolicDataAnalysisSolutionImpactValuesCalculator : IItem {
    67    double CalculateReplacementValue(ISymbolicDataAnalysisModel model, ISymbolicExpressionTreeNode node, IDataAnalysisProblemData problemData, IEnumerable<int> rows);
    78    double CalculateImpactValue(ISymbolicDataAnalysisModel model, ISymbolicExpressionTreeNode node, IDataAnalysisProblemData problemData, IEnumerable<int> rows, double originalQuality = double.NaN);
     9    void CalculateImpactAndReplacementValues(ISymbolicDataAnalysisModel model, ISymbolicExpressionTreeNode node, IDataAnalysisProblemData problemData,
     10      IEnumerable<int> rows, out double impactValue, out double replacementValue, double originalQuality = double.NaN);
    811  }
    912}

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionPruningOperator.cs

    r10417 r10469  
    3434  [StorableClass]
    3535  [Item("SymbolicExpressionTreePruningOperator", "An operator that replaces introns with constant values in a symbolic expression tree.")]
    36   public class SymbolicDataAnalysisExpressionPruningOperator : SingleSuccessorOperator {
    37     private const string NumberOfPrunedSubtreesParameterName = "PrunedSubtrees";
    38     private const string NumberOfPrunedTreesParameterName = "PrunedTrees";
     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
    3952    #region parameter properties
    40     public ILookupParameter<DoubleValue> NumberOfPrunedSubtreesParameter {
    41       get { return (ILookupParameter<DoubleValue>)Parameters[NumberOfPrunedSubtreesParameterName]; }
     53    public ILookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter {
     54      get { return (ILookupParameter<ISymbolicExpressionTree>)Parameters[SymbolicExpressionTreeParameterName]; }
    4255    }
    43     public ILookupParameter<DoubleValue> NumberOfPrunedTreesParameter {
    44       get { return (ILookupParameter<DoubleValue>)Parameters[NumberOfPrunedTreesParameterName]; }
     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]; }
    4585    }
    4686    #endregion
    4787    #region properties
    48     private DoubleValue PrunedSubtrees { get { return NumberOfPrunedSubtreesParameter.ActualValue; } }
    49     private DoubleValue PrunedTrees { get { return NumberOfPrunedTreesParameter.ActualValue; } }
     88    protected IDataAnalysisProblemData ProblemData { get { return ProblemDataParameter.ActualValue; } }
     89    protected ISymbolicDataAnalysisSolutionImpactValuesCalculator ImpactValuesCalculator { get { return ImpactValuesCalculatorParameter.Value; } }
     90    protected IntRange FitnessCalculationPartition { get { return FitnessCalculationPartitionParameter.ActualValue; } }
     91    protected BoolValue PruneOnlyZeroImpactNodes { get { return PruneOnlyZeroImpactNodesParameter.Value; } }
     92    protected DoubleValue NodeImpactThreshold { get { return NodeImpactThresholdParameter.Value; } }
     93    protected ISymbolicExpressionTree SymbolicExpressionTree { get { return SymbolicExpressionTreeParameter.ActualValue; } }
     94    protected DoubleValue Quality { get { return QualityParameter.ActualValue; } }
     95    protected DoubleLimit EstimationLimits { get { return EstimationLimitsParameter.ActualValue; } }
     96    protected ISymbolicDataAnalysisExpressionTreeInterpreter Interpreter { get { return InterpreterParameter.ActualValue; } }
    5097    #endregion
    5198
    5299    [StorableConstructor]
    53100    protected SymbolicDataAnalysisExpressionPruningOperator(bool deserializing) : base(deserializing) { }
    54     public override IDeepCloneable Clone(Cloner cloner) {
    55       return new SymbolicDataAnalysisExpressionPruningOperator(this, cloner);
     101    protected SymbolicDataAnalysisExpressionPruningOperator(SymbolicDataAnalysisExpressionPruningOperator original, Cloner cloner)
     102      : base(original, cloner) { }
     103
     104    protected SymbolicDataAnalysisExpressionPruningOperator() {
     105      #region add parameters
     106      Parameters.Add(new LookupParameter<IDataAnalysisProblemData>(ProblemDataParameterName));
     107      Parameters.Add(new LookupParameter<ISymbolicDataAnalysisModel>(SymbolicDataAnalysisModelParameterName));
     108      Parameters.Add(new LookupParameter<IntRange>(FitnessCalculationPartitionParameterName));
     109      Parameters.Add(new LookupParameter<IntValue>(PrunedSubtreesParameterName, "A counter of how many subtrees were replaced."));
     110      Parameters.Add(new LookupParameter<IntValue>(PrunedTreesParameterName, "A counter of how many trees were pruned."));
     111      Parameters.Add(new FixedValueParameter<BoolValue>(PruneOnlyZeroImpactNodesParameterName, "Specify whether or not only zero impact nodes should be pruned."));
     112      Parameters.Add(new FixedValueParameter<DoubleValue>(NodeImpactThresholdParameterName, "Specifies an impact value threshold below which nodes should be pruned."));
     113      Parameters.Add(new LookupParameter<DoubleLimit>(EstimationLimitsParameterName));
     114      Parameters.Add(new LookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>(InterpreterParameterName));
     115      Parameters.Add(new LookupParameter<ISymbolicExpressionTree>(SymbolicExpressionTreeParameterName));
     116      Parameters.Add(new LookupParameter<DoubleValue>(QualityParameterName));
     117      #endregion
    56118    }
    57     protected SymbolicDataAnalysisExpressionPruningOperator(SymbolicDataAnalysisExpressionPruningOperator original, Cloner cloner)
    58       : base(original, cloner) {
    59     }
    60 
    61     public SymbolicDataAnalysisExpressionPruningOperator() {
    62       Parameters.Add(new LookupParameter<DoubleValue>(NumberOfPrunedSubtreesParameterName));
    63       Parameters.Add(new LookupParameter<DoubleValue>(NumberOfPrunedTreesParameterName));
    64     }
    65 
    66     public ISymbolicDataAnalysisModel Model { get; set; }
    67     public IDataAnalysisProblemData ProblemData { get; set; }
    68     public ISymbolicDataAnalysisSolutionImpactValuesCalculator ImpactsCalculator { get; set; }
    69 
    70     public IntRange FitnessCalculationPartition { get; set; }
    71     public IRandom Random { get; set; }
    72 
    73     public bool PruneOnlyZeroImpactNodes { get; set; }
    74     public double NodeImpactThreshold { get; set; }
    75 
    76119    public override IOperation Apply() {
    77       int prunedSubtrees = 0;
    78 
    79       var nodes = Model.SymbolicExpressionTree.Root.GetSubtree(0).GetSubtree(0).IterateNodesPrefix().ToList();
     120      var model = CreateModel();
     121      var nodes = SymbolicExpressionTree.Root.GetSubtree(0).GetSubtree(0).IterateNodesPrefix().ToList();
    80122      var rows = Enumerable.Range(FitnessCalculationPartition.Start, FitnessCalculationPartition.Size).ToList();
    81123
    82       for (int j = 0; j < nodes.Count; ++j) {
    83         var node = nodes[j];
     124      var prunedSubtrees = 0;
     125      var prunedTrees = 0;
     126
     127      double quality = Evaluate(model);
     128
     129      for (int i = 0; i < nodes.Count; ++i) {
     130        var node = nodes[i];
    84131        if (node is ConstantTreeNode) continue;
    85132
    86         var impact = ImpactsCalculator.CalculateImpactValue(Model, node, ProblemData, rows);
     133        double impactValue, replacementValue;
     134        ImpactValuesCalculator.CalculateImpactAndReplacementValues(model, node, ProblemData, rows, out impactValue, out replacementValue, quality);
    87135
    88         if (PruneOnlyZeroImpactNodes) {
    89           if (!impact.IsAlmost(0.0)) continue;
    90         } else {
    91           if (NodeImpactThreshold < impact) continue;
    92         }
     136        if (PruneOnlyZeroImpactNodes.Value && (!impactValue.IsAlmost(0.0))) continue;
     137        else if (NodeImpactThreshold.Value < impactValue) continue;
    93138
    94         var replacementValue = ImpactsCalculator.CalculateReplacementValue(Model, node, ProblemData, rows);
    95139        var constantNode = new ConstantTreeNode(new Constant()) { Value = replacementValue };
    96140        ReplaceWithConstant(node, constantNode);
    97         j += node.GetLength() - 1; // skip subtrees under the node that was folded
     141        i += node.GetLength() - 1; // skip subtrees under the node that was folded
     142
     143        quality -= impactValue;
    98144
    99145        prunedSubtrees++;
    100146      }
    101147
    102       if (prunedSubtrees > 0) {
    103         lock (PrunedSubtrees) { PrunedSubtrees.Value += prunedSubtrees; }
    104         lock (PrunedTrees) { PrunedTrees.Value += 1; }
    105       }
     148      if (prunedSubtrees > 0) prunedTrees = 1;
     149      PrunedSubtreesParameter.ActualValue = new IntValue(prunedSubtrees);
     150      PrunedTreesParameter.ActualValue = new IntValue(prunedTrees);
     151
    106152      return base.Apply();
    107153    }
    … …  
    112158      parent.InsertSubtree(i, replacement);
    113159    }
     160    protected abstract ISymbolicDataAnalysisModel CreateModel();
     161    protected abstract double Evaluate(IDataAnalysisModel model);
    114162  }
    115163}

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisSolutionImpactValuesCalculator.cs

    r9456 r10469  
    2222using System.Collections.Generic;
    2323using HeuristicLab.Common;
     24using HeuristicLab.Core;
    2425using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
     26using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    2527
    2628namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
    27   public abstract class SymbolicDataAnalysisSolutionImpactValuesCalculator : ISymbolicDataAnalysisSolutionImpactValuesCalculator {
     29  [StorableClass]
     30  [Item("SymbolicDataAnalysisSolutionImpactValuesCalculator", "Calculates the impact values and replacements values for symbolic expression tree nodes.")]
     31  public abstract class SymbolicDataAnalysisSolutionImpactValuesCalculator : Item, ISymbolicDataAnalysisSolutionImpactValuesCalculator {
     32    protected SymbolicDataAnalysisSolutionImpactValuesCalculator() { }
     33
     34    protected SymbolicDataAnalysisSolutionImpactValuesCalculator(SymbolicDataAnalysisSolutionImpactValuesCalculator original, Cloner cloner)
     35      : base(original, cloner) { }
     36    [StorableConstructor]
     37    protected SymbolicDataAnalysisSolutionImpactValuesCalculator(bool deserializing) : base(deserializing) { }
    2838    public abstract double CalculateReplacementValue(ISymbolicDataAnalysisModel model, ISymbolicExpressionTreeNode node, IDataAnalysisProblemData problemData, IEnumerable<int> rows);
    2939    public abstract double CalculateImpactValue(ISymbolicDataAnalysisModel model, ISymbolicExpressionTreeNode node, IDataAnalysisProblemData problemData, IEnumerable<int> rows, double originalQuality = double.NaN);
     40    public abstract void CalculateImpactAndReplacementValues(ISymbolicDataAnalysisModel model, ISymbolicExpressionTreeNode node, IDataAnalysisProblemData problemData, IEnumerable<int> rows, out double impactValue, out double replacementValue, double originalQuality = double.NaN);
    3041
    3142    protected static double CalculateReplacementValue(ISymbolicExpressionTreeNode node, ISymbolicExpressionTree sourceTree, ISymbolicDataAnalysisExpressionTreeInterpreter interpreter,
Note: See TracChangeset for help on using the changeset viewer.