Changeset 3462 for trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3

Timestamp:

04/21/10 15:21:34 (14 years ago)

Author:

gkronber

Message:

Refactored symbolic expression tree encoding and problem classes for symbolic regression. #937 , #938

Location:

trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic

Files:

• BestValidationSymbolicRegressionSolutionVisualizer.cs (modified) (9 diffs)
• SymbolicRegressionEvaluator.cs (modified) (6 diffs)
• SymbolicRegressionMeanSquaredErrorEvaluator.cs (modified) (1 diff)
• SymbolicRegressionModel.cs (modified) (2 diffs)
• SymbolicRegressionProblem.cs (modified) (2 diffs)
• SymbolicRegressionSolution.cs (modified) (1 diff)

trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/BestValidationSymbolicRegressionSolutionVisualizer.cs

@@ -39 +39 @@
   [StorableClass]
   public sealed class BestValidationSymbolicRegressionSolutionVisualizer : SingleSuccessorOperator, ISingleObjectiveSolutionsVisualizer, ISolutionsVisualizer {
-    private const string EvaluatorParameterName = "Evaluator";
+    private const string SymbolicExpressionTreeInterpreterParameterName = "SymbolicExpressionTreeInterpreter";
     private const string SymbolicRegressionModelParameterName = "SymbolicRegressionModel";
     private const string DataAnalysisProblemDataParameterName = "DataAnalysisProblemData";
@@ -49 +49 @@
 
     #region parameter properties
-    public ILookupParameter<ISymbolicRegressionEvaluator> EvaluatorParameter {
-      get { return (ILookupParameter<ISymbolicRegressionEvaluator>)Parameters[EvaluatorParameterName]; }
+    public ILookupParameter<ISymbolicExpressionTreeInterpreter> SymbolicExpressionTreeInterpreterParameter {
+      get { return (ILookupParameter<ISymbolicExpressionTreeInterpreter>)Parameters[SymbolicExpressionTreeInterpreterParameterName]; }
     }
     public IValueLookupParameter<IntValue> ValidationSamplesStartParameter {
@@ -82 +82 @@
 
     #region properties
-    public ISymbolicRegressionEvaluator Evaluator {
-      get { return EvaluatorParameter.ActualValue; }
+    public ISymbolicExpressionTreeInterpreter SymbolicExpressionTreeInterpreter {
+      get { return SymbolicExpressionTreeInterpreterParameter.ActualValue; }
     }
     public IntValue ValidationSamplesStart {
@@ -98 +98 @@
       Parameters.Add(new SubScopesLookupParameter<DoubleValue>(QualityParameterName, "The quality of the symbolic regression solutions."));
       Parameters.Add(new LookupParameter<DataAnalysisProblemData>(DataAnalysisProblemDataParameterName, "The symbolic regression problme data on which the best solution should be evaluated."));
+      Parameters.Add(new LookupParameter<ISymbolicExpressionTreeInterpreter>(SymbolicExpressionTreeInterpreterParameterName, "The interpreter that should be used to calculate the output values of symbolic expression trees."));
       Parameters.Add(new ValueLookupParameter<IntValue>(ValidationSamplesStartParameterName, "The start index of the validation partition (part of the training partition)."));
       Parameters.Add(new ValueLookupParameter<IntValue>(ValidationSamplesEndParameterName, "The end index of the validation partition (part of the training partition)."));
@@ -113 +114 @@
 
       var currentBestExpression = (from expression in expressions
-                                   let validationQuality = SymbolicRegressionMeanSquaredErrorEvaluator.Calculate(expression, problemData.Dataset, problemData.TargetVariable.Value, validationSamplesStart, validationSamplesEnd)
+                                   let validationQuality =
+                                     SymbolicRegressionMeanSquaredErrorEvaluator.Calculate(
+                                       SymbolicExpressionTreeInterpreter, expression,
+                                       problemData.Dataset, problemData.TargetVariable.Value,
+                                       validationSamplesStart, validationSamplesEnd)
                                    select new { Expression = expression, ValidationQuality = validationQuality })
                                    .OrderBy(x => x.ValidationQuality)
@@ -121 +126 @@
       if (bestOfRunSolution == null) {
         // no best of run solution yet -> make a solution from the currentBestExpression
-        UpdateBestOfRunSolution(problemData, currentBestExpression.Expression);
+        UpdateBestOfRunSolution(problemData, currentBestExpression.Expression, SymbolicExpressionTreeInterpreter);
       } else {
         // compare quality of current best with best of run solution
@@ -127 +132 @@
         var bestOfRunValidationQuality = SimpleMSEEvaluator.Calculate(validationValues, estimatedValidationValues);
         if (bestOfRunValidationQuality > currentBestExpression.ValidationQuality) {
-          UpdateBestOfRunSolution(problemData, currentBestExpression.Expression);
+          UpdateBestOfRunSolution(problemData, currentBestExpression.Expression, SymbolicExpressionTreeInterpreter);
         }
       }
@@ -135 +140 @@
     }
 
-    private void UpdateBestOfRunSolution(DataAnalysisProblemData problemData, SymbolicExpressionTree tree) {
-      var newBestSolution = CreateDataAnalysisSolution(problemData, tree);
-      BestValidationSolutionParameter.ActualValue = newBestSolution;
+    private void UpdateBestOfRunSolution(DataAnalysisProblemData problemData, SymbolicExpressionTree tree, ISymbolicExpressionTreeInterpreter interpreter) {
+      var newBestSolution = CreateDataAnalysisSolution(problemData, tree, interpreter);
+      if (BestValidationSolutionParameter.ActualValue == null)
+        BestValidationSolutionParameter.ActualValue = newBestSolution;
+      else
+        // only update model
+        BestValidationSolutionParameter.ActualValue.Model = newBestSolution.Model;
 
       var trainingValues = problemData.Dataset.GetVariableValues(problemData.TargetVariable.Value, problemData.TrainingSamplesStart.Value, problemData.TrainingSamplesEnd.Value);
@@ -160 +169 @@
     }
 
-    private SymbolicRegressionModel CreateModel(DataAnalysisProblemData problemData, SymbolicExpressionTree expression) {
-      return new SymbolicRegressionModel(expression, problemData.InputVariables.Select(x => x.Value));
-    }
-
-    private SymbolicRegressionSolution CreateDataAnalysisSolution(DataAnalysisProblemData problemData, SymbolicExpressionTree expression) {
-      return new SymbolicRegressionSolution(problemData, CreateModel(problemData, expression));
+    private SymbolicRegressionSolution CreateDataAnalysisSolution(DataAnalysisProblemData problemData, SymbolicExpressionTree expression, ISymbolicExpressionTreeInterpreter interpreter) {
+      var model = new SymbolicRegressionModel(interpreter, expression, problemData.InputVariables.Select(s => s.Value));
+      return new SymbolicRegressionSolution(problemData, model);
     }
   }

trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/SymbolicRegressionEvaluator.cs

@@ -34 +34 @@
 using HeuristicLab.Problems.DataAnalysis;
 using HeuristicLab.Operators;
+using HeuristicLab.Problems.DataAnalysis.Symbolic;
 
 namespace HeuristicLab.Problems.DataAnalysis.Regression.Symbolic {
@@ -40 +41 @@
   public abstract class SymbolicRegressionEvaluator : SingleSuccessorOperator, ISymbolicRegressionEvaluator {
     private const string QualityParameterName = "Quality";
+    private const string SymbolicExpressionTreeInterpreterParameterName = "SymbolicExpressionTreeInterpreter";
     private const string FunctionTreeParameterName = "FunctionTree";
     private const string RegressionProblemDataParameterName = "RegressionProblemData";
@@ -49 +51 @@
     public ILookupParameter<DoubleValue> QualityParameter {
       get { return (ILookupParameter<DoubleValue>)Parameters[QualityParameterName]; }
+    }
+
+    public ILookupParameter<ISymbolicExpressionTreeInterpreter> SymbolicExpressionTreeInterpreterParameter {
+      get { return (ILookupParameter<ISymbolicExpressionTreeInterpreter>)Parameters[SymbolicExpressionTreeInterpreterParameterName]; }
     }
 
@@ -72 +78 @@
     #endregion
     #region properties
+    public ISymbolicExpressionTreeInterpreter SymbolicExpressionTreeInterpreter {
+      get { return SymbolicExpressionTreeInterpreterParameter.ActualValue; }
+    }
     public SymbolicExpressionTree SymbolicExpressionTree {
       get { return SymbolicExpressionTreeParameter.ActualValue; }
@@ -89 +98 @@
       : base() {
       Parameters.Add(new LookupParameter<DoubleValue>(QualityParameterName, "The quality of the evaluated symbolic regression solution."));
+      Parameters.Add(new LookupParameter<ISymbolicExpressionTreeInterpreter>(SymbolicExpressionTreeInterpreterParameterName, "The interpreter that should be used to calculate the output values of the symbolic expression tree."));
       Parameters.Add(new LookupParameter<SymbolicExpressionTree>(FunctionTreeParameterName, "The symbolic regression solution encoded as a symbolic expression tree."));
       Parameters.Add(new LookupParameter<DataAnalysisProblemData>(RegressionProblemDataParameterName, "The problem data on which the symbolic regression solution should be evaluated."));
@@ -98 +108 @@
     public override IOperation Apply() {
       DoubleValue numberOfEvaluatedNodes = NumberOfEvaluatedNodesParameter.ActualValue;
-      QualityParameter.ActualValue = new DoubleValue(Evaluate(SymbolicExpressionTree, RegressionProblemData.Dataset,
+      QualityParameter.ActualValue = new DoubleValue(Evaluate(SymbolicExpressionTreeInterpreter, SymbolicExpressionTree, RegressionProblemData.Dataset,
         RegressionProblemData.TargetVariable, SamplesStart, SamplesEnd, numberOfEvaluatedNodes));
       return null;
     }
 
-    protected abstract double Evaluate(SymbolicExpressionTree solution, Dataset dataset, StringValue targetVariable, IntValue samplesStart, IntValue samplesEnd, DoubleValue numberOfEvaluatedNodes);
+    protected abstract double Evaluate(ISymbolicExpressionTreeInterpreter interpreter,
+      SymbolicExpressionTree solution,
+      Dataset dataset,
+      StringValue targetVariable,
+      IntValue samplesStart, IntValue samplesEnd,
+      DoubleValue numberOfEvaluatedNodes);
   }
 }

trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/SymbolicRegressionMeanSquaredErrorEvaluator.cs

@@ -41 +41 @@
   [StorableClass]
   public class SymbolicRegressionMeanSquaredErrorEvaluator : SymbolicRegressionEvaluator {
-    protected override double Evaluate(SymbolicExpressionTree solution, Dataset dataset, StringValue targetVariable, IntValue samplesStart, IntValue samplesEnd, DoubleValue numberOfEvaluatedNodes) {
-      double mse = Calculate(solution, dataset, targetVariable.Value, samplesStart.Value, samplesEnd.Value);
+    protected override double Evaluate(ISymbolicExpressionTreeInterpreter interpreter, SymbolicExpressionTree solution, Dataset dataset, StringValue targetVariable, IntValue samplesStart, IntValue samplesEnd, DoubleValue numberOfEvaluatedNodes) {
+      double mse = Calculate(interpreter, solution, dataset, targetVariable.Value, samplesStart.Value, samplesEnd.Value);
       numberOfEvaluatedNodes.Value += solution.Size * (samplesEnd.Value - samplesStart.Value);
       return mse;
     }
 
-    public static double Calculate(SymbolicExpressionTree solution, Dataset dataset, string targetVariable, int start, int end) {
-      SimpleArithmeticExpressionEvaluator evaluator = new SimpleArithmeticExpressionEvaluator();
+    public static double Calculate(ISymbolicExpressionTreeInterpreter interpreter, SymbolicExpressionTree solution, Dataset dataset, string targetVariable, int start, int end) {
       int targetVariableIndex = dataset.GetVariableIndex(targetVariable);
-      var estimatedValues = evaluator.EstimatedValues(solution, dataset, Enumerable.Range(start, end - start));
+      var estimatedValues = interpreter.GetSymbolicExpressionTreeValues(solution, dataset, Enumerable.Range(start, end - start));
       var originalValues = from row in Enumerable.Range(start, end - start) select dataset[row, targetVariableIndex];
       return SimpleMSEEvaluator.Calculate(originalValues, estimatedValues);

trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/SymbolicRegressionModel.cs

@@ -38 +38 @@
 namespace HeuristicLab.Problems.DataAnalysis.Regression.Symbolic {
   [StorableClass]
-  public class SymbolicRegressionModel : DeepCloneable, IModel {
+  [Item("SymbolicRegressionModel", "A symbolic regression model represents an entity that provides estimated values based on input values.")]
+  public class SymbolicRegressionModel : Item {
     [Storable]
     private SymbolicExpressionTree tree;
@@ -45 +46 @@
     }
     [Storable]
-    private SimpleArithmeticExpressionEvaluator evaluator;
-    public SimpleArithmeticExpressionEvaluator Evaluator {
-      get { return evaluator; }
+    private ISymbolicExpressionTreeInterpreter interpreter;
+    public ISymbolicExpressionTreeInterpreter Interpreter {
+      get { return interpreter; }
     }
-    private Dataset emptyDataset;
-    private IEnumerable<int> firstRow = new int[] { 0 };
+    [Storable]
+    private List<string> inputVariables;
+    public IEnumerable<string> InputVariables {
+      get { return inputVariables.AsEnumerable(); }
+    }
 
     public SymbolicRegressionModel() : base() { } // for cloning
 
-    public SymbolicRegressionModel(SymbolicExpressionTree tree, IEnumerable<string> inputVariables)
+    public SymbolicRegressionModel(ISymbolicExpressionTreeInterpreter interpreter, SymbolicExpressionTree tree, IEnumerable<string> inputVariables)
       : base() {
       this.tree = tree;
-      this.evaluator = new SimpleArithmeticExpressionEvaluator();
-      emptyDataset = new Dataset(inputVariables, new double[1, inputVariables.Count()]);
+      this.interpreter = interpreter;
+      this.inputVariables = inputVariables.ToList();
     }
 
-    #region IModel Members
-
-    public double GetValue(double[] xs) {
-      if (xs.Length != emptyDataset.Columns) throw new ArgumentException("Length of input vector doesn't match model");
-      for (int i = 0; i < xs.Length; i++) {
-        emptyDataset[0, i] = xs[i];
-      }
-      return evaluator.EstimatedValues(tree, emptyDataset, firstRow).First();
+    public IEnumerable<double> GetEstimatedValues(Dataset dataset, int start, int end) {
+      return interpreter.GetSymbolicExpressionTreeValues(tree, dataset, Enumerable.Range(start, end - start));
     }
 
-    #endregion
+    public override IDeepCloneable Clone(Cloner cloner) {
+      var clone = (SymbolicRegressionModel)base.Clone(cloner);
+      clone.tree = (SymbolicExpressionTree)tree.Clone(cloner);
+      clone.interpreter = (ISymbolicExpressionTreeInterpreter)interpreter.Clone(cloner);
+      clone.inputVariables = new List<string>(inputVariables);
+      return clone;
+    }
   }
 }

trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/SymbolicRegressionProblem.cs

@@ -34 +34 @@
 using HeuristicLab.Problems.DataAnalysis.Regression;
 using HeuristicLab.Problems.DataAnalysis.Symbolic;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.ArchitectureAlteringOperators;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Manipulators;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Crossovers;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Creators;
 
 namespace HeuristicLab.Problems.DataAnalysis.Regression.Symbolic {
@@ -144 +148 @@
       var globalGrammar = new GlobalSymbolicExpressionGrammar(grammar);
       var visualizer = new BestValidationSymbolicRegressionSolutionVisualizer();
+      var interpreter = new SimpleArithmeticExpressionInterpreter();
       Parameters.Add(new ValueParameter<BoolValue>("Maximization", "Set to false as the error of the regression model should be minimized.", new BoolValue(false)));
       Parameters.Add(new ValueParameter<SymbolicExpressionTreeCreator>("SolutionCreator", "The operator which should be used to create new symbolic regression solutions.", creator));
+      Parameters.Add(new ValueParameter<ISymbolicExpressionTreeInterpreter>("SymbolicExpressionTreeInterpreter", "The interpreter that should be used to evaluate the symbolic expression tree.", interpreter));
       Parameters.Add(new ValueParameter<ISymbolicRegressionEvaluator>("Evaluator", "The operator which should be used to evaluate symbolic regression solutions.", evaluator));
       Parameters.Add(new OptionalValueParameter<DoubleValue>("BestKnownQuality", "The minimal error value that reached by symbolic regression solutions for the problem."));

trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/SymbolicRegressionSolution.cs

@@ -36 +36 @@
   [StorableClass]
   public sealed class SymbolicRegressionSolution : DataAnalysisSolution {
-    public new SymbolicRegressionModel Model {
-      get { return (SymbolicRegressionModel)base.Model; }
-      set { base.Model = value; }
+    private SymbolicRegressionModel model;
+    public SymbolicRegressionModel Model {
+      get { return model; }
+      set {
+        if (model != value) {
+          if (value == null) throw new ArgumentNullException();
+          model = value;
+          OnModelChanged(EventArgs.Empty);
+        }
+      }
     }
 
     public SymbolicRegressionSolution() : base() { }
     public SymbolicRegressionSolution(DataAnalysisProblemData problemData, SymbolicRegressionModel model)
-      : base(problemData, model) {
+      : base(problemData) {
+      this.model = model;
+      RecalculateEstimatedValues();
+    }
+
+    public event EventHandler ModelChanged;
+    private void OnModelChanged(EventArgs e) {
+      RecalculateEstimatedValues();
+      var listeners = ModelChanged;
+      if (listeners != null)
+        listeners(this, e);
+    }
+
+    protected override void OnProblemDataChanged(EventArgs e) {
+      RecalculateEstimatedValues();
+    }
+
+    private void RecalculateEstimatedValues() {
+      estimatedValues = model.GetEstimatedValues(ProblemData.Dataset, 0, ProblemData.Dataset.Rows).ToList();
+      OnEstimatedValuesChanged(EventArgs.Empty);
+    }
+
+    private List<double> estimatedValues;
+    public override IEnumerable<double> EstimatedValues {
+      get {
+        return estimatedValues.AsEnumerable();
+      }
+    }
+
+    public override IEnumerable<double> EstimatedTrainingValues {
+      get {
+        int start = ProblemData.TrainingSamplesStart.Value;
+        int n = ProblemData.TrainingSamplesEnd.Value - start;
+        return estimatedValues.Skip(start).Take(n).ToList();
+      }
+    }
+
+    public override IEnumerable<double> EstimatedTestValues {
+      get {
+        int start = ProblemData.TestSamplesStart.Value;
+        int n = ProblemData.TestSamplesEnd.Value - start;
+        return estimatedValues.Skip(start).Take(n).ToList();
+      }
     }
   }