Changeset 3884 for trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression

Timestamp:

06/01/10 17:58:03 (15 years ago)

Author:

gkronber

Message:

Worked on support vector regression operators and views. #1009

Location:

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

Files:

• SupportVectorRegression/BestSupportVectorRegressionSolutionAnalyzer.cs (modified) (1 diff)
• SupportVectorRegression/SupportVectorRegressionSolution.cs (modified) (3 diffs)
• Symbolic/SymbolicRegressionModel.cs (modified) (3 diffs)
• Symbolic/SymbolicRegressionSolution.cs (modified) (2 diffs)

trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/SupportVectorRegression/BestSupportVectorRegressionSolutionAnalyzer.cs

@@ -169 +169 @@
       return base.Apply();
     }
-
-    private IEnumerable<string> GetInputVariables(SymbolicExpressionTree tree) {
-      return (from varNode in tree.IterateNodesPrefix().OfType<VariableTreeNode>()
-              select varNode.VariableName).Distinct();
-    }
   }
 }

trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/SupportVectorRegression/SupportVectorRegressionSolution.cs

@@ -39 +39 @@
   [StorableClass]
   public sealed class SupportVectorRegressionSolution : DataAnalysisSolution {
+    public SupportVectorRegressionSolution() : base() { }
+    public SupportVectorRegressionSolution(DataAnalysisProblemData problemData, SupportVectorMachineModel model, IEnumerable<string> inputVariables, double lowerEstimationLimit, double upperEstimationLimit)
+      : base(problemData, lowerEstimationLimit, upperEstimationLimit) {
+      this.Model = model;
+    }
+
     public override Image ItemImage {
       get { return HeuristicLab.Common.Resources.VS2008ImageLibrary.Function; }
     }
 
-    [Storable]
-    private SupportVectorMachineModel model;
-    public SupportVectorMachineModel Model {
-      get { return model; }
+    public new SupportVectorMachineModel Model {
+      get { return (SupportVectorMachineModel)base.Model; }
+      set { base.Model = value; }
     }
 
@@ -53 +58 @@
     }
 
-    public SupportVectorRegressionSolution() : base() { }
-    public SupportVectorRegressionSolution(DataAnalysisProblemData problemData, SupportVectorMachineModel model, IEnumerable<string> inputVariables, double lowerEstimationLimit, double upperEstimationLimit)
-      : base(problemData, lowerEstimationLimit, upperEstimationLimit) {
-      this.model = model;
-    }
-
-    protected override void OnProblemDataChanged(EventArgs e) {
-      RecalculateEstimatedValues();
-      model.Model.SupportVectorIndizes = new int[0];
+    protected override void OnProblemDataChanged() {
+      Model.Model.SupportVectorIndizes = new int[0];
+      base.OnProblemDataChanged();
     }
 
     private Dataset CalculateSupportVectors() {
-      if (model.Model.SupportVectorIndizes.Length == 0)
+      if (Model.Model.SupportVectorIndizes.Length == 0)
         return new Dataset();
 
-      Dataset dataset = new Dataset(ProblemData.Dataset.VariableNames, new double[model.Model.SupportVectorCount, ProblemData.Dataset.Columns]);
-      for (int i = 0; i < model.Model.SupportVectorIndizes.Length; i++) {
+      Dataset dataset = new Dataset(ProblemData.Dataset.VariableNames, new double[Model.Model.SupportVectorCount, ProblemData.Dataset.Columns]);
+      for (int i = 0; i < Model.Model.SupportVectorIndizes.Length; i++) {
         for (int column = 0; column < ProblemData.Dataset.Columns; column++)
-          dataset[i, column] = ProblemData.Dataset[model.Model.SupportVectorIndizes[i], column];
+          dataset[i, column] = ProblemData.Dataset[Model.Model.SupportVectorIndizes[i], column];
       }
       return dataset;
     }
 
-    private void RecalculateEstimatedValues() {
+    protected override void RecalculateEstimatedValues() {
       SVM.Problem problem = SupportVectorMachineUtil.CreateSvmProblem(ProblemData, 0, ProblemData.Dataset.Rows);
-      SVM.Problem scaledProblem = Scaling.Scale(model.RangeTransform, problem);
+      SVM.Problem scaledProblem = Scaling.Scale(Model.RangeTransform, problem);
 
       estimatedValues = (from row in Enumerable.Range(0, scaledProblem.Count)
-                         let prediction = SVM.Prediction.Predict(model.Model, scaledProblem.X[row])
+                         let prediction = SVM.Prediction.Predict(Model.Model, scaledProblem.X[row])
                          let boundedX = Math.Min(UpperEstimationLimit, Math.Max(LowerEstimationLimit, prediction))
                          select double.IsNaN(boundedX) ? UpperEstimationLimit : boundedX).ToList();
-      OnEstimatedValuesChanged(EventArgs.Empty);
+      OnEstimatedValuesChanged();
     }
 
@@ -112 +111 @@
       }
     }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      SupportVectorRegressionSolution clone = (SupportVectorRegressionSolution)base.Clone(cloner);
-      clone.model = (SupportVectorMachineModel)cloner.Clone(model);
-      return clone;
-    }
   }
 }

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

