Changeset 4417 for branches/HeuristicLab.Classification/HeuristicLab.Problems.DataAnalysis.Classification/3.3/Symbolic/Analyzer/ValidationBestSymbolicClassificationSolutionAnalyzer.cs

Timestamp:

09/16/10 17:17:51 (14 years ago)

Author:

mkommend

Message:

adapted classification analyzer and readded views project (ticket #939)

File:

• branches/HeuristicLab.Classification/HeuristicLab.Problems.DataAnalysis.Classification/3.3/Symbolic/Analyzer/ValidationBestSymbolicClassificationSolutionAnalyzer.cs (modified) (5 diffs)

branches/HeuristicLab.Classification/HeuristicLab.Problems.DataAnalysis.Classification/3.3/Symbolic/Analyzer/ValidationBestSymbolicClassificationSolutionAnalyzer.cs

@@ -55 +55 @@
     private const string BestValidationQualityParameterName = "Best validation quality";
     private const string BestValidationSolutionParameterName = "Best validation solution";
-    private const string BestSolutionGenerationParameterName = "Best solution generation";
-    private const string BestSolutionInputvariableCountParameterName = "Variables used by best solution";
+    private const string BestSolutionAccuracyTrainingParameterName = "Best solution accuracy (training)";
+    private const string BestSolutionAccuracyTestParameterName = "Best solution accuracy (test)";
     private const string VariableFrequenciesParameterName = "VariableFrequencies";
-    private const string VariableImpactsParameterName = "Variable Impacts";
 
     #region parameter properties
@@ -111 +110 @@
       get { return (ILookupParameter<SymbolicClassificationSolution>)Parameters[BestValidationSolutionParameterName]; }
     }
-    public ILookupParameter<IntValue> BestSolutionGenerationParameter {
-      get { return (ILookupParameter<IntValue>)Parameters[BestSolutionGenerationParameterName]; }
-    }
-    public ILookupParameter<DoubleMatrix> VariableImpactsParameter {
-      get { return (ILookupParameter<DoubleMatrix>)Parameters[VariableImpactsParameterName]; }
-    }
-    public ILookupParameter<IntValue> BestSolutionInputvariableCountParameter {
-      get { return (ILookupParameter<IntValue>)Parameters[BestSolutionInputvariableCountParameterName]; }
+    public ILookupParameter<DoubleValue> BestSolutionAccuracyTrainingParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters[BestSolutionAccuracyTrainingParameterName]; }
+    }
+    public ILookupParameter<DoubleValue> BestSolutionAccuracyTestParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters[BestSolutionAccuracyTestParameterName]; }
     }
     #endregion
@@ -174 +170 @@
       protected set { BestValidationSolutionParameter.ActualValue = value; }
     }
-    public IntValue BestSolutionGeneration {
-      get { return BestSolutionGenerationParameter.ActualValue; }
-      protected set { BestSolutionGenerationParameter.ActualValue = value; }
-    }
-    public IntValue BestSolutionInputvariableCount {
-      get { return BestSolutionInputvariableCountParameter.ActualValue; }
-      protected set { BestSolutionInputvariableCountParameter.ActualValue = value; }
-    }
-    public DoubleMatrix VariableImpacts {
-      get { return VariableImpactsParameter.ActualValue; }
-      protected set { VariableImpactsParameter.ActualValue = value; }
+    public DoubleValue BestSolutionAccuracyTraining {
+      get { return BestSolutionAccuracyTrainingParameter.ActualValue; }
+      protected set { BestSolutionAccuracyTrainingParameter.ActualValue = value; }
+    }
+    public DoubleValue BestSolutionAccuracyTest {
+      get { return BestSolutionAccuracyTestParameter.ActualValue; }
+      protected set { BestSolutionAccuracyTestParameter.ActualValue = value; }
     }
     #endregion
@@ -208 +200 @@
       Parameters.Add(new LookupParameter<DoubleValue>(BestValidationQualityParameterName, "The validation quality of the best solution in the current run."));
       Parameters.Add(new LookupParameter<SymbolicClassificationSolution>(BestValidationSolutionParameterName, "The best solution on the validation data found in the current run."));
-      Parameters.Add(new LookupParameter<IntValue>(BestSolutionGenerationParameterName, "The generation in which the best solution was found."));
-      Parameters.Add(new LookupParameter<DoubleMatrix>(VariableImpactsParameterName, "The impacts of the input variables calculated during the run."));
-      Parameters.Add(new LookupParameter<IntValue>(BestSolutionInputvariableCountParameterName, "The number of input variables used by the best solution."));
-
+      Parameters.Add(new LookupParameter<DoubleValue>(BestSolutionAccuracyTrainingParameterName, "The training accuracy of the best solution."));
+      Parameters.Add(new LookupParameter<DoubleValue>(BestSolutionAccuracyTestParameterName, "The test accuracy of the best solution."));
     }
 
