Changeset 6618 for branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationSolution.cs

Timestamp:

08/01/11 17:48:53 (13 years ago)

Author:

mkommend

Message:

#1479: Integrated trunk changes.

File:

• branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationSolution.cs (modified) (2 diffs)

branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationSolution.cs

@@ -23 +23 @@
 using System.Linq;
 using HeuristicLab.Common;
-using HeuristicLab.Data;
-using HeuristicLab.Optimization;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
@@ -32 +30 @@
   /// </summary>
   [StorableClass]
-  public class ClassificationSolution : DataAnalysisSolution, IClassificationSolution {
-    private const string TrainingAccuracyResultName = "Accuracy (training)";
-    private const string TestAccuracyResultName = "Accuracy (test)";
-
-    public new IClassificationModel Model {
-      get { return (IClassificationModel)base.Model; }
-      protected set { base.Model = value; }
-    }
-
-    public new IClassificationProblemData ProblemData {
-      get { return (IClassificationProblemData)base.ProblemData; }
-      protected set { base.ProblemData = value; }
-    }
-
-    public double TrainingAccuracy {
-      get { return ((DoubleValue)this[TrainingAccuracyResultName].Value).Value; }
-      private set { ((DoubleValue)this[TrainingAccuracyResultName].Value).Value = value; }
-    }
-
-    public double TestAccuracy {
-      get { return ((DoubleValue)this[TestAccuracyResultName].Value).Value; }
-      private set { ((DoubleValue)this[TestAccuracyResultName].Value).Value = value; }
-    }
+  public abstract class ClassificationSolution : ClassificationSolutionBase {
+    protected readonly Dictionary<int, double> evaluationCache;
 
     [StorableConstructor]
-    protected ClassificationSolution(bool deserializing) : base(deserializing) { }
+    protected ClassificationSolution(bool deserializing)
+      : base(deserializing) {
+      evaluationCache = new Dictionary<int, double>();
+    }
     protected ClassificationSolution(ClassificationSolution original, Cloner cloner)
       : base(original, cloner) {
+      evaluationCache = new Dictionary<int, double>(original.evaluationCache);
     }
     public ClassificationSolution(IClassificationModel model, IClassificationProblemData problemData)
       : base(model, problemData) {
-      Add(new Result(TrainingAccuracyResultName, "Accuracy of the model on the training partition (percentage of correctly classified instances).", new PercentValue()));
-      Add(new Result(TestAccuracyResultName, "Accuracy of the model on the test partition (percentage of correctly classified instances).", new PercentValue()));
-      CalculateResults();
+      evaluationCache = new Dictionary<int, double>();
     }
 
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new ClassificationSolution(this, cloner);
+    public override IEnumerable<double> EstimatedClassValues {
+      get { return GetEstimatedClassValues(Enumerable.Range(0, ProblemData.Dataset.Rows)); }
+    }
+    public override IEnumerable<double> EstimatedTrainingClassValues {
+      get { return GetEstimatedClassValues(ProblemData.TrainingIndizes); }
+    }
+    public override IEnumerable<double> EstimatedTestClassValues {
+      get { return GetEstimatedClassValues(ProblemData.TestIndizes); }
     }
 
-    protected override void RecalculateResults() {
-      CalculateResults();
+    public override IEnumerable<double> GetEstimatedClassValues(IEnumerable<int> rows) {
+      var rowsToEvaluate = rows.Except(evaluationCache.Keys);
+      var rowsEnumerator = rowsToEvaluate.GetEnumerator();
+      var valuesEnumerator = Model.GetEstimatedClassValues(ProblemData.Dataset, rowsToEvaluate).GetEnumerator();
+
+      while (rowsEnumerator.MoveNext() & valuesEnumerator.MoveNext()) {
+        evaluationCache.Add(rowsEnumerator.Current, valuesEnumerator.Current);
+      }
+
+      return rows.Select(row => evaluationCache[row]);
     }
 
-    private void CalculateResults() {
-      double[] estimatedTrainingClassValues = EstimatedTrainingClassValues.ToArray(); // cache values
-      IEnumerable<double> originalTrainingClassValues = ProblemData.Dataset.GetEnumeratedVariableValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes);
-      double[] estimatedTestClassValues = EstimatedTestClassValues.ToArray(); // cache values
-      IEnumerable<double> originalTestClassValues = ProblemData.Dataset.GetEnumeratedVariableValues(ProblemData.TargetVariable, ProblemData.TestIndizes);
-
-      OnlineCalculatorError errorState;
-      double trainingAccuracy = OnlineAccuracyCalculator.Calculate(estimatedTrainingClassValues, originalTrainingClassValues, out errorState);
-      if (errorState != OnlineCalculatorError.None) trainingAccuracy = double.NaN;
-      double testAccuracy = OnlineAccuracyCalculator.Calculate(estimatedTestClassValues, originalTestClassValues, out errorState);
-      if (errorState != OnlineCalculatorError.None) testAccuracy = double.NaN;
-
-      TrainingAccuracy = trainingAccuracy;
-      TestAccuracy = testAccuracy;
+    protected override void OnProblemDataChanged() {
+      evaluationCache.Clear();
+      base.OnProblemDataChanged();
     }
 
-    public virtual IEnumerable<double> EstimatedClassValues {
-      get {
-        return GetEstimatedClassValues(Enumerable.Range(0, ProblemData.Dataset.Rows));
-      }
-    }
-
-    public virtual IEnumerable<double> EstimatedTrainingClassValues {
-      get {
-        return GetEstimatedClassValues(ProblemData.TrainingIndizes);
-      }
-    }
-
-    public virtual IEnumerable<double> EstimatedTestClassValues {
-      get {
-        return GetEstimatedClassValues(ProblemData.TestIndizes);
-      }
-    }
-
-    public virtual IEnumerable<double> GetEstimatedClassValues(IEnumerable<int> rows) {
-      return Model.GetEstimatedClassValues(ProblemData.Dataset, rows);
+    protected override void OnModelChanged() {
+      evaluationCache.Clear();
+      base.OnModelChanged();
     }
   }