@@ -39 +39 @@
   [StorableClass]
   [Item("SymbolicRegressionModel", "A symbolic regression model represents an entity that provides estimated values based on input values.")]
-  public class SymbolicRegressionModel : Item {
+  public class SymbolicRegressionModel : NamedItem, IDataAnalysisModel {
+    private SymbolicRegressionModel() : base() { } // for cloning
+    [StorableConstructor]
+    protected SymbolicRegressionModel(bool deserializing)
+      : base(deserializing) {
+    }
+    public SymbolicRegressionModel(ISymbolicExpressionTreeInterpreter interpreter, SymbolicExpressionTree tree, IEnumerable<string> inputVariables)
+      : base() {
+      this.tree = tree;
+      this.interpreter = interpreter;
+      this.inputVariables = inputVariables.ToList();
+    }
+
     [Storable]
     private SymbolicExpressionTree tree;
@@ -50 +62 @@
       get { return interpreter; }
     }
+    [Storable]
     private List<string> inputVariables;
-    [Storable]
     public IEnumerable<string> InputVariables {
       get { return inputVariables.AsEnumerable(); }
@@ -59 +71 @@
       }
     }
-    public SymbolicRegressionModel() : base() { } // for cloning
 
-    public SymbolicRegressionModel(ISymbolicExpressionTreeInterpreter interpreter, SymbolicExpressionTree tree, IEnumerable<string> inputVariables)
-      : base() {
-      this.tree = tree;
-      this.interpreter = interpreter;
-      this.inputVariables = inputVariables.ToList();
-    }
-
-    public IEnumerable<double> GetEstimatedValues(Dataset dataset, int start, int end) {
-      return interpreter.GetSymbolicExpressionTreeValues(tree, dataset, Enumerable.Range(start, end - start));
+    public IEnumerable<double> GetEstimatedValues(DataAnalysisProblemData problemData, int start, int end) {
+      return interpreter.GetSymbolicExpressionTreeValues(tree, problemData.Dataset, Enumerable.Range(start, end - start));
     }
 

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

@@ -37 +37 @@
   [StorableClass]
   public sealed class SymbolicRegressionSolution : DataAnalysisSolution {
+    public SymbolicRegressionSolution() : base() { }
+    public SymbolicRegressionSolution(DataAnalysisProblemData problemData, SymbolicRegressionModel model, double lowerEstimationLimit, double upperEstimationLimit)
+      : base(problemData, lowerEstimationLimit, upperEstimationLimit) {
+      this.Model = model;
+    }
+
     public override Image ItemImage {
       get { return HeuristicLab.Common.Resources.VS2008ImageLibrary.Function; }
     }
-    [Storable]
-    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 new SymbolicRegressionModel Model {
+      get { return (SymbolicRegressionModel)base.Model; }
+      set { base.Model = value; }
     }
 
-    public SymbolicRegressionSolution() : base() { }
-    public SymbolicRegressionSolution(DataAnalysisProblemData problemData, SymbolicRegressionModel model, double lowerEstimationLimit, double upperEstimationLimit)
-      : base(problemData, lowerEstimationLimit, upperEstimationLimit) {
-      this.model = model;
-    }
-
-    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 = (from x in model.GetEstimatedValues(ProblemData.Dataset, 0, ProblemData.Dataset.Rows)
+    protected override void RecalculateEstimatedValues() {
+      estimatedValues = (from x in Model.GetEstimatedValues(ProblemData, 0, ProblemData.Dataset.Rows)
                          let boundedX = Math.Min(UpperEstimationLimit, Math.Max(LowerEstimationLimit, x))
                          select double.IsNaN(boundedX) ? UpperEstimationLimit : boundedX).ToList();
-      OnEstimatedValuesChanged(EventArgs.Empty);
+      OnEstimatedValuesChanged();
     }
 
@@ -103 +84 @@
       }
     }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      SymbolicRegressionSolution clone = (SymbolicRegressionSolution)base.Clone(cloner);
-      clone.model = (SymbolicRegressionModel)cloner.Clone(model);
-      return clone;
-    }
   }
 }