Changeset 3892 for trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/SupportVectorRegression

Timestamp:

06/02/10 19:10:35 (15 years ago)

Author:

gkronber

Message:

Improved code for analyzers for SVR and symbolic regression. #1009

File:

• trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/SupportVectorRegression/BestSupportVectorRegressionSolutionAnalyzer.cs (modified) (1 diff)

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

@@ -36 +36 @@
 using HeuristicLab.Problems.DataAnalysis.Evaluators;
 using HeuristicLab.Problems.DataAnalysis.SupportVectorMachine;
+using HeuristicLab.Problems.DataAnalysis.Regression.Symbolic.Analyzers;
 
 namespace HeuristicLab.Problems.DataAnalysis.Regression.SupportVectorRegression {
-  [Item("BestSupportVectorRegressionSolutionAnalyzer", "An operator for analyzing the best support vector solution of regression problems.")]
+  [Item("BestSupportVectorRegressionSolutionAnalyzer", "An operator for analyzing the best solution of support vector regression problems.")]
   [StorableClass]
-  public sealed class BestSupportVectorRegressionSolutionAnalyzer : SingleSuccessorOperator, IAnalyzer {
+  public sealed class BestSupportVectorRegressionSolutionAnalyzer : RegressionSolutionAnalyzer {
     private const string SupportVectorRegressionModelParameterName = "SupportVectorRegressionModel";
-    private const string ProblemDataParameterName = "ProblemData";
-    private const string QualityParameterName = "Quality";
-    private const string UpperEstimationLimitParameterName = "UpperEstimationLimit";
-    private const string LowerEstimationLimitParameterName = "LowerEstimationLimit";
+    private const string BestSolutionInputvariableCountResultName = "Variables used by best solution";
     private const string BestSolutionParameterName = "BestSolution";
-    private const string BestSolutionQualityParameterName = "BestSolutionQuality";
-    private const string ResultsParameterName = "Results";
-    private const string BestSolutionResultName = "Best solution (on validiation set)";
-    private const string BestSolutionInputvariableCountResultName = "Variables used by best solution";
-    private const string BestSolutionTrainingRSquared = "Best solution R² (training)";
-    private const string BestSolutionTestRSquared = "Best solution R² (test)";
-    private const string BestSolutionTrainingMse = "Best solution mean squared error (training)";
-    private const string BestSolutionTestMse = "Best solution mean squared error (test)";
-    private const string BestSolutionTrainingRelativeError = "Best solution average relative error (training)";
-    private const string BestSolutionTestRelativeError = "Best solution average relative error (test)";
 
+    #region parameter properties
     public ScopeTreeLookupParameter<SupportVectorMachineModel> SupportVectorRegressionModelParameter {
       get { return (ScopeTreeLookupParameter<SupportVectorMachineModel>)Parameters[SupportVectorRegressionModelParameterName]; }
-    }
-    public IValueLookupParameter<DataAnalysisProblemData> ProblemDataParameter {
-      get { return (IValueLookupParameter<DataAnalysisProblemData>)Parameters[ProblemDataParameterName]; }
-    }
-    public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
-      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters[QualityParameterName]; }
-    }
-    public IValueLookupParameter<DoubleValue> UpperEstimationLimitParameter {
-      get { return (IValueLookupParameter<DoubleValue>)Parameters[UpperEstimationLimitParameterName]; }
-    }
-    public IValueLookupParameter<DoubleValue> LowerEstimationLimitParameter {
-      get { return (IValueLookupParameter<DoubleValue>)Parameters[LowerEstimationLimitParameterName]; }
     }
     public ILookupParameter<SupportVectorRegressionSolution> BestSolutionParameter {
       get { return (ILookupParameter<SupportVectorRegressionSolution>)Parameters[BestSolutionParameterName]; }
     }
-    public ILookupParameter<DoubleValue> BestSolutionQualityParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters[BestSolutionQualityParameterName]; }
+    #endregion
+    #region properties
+    public ItemArray<SupportVectorMachineModel> SupportVectorMachineModel {
+      get { return SupportVectorRegressionModelParameter.ActualValue; }
     }
