Changeset 702 for trunk/sources/HeuristicLab.GP.StructureIdentification

Timestamp:

10/29/08 11:21:04 (16 years ago)

Author:

gkronber

Message:

fixed #328 by restructuring evaluation operators to remove state in evaluation operators.

Location:

trunk/sources/HeuristicLab.GP.StructureIdentification

Files:

• BakedTreeEvaluator.cs (modified) (6 diffs)
• Evaluators/CoefficientOfDeterminationEvaluator.cs (modified) (3 diffs)
• Evaluators/EarlyStoppingMeanSquaredErrorEvaluator.cs (modified) (3 diffs)
• Evaluators/GPEvaluatorBase.cs (modified) (3 diffs)
• Evaluators/MeanAbsolutePercentageErrorEvaluator.cs (modified) (3 diffs)
• Evaluators/MeanSquaredErrorEvaluator.cs (modified) (3 diffs)
• Evaluators/SimpleEvaluator.cs (modified) (3 diffs)
• Evaluators/VarianceAccountedForEvaluator.cs (modified) (3 diffs)

trunk/sources/HeuristicLab.GP.StructureIdentification/BakedTreeEvaluator.cs

@@ -30 +30 @@
 
 namespace HeuristicLab.GP.StructureIdentification {
+  /// <summary>
+  /// Evaluates FunctionTrees recursively by interpretation of the function symbols in each node.
+  /// Not thread-safe!
+  /// </summary>
   public class BakedTreeEvaluator {
     private const double EPSILON = 1.0e-7;
+    private double estimatedValueMax;
+    private double estimatedValueMin;
 
     private class Instr {
@@ -43 +49 @@
 
     private List<Instr> code;
+    private Instr[] codeArr;
     private int PC;
     private Dataset dataset;
@@ -52 +59 @@
     }
 
-    public void ResetEvaluator(BakedFunctionTree functionTree, Dataset dataset) {
+    public void ResetEvaluator(BakedFunctionTree functionTree, Dataset dataset, int targetVariable, int start, int end, double punishmentFactor) {
       this.dataset = dataset;
+      double maximumPunishment = punishmentFactor * dataset.GetRange(targetVariable);
+
+      // get the mean of the values of the target variable to determin the max and min bounds of the estimated value
+      double targetMean = dataset.GetMean(targetVariable, start, end - 1);
+      estimatedValueMin = targetMean - maximumPunishment;
+      estimatedValueMax = targetMean + maximumPunishment;
+
       List<LightWeightFunction> linearRepresentation = functionTree.LinearRepresentation;
       code.Clear();
@@ -61 +75 @@
         code.Add(curInstr);
       }
+
+      codeArr = code.ToArray<Instr>();
     }
 
@@ -88 +104 @@
       PC = 0;
       this.sampleIndex = sampleIndex;
-      return EvaluateBakedCode();
+
+      double estimated = EvaluateBakedCode();
+      if(double.IsNaN(estimated) || double.IsInfinity(estimated)) {
+        estimated = estimatedValueMax;
+      } else if(estimated > estimatedValueMax) {
+        estimated = estimatedValueMax;
+      } else if(estimated < estimatedValueMin) {
+        estimated = estimatedValueMin;
+      }
+      return estimated;
     }
 
@@ -101 +126 @@
 
     private double EvaluateBakedCode() {
-      Instr currInstr = code[PC++];
+      Instr currInstr = codeArr[PC++];
       switch(currInstr.symbol) {
         case EvaluatorSymbolTable.VARIABLE: {

trunk/sources/HeuristicLab.GP.StructureIdentification/Evaluators/CoefficientOfDeterminationEvaluator.cs

@@ -30 +30 @@
 namespace HeuristicLab.GP.StructureIdentification {
   public class CoefficientOfDeterminationEvaluator : GPEvaluatorBase {
-    private DoubleData r2;
     public override string Description {
       get {
@@ -43 +42 @@
     }
 
-    public override IOperation Apply(IScope scope) {
-      r2 = GetVariableValue<DoubleData>("R2", scope, false, false);
-      if(r2 == null) {
-        r2 = new DoubleData();
-        scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("R2"), r2));
-      }
-
-      return base.Apply(scope);
-    }
-
-    public override void Evaluate(int start, int end) {
+    public override void Evaluate(IScope scope, BakedTreeEvaluator evaluator, HeuristicLab.DataAnalysis.Dataset dataset, int targetVariable, int start, int end, bool updateTargetValues) {
       double errorsSquaredSum = 0.0;
       double originalDeviationTotalSumOfSquares = 0.0;
+      double targetMean = dataset.GetMean(targetVariable, start, end);
       for(int sample = start; sample < end; sample++) {
-        double estimated = GetEstimatedValue(sample);
-        double original = GetOriginalValue(sample);
-        SetOriginalValue(sample, estimated);
+        double estimated = evaluator.Evaluate(sample);
+        double original = dataset.GetValue(targetVariable, sample);
+        if(updateTargetValues) {
+          dataset.SetValue(targetVariable, sample, estimated);
+        }
         if(!double.IsNaN(original) && !double.IsInfinity(original)) {
           double error = estimated - original;
           errorsSquaredSum += error * error;
 
-          double origDeviation = original - TargetMean;
+          double origDeviation = original - targetMean;
           originalDeviationTotalSumOfSquares += origDeviation * origDeviation;
         }
@@ -74 +66 @@
       if(double.IsNaN(quality) || double.IsInfinity(quality))
         quality = double.MaxValue;
+
+      DoubleData r2 = GetVariableValue<DoubleData>("R2", scope, false, false);
+      if(r2 == null) {
+        r2 = new DoubleData();
+        scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("R2"), r2));
+      }
+
       r2.Data = quality;
     }

trunk/sources/HeuristicLab.GP.StructureIdentification/Evaluators/EarlyStoppingMeanSquaredErrorEvaluator.cs

@@ -30 +30 @@
 namespace HeuristicLab.GP.StructureIdentification {
   public class EarlyStoppingMeanSquaredErrorEvaluator : MeanSquaredErrorEvaluator {
-    private double qualityLimit;
     public override string Description {
       get {
@@ -44 +43 @@
     }
 
-    public override IOperation Apply(IScope scope) {
-      qualityLimit = GetVariableValue<DoubleData>("QualityLimit", scope, false).Data;
-      return base.Apply(scope);
-    }
+    // evaluates the function-tree for the given target-variable and the whole dataset and returns the MSE
+    public override void Evaluate(IScope scope, BakedTreeEvaluator evaluator, HeuristicLab.DataAnalysis.Dataset dataset, int targetVariable, int start, int end, bool updateTargetValues) {
+      double qualityLimit = GetVariableValue<DoubleData>("QualityLimit", scope, false).Data;
+      DoubleData mse = GetVariableValue<DoubleData>("MSE", scope, false, false);
+      if(mse == null) {
+        mse = new DoubleData();
+        scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("MSE"), mse));
+      }
 
-    // evaluates the function-tree for the given target-variable and the whole dataset and returns the MSE
-    public override void Evaluate(int start, int end) {
       double errorsSquaredSum = 0;
       int rows = end - start;
       for(int sample = start; sample < end; sample++) {
-        double estimated = GetEstimatedValue(sample);
-        double original = GetOriginalValue(sample);
-        SetOriginalValue(sample, estimated);
+        double estimated = evaluator.Evaluate(sample);
+        double original = dataset.GetValue(targetVariable, sample);
+        if(updateTargetValues) {
+          dataset.SetValue(targetVariable, sample, estimated);
+        }
         if(!double.IsNaN(original) && !double.IsInfinity(original)) {
           double error = estimated - original;
@@ -71 +74 @@
         errorsSquaredSum = double.MaxValue;
       }
+
       mse.Data = errorsSquaredSum;
     }

trunk/sources/HeuristicLab.GP.StructureIdentification/Evaluators/GPEvaluatorBase.cs

@@ -31 +31 @@
 namespace HeuristicLab.GP.StructureIdentification {
   public abstract class GPEvaluatorBase : OperatorBase {
-    private int targetVariable;
-    private int start;
-    private int end;
-    private bool useEstimatedValues;
-    private double[] backupValues;
-    private int evaluatedSamples;
-    private double estimatedValueMax;
-    private double estimatedValueMin;
-    private int treeSize;
-    private double totalEvaluatedNodes;
-    protected Dataset dataset;
-    private double targetMean;
-    private BakedTreeEvaluator evaluator;
-    protected double TargetMean { get { return targetMean; } }
-
     public GPEvaluatorBase()
       : base() {
@@ -61 +46 @@
     public override IOperation Apply(IScope scope) {
       // get all variable values
-      targetVariable = GetVariableValue<IntData>("TargetVariable", scope, true).Data;
-      dataset = GetVariableValue<Dataset>("Dataset", scope, true);
+      int targetVariable = GetVariableValue<IntData>("TargetVariable", scope, true).Data;
+      Dataset dataset = GetVariableValue<Dataset>("Dataset", scope, true);
       BakedFunctionTree functionTree = GetVariableValue<BakedFunctionTree>("FunctionTree", scope, true);
-      double maximumPunishment = GetVariableValue<DoubleData>("PunishmentFactor", scope, true).Data * dataset.GetRange(targetVariable);
-      treeSize = scope.GetVariableValue<IntData>("TreeSize", false).Data;
-      totalEvaluatedNodes = scope.GetVariableValue<DoubleData>("TotalEvaluatedNodes", true).Data;
+      double punishmentFactor = GetVariableValue<DoubleData>("PunishmentFactor", scope, true).Data;
+      int treeSize = scope.GetVariableValue<IntData>("TreeSize", false).Data;
+      double totalEvaluatedNodes = scope.GetVariableValue<DoubleData>("TotalEvaluatedNodes", true).Data;
       int start = GetVariableValue<IntData>("SamplesStart", scope, true).Data;
       int end = GetVariableValue<IntData>("SamplesEnd", scope, true).Data;
-      useEstimatedValues = GetVariableValue<BoolData>("UseEstimatedTargetValue", scope, true).Data;
+      bool useEstimatedValues = GetVariableValue<BoolData>("UseEstimatedTargetValue", scope, true).Data;
+      double[] backupValues = null;
       // prepare for autoregressive modelling by saving the original values of the target-variable to a backup array
       if(useEstimatedValues &&
-        (backupValues == null || start != this.start || end != this.end)) {
-        this.start = start;
-        this.end = end;
+        (backupValues == null || backupValues.Length!=end-start)) {
         backupValues = new double[end - start];
         for(int i = start; i < end; i++) {
@@ -80 +64 @@
         }
       }
-      // get the mean of the values of the target variable to determin the max and min bounds of the estimated value
-      targetMean = dataset.GetMean(targetVariable, start, end - 1);
-      estimatedValueMin = targetMean - maximumPunishment;
-      estimatedValueMax = targetMean + maximumPunishment;
 
       // initialize and reset the evaluator
-      if(evaluator == null) evaluator = new BakedTreeEvaluator();
-      evaluator.ResetEvaluator(functionTree, dataset);
-      evaluatedSamples = 0;
+      BakedTreeEvaluator evaluator = new BakedTreeEvaluator();
+      evaluator.ResetEvaluator(functionTree, dataset, targetVariable, start, end, punishmentFactor);
 
-      Evaluate(start, end);
+      Evaluate(scope, evaluator, dataset, targetVariable, start, end, useEstimatedValues);
 
       // restore the values of the target variable from the backup array if necessary
-      if(useEstimatedValues) RestoreDataset(dataset, targetVariable, start, end);
+      if(useEstimatedValues) {
+        for(int i = start; i < end; i++) {
+          dataset.SetValue(i, targetVariable, backupValues[i - start]);
+        }
+      }
+
       // update the value of total evaluated nodes
-      scope.GetVariableValue<DoubleData>("TotalEvaluatedNodes", true).Data = totalEvaluatedNodes + treeSize * evaluatedSamples;
+      scope.GetVariableValue<DoubleData>("TotalEvaluatedNodes", true).Data = totalEvaluatedNodes + treeSize * (end-start);
       return null;
     }
 
-    private void RestoreDataset(Dataset dataset, int targetVariable, int from, int to) {
-      for(int i = from; i < to; i++) {
-        dataset.SetValue(i, targetVariable, backupValues[i - from]);
-      }
-    }
-
-    public abstract void Evaluate(int start, int end);
-
-    public void SetOriginalValue(int sample, double value) {
-      if(useEstimatedValues) {
-        dataset.SetValue(sample, targetVariable, value);
-      }
-    }
-
-    public double GetOriginalValue(int sample) {
-      return dataset.GetValue(sample, targetVariable);
-    }
-
-    public double GetEstimatedValue(int sample) {
-      evaluatedSamples++;
-      double estimated = evaluator.Evaluate(sample);
-      if(double.IsNaN(estimated) || double.IsInfinity(estimated)) {
-        estimated = estimatedValueMax;
-      } else if(estimated > estimatedValueMax) {
-        estimated = estimatedValueMax;
-      } else if(estimated < estimatedValueMin) {
-        estimated = estimatedValueMin;
-      }
-      return estimated;
-    }
+    public abstract void Evaluate(IScope scope, BakedTreeEvaluator evaluator, Dataset dataset, int targetVariable, int start, int end, bool updateTargetValues);
   }
 }

trunk/sources/HeuristicLab.GP.StructureIdentification/Evaluators/MeanAbsolutePercentageErrorEvaluator.cs

@@ -27 +27 @@
 using HeuristicLab.Data;
 using HeuristicLab.Operators;
+using HeuristicLab.DataAnalysis;
 
 namespace HeuristicLab.GP.StructureIdentification {
   public class MeanAbsolutePercentageErrorEvaluator : GPEvaluatorBase {
-    private DoubleData mape;
     public override string Description {
       get {
@@ -43 +43 @@
     }
 
-    public override IOperation Apply(IScope scope) {
-      mape = GetVariableValue<DoubleData>("MAPE", scope, false, false);
-      if(mape == null) {
-        mape = new DoubleData();
-        scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("MAPE"), mape));
-      }
-
-      return base.Apply(scope);
-    }
-
-    public override void Evaluate(int start, int end) {
+    public override void Evaluate(IScope scope, BakedTreeEvaluator evaluator, Dataset dataset, int targetVariable, int start, int end, bool updateTargetValues) {
       double errorsSum = 0.0;
       int n = 0;
       for(int sample = start; sample < end; sample++) {
-        double estimated = GetEstimatedValue(sample);
-        double original = GetOriginalValue(sample);
-        SetOriginalValue(sample, estimated);
-        if(!double.IsNaN(original) && !double.IsInfinity(original) && original!=0.0) {
+        double estimated = evaluator.Evaluate(sample);
+        double original = dataset.GetValue(targetVariable, sample);
+
+        if(updateTargetValues) {
+          dataset.SetValue(targetVariable, sample, estimated);
+        }
+        
+        if(!double.IsNaN(original) && !double.IsInfinity(original) && original != 0.0) {
           double percent_error = Math.Abs((estimated - original) / original);
           errorsSum += percent_error;
@@ -69 +63 @@
       if(double.IsNaN(quality) || double.IsInfinity(quality))
         quality = double.MaxValue;
+
+      // create a variable for the MAPE
+      DoubleData mape = GetVariableValue<DoubleData>("MAPE", scope, false, false);
+      if(mape == null) {
+        mape = new DoubleData();
+        scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("MAPE"), mape));
+      }
+
       mape.Data = quality;
     }

trunk/sources/HeuristicLab.GP.StructureIdentification/Evaluators/MeanSquaredErrorEvaluator.cs

@@ -27 +27 @@
 using HeuristicLab.Data;
 using HeuristicLab.Operators;
+using HeuristicLab.DataAnalysis;
 
 namespace HeuristicLab.GP.StructureIdentification {
   public class MeanSquaredErrorEvaluator : GPEvaluatorBase {
-    protected DoubleData mse;
     public override string Description {
       get {
@@ -43 +43 @@
     }
 
-    public override IOperation Apply(IScope scope) {
-      mse = GetVariableValue<DoubleData>("MSE", scope, false, false);
-      if(mse == null) {
-        mse = new DoubleData();
-        scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("MSE"), mse));
-      }
-
-      return base.Apply(scope);
-    }
-
-    public override void Evaluate(int start, int end) {
+    public override void Evaluate(IScope scope, BakedTreeEvaluator evaluator, Dataset dataset, int targetVariable, int start, int end, bool updateTargetValues) {
       double errorsSquaredSum = 0;
       for(int sample = start; sample < end; sample++) {
-        double original = GetOriginalValue(sample);
-        double estimated = GetEstimatedValue(sample);
-        SetOriginalValue(sample, estimated);
+        double original = dataset.GetValue(targetVariable, sample);
+        double estimated = evaluator.Evaluate(sample);
+        if(updateTargetValues) {
+          dataset.SetValue(targetVariable, sample, estimated);
+        }
         if(!double.IsNaN(original) && !double.IsInfinity(original)) {
           double error = estimated - original;
@@ -69 +61 @@
         errorsSquaredSum = double.MaxValue;
       }
+
+      DoubleData mse = GetVariableValue<DoubleData>("MSE", scope, false, false);
+      if(mse == null) {
+        mse = new DoubleData();
+        scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("MSE"), mse));
+      }
+
       mse.Data = errorsSquaredSum;
     }

trunk/sources/HeuristicLab.GP.StructureIdentification/Evaluators/SimpleEvaluator.cs

@@ -27 +27 @@
 using HeuristicLab.Data;
 using HeuristicLab.Operators;
+using HeuristicLab.DataAnalysis;
 
 namespace HeuristicLab.GP.StructureIdentification {
   public class SimpleEvaluator : GPEvaluatorBase {
-    private ItemList values;
     public SimpleEvaluator()
       : base() {
@@ -36 +36 @@
     }
 
-    public override IOperation Apply(IScope scope) {
-      values = GetVariableValue<ItemList>("Values", scope, false, false);
+    public override void Evaluate(IScope scope, BakedTreeEvaluator evaluator, Dataset dataset, int targetVariable, int start, int end, bool updateTargetValues) {
+      ItemList values = GetVariableValue<ItemList>("Values", scope, false, false);
       if(values == null) {
         values = new ItemList();
@@ -47 +47 @@
       }
       values.Clear();
-      return base.Apply(scope);
-    }
 
-    public override void Evaluate(int start, int end) {
       for(int sample = start; sample < end; sample++) {
         ItemList row = new ItemList();
-        double estimated = GetEstimatedValue(sample);
-        double original = GetOriginalValue(sample);
-        SetOriginalValue(sample, estimated);
+        double estimated = evaluator.Evaluate(sample);
+        double original = dataset.GetValue(targetVariable, sample);
+        if(updateTargetValues) {
+          dataset.SetValue(targetVariable, sample, estimated);
+        }
         row.Add(new DoubleData(estimated));
         row.Add(new DoubleData(original));

trunk/sources/HeuristicLab.GP.StructureIdentification/Evaluators/VarianceAccountedForEvaluator.cs

@@ -31 +31 @@
 namespace HeuristicLab.GP.StructureIdentification {
   public class VarianceAccountedForEvaluator : GPEvaluatorBase {
-    private DoubleData vaf;
     public override string Description {
       get {
@@ -54 +53 @@
     }
 
-    public override IOperation Apply(IScope scope) {
-      vaf = GetVariableValue<DoubleData>("VAF", scope, false, false);
-      if(vaf == null) {
-        vaf = new DoubleData();
-        scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("VAF"), vaf));
-      }
-
-      return base.Apply(scope);
-    }
-
-    public override void Evaluate(int start, int end) {
+    public override void Evaluate(IScope scope, BakedTreeEvaluator evaluator, Dataset dataset, int targetVariable, int start, int end, bool updateTargetValues) {
       int nSamples = end - start;
       double[] errors = new double[nSamples];
       double[] originalTargetVariableValues = new double[nSamples];
       for(int sample = start; sample < end; sample++) {
-        double estimated = GetEstimatedValue(sample);
-        double original = GetOriginalValue(sample);
-        SetOriginalValue(sample, estimated);
+        double estimated = evaluator.Evaluate(sample);
+        double original = dataset.GetValue(targetVariable, sample);
+        if(updateTargetValues) {
+          dataset.SetValue(targetVariable, sample, estimated);
+        }
         if(!double.IsNaN(original) && !double.IsInfinity(original)) {
           errors[sample - start] = original - estimated;
@@ -84 +75 @@
         quality = double.MaxValue;
       }
+      DoubleData vaf = GetVariableValue<DoubleData>("VAF", scope, false, false);
+      if(vaf == null) {
+        vaf = new DoubleData();
+        scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("VAF"), vaf));
+      }
+
       vaf.Data = quality;
     }