Free cookie consent management tool by TermsFeed Policy Generator

Changeset 10459 for branches


Ignore:
Timestamp:
02/17/14 08:58:05 (11 years ago)
Author:
bburlacu
Message:

#1772: Merged uncomitted pruning code from trunk. Removed Plugin.cs file. Renamed SymbolicDataAnalysisExpressionAfterCrossoverOperator.cs and SymbolicDataAnalysisExpressionBeforeCrossoverOperator.cs

Location:
branches/HeuristicLab.EvolutionTracking
Files:
2 added
3 deleted
7 edited

Legend:

Unmodified
Added
Removed

  • branches/HeuristicLab.EvolutionTracking/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Formatters/SymbolicExpressionTreeLatexFormatter.cs

    r10456 r10459  
    1717      {"Subtraction", "$-$"},
    1818      {"Multiplication", "$\\times$"},
    19       {"Division", "$\\div$"}
     19      {"Division", "$\\div$"},
     20      {"Logarithm", "$\\log$"},
     21      {"Exponential", "$\\exp$"}
    2022    };
    2123    private readonly ReingoldTilfordLayoutEngine<ISymbolicExpressionTreeNode> layoutEngine;

  • branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisSingleObjectivePruningAnalyzer.cs

    r10456 r10459  
    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}

  • branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj

    r10457 r10459  
    173173  </ItemGroup>
    174174  <ItemGroup>
    175     <Compile Include="Analyzers\SymbolicDataAnalysisSingleObjectivePruningAnalyzer.cs" /> 
     175    <Compile Include="Analyzers\SymbolicDataAnalysisSingleObjectivePruningAnalyzer.cs" />
    176176    <Compile Include="Analyzers\SymbolicDataAnalysisGenealogyAnalyzer.cs" />
    177177    <Compile Include="Analyzers\SymbolicDataAnalysisPopulationDiversityAnalyzer.cs" />
    … …  
    295295    <Compile Include="Symbols\VariableConditionTreeNode.cs" />
    296296    <Compile Include="Symbols\VariableTreeNode.cs" />
    297     <Compile Include="Tracking\SymbolicDataAnalysExpressionAfterCrossoverOperator.cs" />
    298     <Compile Include="Tracking\SymbolicDataAnalysExpressionBeforeCrossoverOperator.cs" />
     297    <Compile Include="Tracking\SymbolicDataAnalysisExpressionAfterCrossoverOperator.cs" />
     298    <Compile Include="Tracking\SymbolicDataAnalysisExpressionBeforeCrossoverOperator.cs" />
    299299    <Compile Include="Tracking\SymbolicDataAnalysisExpressionAfterManipulatorOperator.cs" />
    300300    <Compile Include="Tracking\SymbolicDataAnalysisExpressionBeforeManipulatorOperator.cs" />

  • branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/ISymbolicDataAnalysisImpactValuesCalculator.cs

    r8946 r10459  
    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}

  • branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionPruningOperator.cs

    r10456 r10459  
    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((IRegressionModel)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
    98142
     143        quality -= impactValue;
    99144        prunedSubtrees++;
    100145      }
    101146
    102       if (prunedSubtrees > 0) {
    103         lock (PrunedSubtrees) { PrunedSubtrees.Value += prunedSubtrees; }
    104         lock (PrunedTrees) { PrunedTrees.Value += 1; }
    105       }
     147      //      Quality.Value = quality; // update quality according to what has been pruned
     148
     149      if (prunedSubtrees > 0) prunedTrees = 1;
     150      PrunedSubtreesParameter.ActualValue = new IntValue(prunedSubtrees);
     151      PrunedTreesParameter.ActualValue = new IntValue(prunedTrees);
     152
    106153      return base.Apply();
    107154    }
    … …  
    112159      parent.InsertSubtree(i, replacement);
    113160    }
     161    protected abstract ISymbolicDataAnalysisModel CreateModel();
     162    protected abstract double Evaluate();
     163    protected abstract double Evaluate(IDataAnalysisModel model);
    114164  }
    115165}

  • branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisProblem.cs

    r10347 r10459  
    356356      // add tracking analyzer
    357357      foreach (var op in operators.OfType<SymbolicDataAnalysisGenealogyAnalyzer>()) {
    358         //        op.BeforeCrossoverOperator = new SymbolicDataAnalysExpressionBeforeCrossoverOperator();
    359         //        op.AfterCrossoverOperator = new SymbolicDataAnalysExpressionAfterCrossoverOperator();
     358        //        op.BeforeCrossoverOperator = new SymbolicDataAnalysisExpressionBeforeCrossoverOperator();
     359        //        op.AfterCrossoverOperator = new SymbolicDataAnalysisExpressionAfterCrossoverOperator();
    360360        op.BeforeCrossoverOperator = new BeforeCrossoverOperator<ISymbolicExpressionTree>();
    361361        op.AfterCrossoverOperator = new AfterCrossoverOperator<ISymbolicExpressionTree>();
    … …  
    373373          op.ManipulatorChildParameterName = manipulator.SymbolicExpressionTreeParameter.Name;
    374374        }
     375        op.PopulationParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
    375376      }
    376377    }

  • branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisSolutionImpactValuesCalculator.cs

    r9456 r10459  
    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,
    … …  
    4758      return interpreter.GetSymbolicExpressionTreeValues(tempTree, dataset, rows).Median();
    4859    }
     60
     61
    4962  }
    5063}
Note: See TracChangeset for help on using the changeset viewer.