@@ -272 +262 @@
           BestValidationSolution.Description = "Best solution on validation partition found over the whole run.";
           BestValidationQuality = new DoubleValue(bestQuality);
-          BestSolutionGeneration = (IntValue)Generations.Clone();
-          BestSolutionInputvariableCount = new IntValue(BestValidationSolution.Model.InputVariables.Count());
-
-          Results.Add(new Result(BestValidationSolutionParameterName, BestValidationSolution));
-          Results.Add(new Result(BestValidationQualityParameterName, BestValidationQuality));
-          Results.Add(new Result(BestSolutionGenerationParameterName, BestSolutionGeneration));
-
-          Results.Add(new Result(BestSolutionInputvariableCountParameterName, BestSolutionInputvariableCount));
-
-          if (VariableFrequencies != null) {
-            VariableImpacts = CalculateVariableImpacts(VariableFrequencies);
-            Results.Add(new Result(VariableImpactsParameterName, VariableImpacts));
-          }
-
         } else {
           BestValidationSolution.Model = model;
-          BestValidationQuality.Value = bestQuality;
-          BestSolutionGeneration.Value = Generations.Value;
-          BestSolutionInputvariableCount.Value = BestValidationSolution.Model.InputVariables.Count();
-
-          if (VariableFrequencies != null) {
-            VariableImpacts = CalculateVariableImpacts(VariableFrequencies);
-            Results[VariableImpactsParameterName].Value = VariableImpacts;
-          }
         }
+
+        UpdateBestSolutionResults();
       }
       return base.Apply();
     }
 
-    private static DoubleMatrix CalculateVariableImpacts(DataTable variableFrequencies) {
-      if (variableFrequencies != null) {
-        var impacts = new DoubleMatrix(variableFrequencies.Rows.Count, 1, new string[] { "Impact" }, variableFrequencies.Rows.Select(x => x.Name));
-        impacts.SortableView = true;
-        int rowIndex = 0;
-        foreach (var dataRow in variableFrequencies.Rows) {
-          string variableName = dataRow.Name;
-          impacts[rowIndex++, 0] = dataRow.Values.Average();
-        }
-        return impacts;
-      } else return new DoubleMatrix(1, 1);
-    }
+    private void UpdateBestSolutionResults() {
+      BestSymbolicRegressionSolutionAnalyzer.UpdateBestSolutionResults(BestValidationSolution, ClassificationProblemData, Results, Generations, VariableFrequencies);
+
+      IEnumerable<double> trainingValues = ClassificationProblemData.Dataset.GetEnumeratedVariableValues(
+        ClassificationProblemData.TargetVariable.Value,
+        ClassificationProblemData.TrainingSamplesStart.Value,
+        ClassificationProblemData.TrainingSamplesEnd.Value);
+      IEnumerable<double> testValues = ClassificationProblemData.Dataset.GetEnumeratedVariableValues(
+        ClassificationProblemData.TargetVariable.Value,
+        ClassificationProblemData.TestSamplesStart.Value,
+        ClassificationProblemData.TestSamplesEnd.Value);
+
+      OnlineAccuracyEvaluator accuracyEvaluator = new OnlineAccuracyEvaluator();
+      var originalEnumerator = trainingValues.GetEnumerator();
+      var estimatedEnumerator = BestValidationSolution.EstimatedTrainingClassValues.GetEnumerator();
+      while (originalEnumerator.MoveNext() & estimatedEnumerator.MoveNext()) {
+        accuracyEvaluator.Add(originalEnumerator.Current, estimatedEnumerator.Current);
+      }
+      double trainingAccuracy = accuracyEvaluator.Accuracy;
+
+      accuracyEvaluator.Reset();
+      originalEnumerator = testValues.GetEnumerator();
+      estimatedEnumerator = BestValidationSolution.EstimatedTestClassValues.GetEnumerator();
+      while (originalEnumerator.MoveNext() & estimatedEnumerator.MoveNext()) {
+        accuracyEvaluator.Add(originalEnumerator.Current, estimatedEnumerator.Current);
+      }
+      double testAccuracy = accuracyEvaluator.Accuracy;
+
+      if (!Results.ContainsKey(BestSolutionAccuracyTrainingParameterName)) {
+        BestSolutionAccuracyTraining = new DoubleValue(trainingAccuracy);
+        BestSolutionAccuracyTest = new DoubleValue(testAccuracy);
+
+        Results.Add(new Result(BestSolutionAccuracyTrainingParameterName, BestSolutionAccuracyTraining));
+        Results.Add(new Result(BestSolutionAccuracyTestParameterName, BestSolutionAccuracyTest));
+      } else {
+        BestSolutionAccuracyTraining.Value = trainingAccuracy;
+        BestSolutionAccuracyTest.Value = testAccuracy;
+      }
+    }
+
   }
 }