-    public ILookupParameter<ResultCollection> ResultsParameter {
-      get { return (ILookupParameter<ResultCollection>)Parameters[ResultsParameterName]; }
-    }
+    #endregion
 
     public BestSupportVectorRegressionSolutionAnalyzer()
       : base() {
       Parameters.Add(new ScopeTreeLookupParameter<SupportVectorMachineModel>(SupportVectorRegressionModelParameterName, "The support vector regression models to analyze."));
-      Parameters.Add(new ValueLookupParameter<DataAnalysisProblemData>(ProblemDataParameterName, "The problem data for which the support vector model is a solution."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>(UpperEstimationLimitParameterName, "The upper estimation limit that was set for the evaluation of the support vector model."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>(LowerEstimationLimitParameterName, "The lower estimation limit that was set for the evaluation of the support vector model."));
-      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>(QualityParameterName, "The qualities of the support vector models which should be analyzed."));
-      Parameters.Add(new LookupParameter<SupportVectorRegressionSolution>(BestSolutionParameterName, "The best support vector solution."));
-      Parameters.Add(new LookupParameter<DoubleValue>(BestSolutionQualityParameterName, "The quality of the best support vector solution."));
-      Parameters.Add(new LookupParameter<ResultCollection>(ResultsParameterName, "The result collection where the best support vector solution should be stored."));
+      Parameters.Add(new LookupParameter<SupportVectorRegressionSolution>(BestSolutionParameterName, "The best support vector regression solution."));
     }
 
-    public override IOperation Apply() {
-      ItemArray<DoubleValue> qualities = QualityParameter.ActualValue;
-      ResultCollection results = ResultsParameter.ActualValue;
-      ItemArray<SupportVectorMachineModel> models = SupportVectorRegressionModelParameter.ActualValue;
-      DataAnalysisProblemData problemData = ProblemDataParameter.ActualValue;
-      DoubleValue upperEstimationLimit = UpperEstimationLimitParameter.ActualValue;
-      DoubleValue lowerEstimationLimit = LowerEstimationLimitParameter.ActualValue;
-      var inputVariables = ProblemDataParameter.ActualValue.InputVariables.Select(x => x.Value);
+    protected override DataAnalysisSolution UpdateBestSolution() {
+      double upperEstimationLimit = UpperEstimationLimit != null ? UpperEstimationLimit.Value : double.PositiveInfinity;
+      double lowerEstimationLimit = LowerEstimationLimit != null ? LowerEstimationLimit.Value : double.NegativeInfinity;
 
-      int i = qualities.Select((x, index) => new { index, x.Value }).OrderBy(x => x.Value).First().index;
+      int i = Quality.Select((x, index) => new { index, x.Value }).OrderBy(x => x.Value).First().index;
 
-      SupportVectorRegressionSolution solution = BestSolutionParameter.ActualValue;
-      if (solution == null) {
-        solution = new SupportVectorRegressionSolution(problemData, models[i], inputVariables, lowerEstimationLimit.Value, upperEstimationLimit.Value);
+      if (BestSolutionQualityParameter.ActualValue == null || BestSolutionQualityParameter.ActualValue.Value > Quality[i].Value) {
+        IEnumerable<string> inputVariables = from var in ProblemData.InputVariables
+                                             where ProblemData.InputVariables.ItemChecked(var)
+                                             select var.Value;
+        var solution = new SupportVectorRegressionSolution(ProblemData, SupportVectorMachineModel[i], inputVariables, lowerEstimationLimit, upperEstimationLimit);
+
         BestSolutionParameter.ActualValue = solution;
-        BestSolutionQualityParameter.ActualValue = qualities[i];
-        results.Add(new Result(BestSolutionResultName, solution));
-        results.Add(new Result(BestSolutionInputvariableCountResultName, new IntValue(inputVariables.Count())));
-        #region calculate R2,MSE,Rel Error
-        double[] trainingValues = problemData.Dataset.GetVariableValues(
-          problemData.TargetVariable.Value,
-          problemData.TrainingSamplesStart.Value,
-          problemData.TrainingSamplesEnd.Value);
-        double[] testValues = problemData.Dataset.GetVariableValues(
-          problemData.TargetVariable.Value,
-          problemData.TestSamplesStart.Value,
-          problemData.TestSamplesEnd.Value);
-        double trainingR2 = SimpleRSquaredEvaluator.Calculate(trainingValues, solution.EstimatedTrainingValues);
-        double testR2 = SimpleRSquaredEvaluator.Calculate(testValues, solution.EstimatedTestValues);
-        double trainingMse = SimpleMSEEvaluator.Calculate(trainingValues, solution.EstimatedTrainingValues);
-        double testMse = SimpleMSEEvaluator.Calculate(testValues, solution.EstimatedTestValues);
-        double trainingRelError = SimpleMeanAbsolutePercentageErrorEvaluator.Calculate(trainingValues, solution.EstimatedTrainingValues);
-        double testRelError = SimpleMeanAbsolutePercentageErrorEvaluator.Calculate(testValues, solution.EstimatedTestValues);
-        results.Add(new Result(BestSolutionTrainingRSquared, new DoubleValue(trainingR2)));
-        results.Add(new Result(BestSolutionTestRSquared, new DoubleValue(testR2)));
-        results.Add(new Result(BestSolutionTrainingMse, new DoubleValue(trainingMse)));
-        results.Add(new Result(BestSolutionTestMse, new DoubleValue(testMse)));
-        results.Add(new Result(BestSolutionTrainingRelativeError, new DoubleValue(trainingRelError)));
-        results.Add(new Result(BestSolutionTestRelativeError, new DoubleValue(testRelError)));
-        #endregion
-      } else {
-        if (BestSolutionQualityParameter.ActualValue.Value > qualities[i].Value) {
-          solution = new SupportVectorRegressionSolution(problemData, models[i], inputVariables, lowerEstimationLimit.Value, upperEstimationLimit.Value);
-          BestSolutionParameter.ActualValue = solution;
-          BestSolutionQualityParameter.ActualValue = qualities[i];
-          results[BestSolutionResultName].Value = solution;
-          results[BestSolutionInputvariableCountResultName].Value = new IntValue(inputVariables.Count());
-          #region update R2,MSE, Rel Error
-          double[] trainingValues = problemData.Dataset.GetVariableValues(
-            problemData.TargetVariable.Value,
-            problemData.TrainingSamplesStart.Value,
-            problemData.TrainingSamplesEnd.Value);
-          double[] testValues = problemData.Dataset.GetVariableValues(
-            problemData.TargetVariable.Value,
-            problemData.TestSamplesStart.Value,
-            problemData.TestSamplesEnd.Value);
-          double trainingR2 = SimpleRSquaredEvaluator.Calculate(trainingValues, solution.EstimatedTrainingValues);
-          double testR2 = SimpleRSquaredEvaluator.Calculate(testValues, solution.EstimatedTestValues);
-          double trainingMse = SimpleMSEEvaluator.Calculate(trainingValues, solution.EstimatedTrainingValues);
-          double testMse = SimpleMSEEvaluator.Calculate(testValues, solution.EstimatedTestValues);
-          double trainingRelError = SimpleMeanAbsolutePercentageErrorEvaluator.Calculate(trainingValues, solution.EstimatedTrainingValues);
-          double testRelError = SimpleMeanAbsolutePercentageErrorEvaluator.Calculate(testValues, solution.EstimatedTestValues);
-          results[BestSolutionTrainingRSquared].Value = new DoubleValue(trainingR2);
-          results[BestSolutionTestRSquared].Value = new DoubleValue(testR2);
-          results[BestSolutionTrainingMse].Value = new DoubleValue(trainingMse);
-          results[BestSolutionTestMse].Value = new DoubleValue(testMse);
-          results[BestSolutionTrainingRelativeError].Value = new DoubleValue(trainingRelError);
-          results[BestSolutionTestRelativeError].Value = new DoubleValue(testRelError);
-          #endregion
+        BestSolutionQualityParameter.ActualValue = Quality[i];
+
+        if (Results.ContainsKey(BestSolutionInputvariableCountResultName)) {
+          Results[BestSolutionInputvariableCountResultName].Value = new IntValue(inputVariables.Count());
+        } else {
+          Results.Add(new Result(BestSolutionInputvariableCountResultName, new IntValue(inputVariables.Count())));
         }
       }
-
-      return base.Apply();
+      return BestSolutionParameter.ActualValue;
     }
   }