Free cookie consent management tool by TermsFeed Policy Generator

source: trunk/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationSolutionBase.cs @ 16788

Last change on this file since 16788 was 16565, checked in by gkronber, 6 years ago

#2520: merged changes from PersistenceOverhaul branch (r16451:16564) into trunk

File size: 10.4 KB
RevLine 
[6589]1#region License Information
2/* HeuristicLab
[16565]3 * Copyright (C) 2002-2019 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
[6589]4 *
5 * This file is part of HeuristicLab.
6 *
7 * HeuristicLab is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * HeuristicLab is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
19 */
20#endregion
21
[16244]22using System;
[6589]23using System.Collections.Generic;
24using System.Linq;
25using HeuristicLab.Common;
26using HeuristicLab.Data;
27using HeuristicLab.Optimization;
[16565]28using HEAL.Attic;
[13100]29using HeuristicLab.Problems.DataAnalysis.OnlineCalculators;
[6589]30
31namespace HeuristicLab.Problems.DataAnalysis {
[16565]32  [StorableType("60599497-EAF0-4DB0-B2E4-D58F34458D8F")]
[6589]33  public abstract class ClassificationSolutionBase : DataAnalysisSolution, IClassificationSolution {
34    private const string TrainingAccuracyResultName = "Accuracy (training)";
35    private const string TestAccuracyResultName = "Accuracy (test)";
[6913]36    private const string TrainingNormalizedGiniCoefficientResultName = "Normalized Gini Coefficient (training)";
37    private const string TestNormalizedGiniCoefficientResultName = "Normalized Gini Coefficient (test)";
[11763]38    private const string ClassificationPerformanceMeasuresResultName = "Classification Performance Measures";
[6589]39
40    public new IClassificationModel Model {
41      get { return (IClassificationModel)base.Model; }
42      protected set { base.Model = value; }
43    }
44
45    public new IClassificationProblemData ProblemData {
46      get { return (IClassificationProblemData)base.ProblemData; }
[16244]47      set {
48        if (value == null) throw new ArgumentNullException("The problemData must not be null.");
49        string errorMessage = string.Empty;
50        if (!Model.IsProblemDataCompatible(value, out errorMessage)) throw new ArgumentException(errorMessage);
51
52        base.ProblemData = value;
53      }
[6589]54    }
55
56    #region Results
57    public double TrainingAccuracy {
58      get { return ((DoubleValue)this[TrainingAccuracyResultName].Value).Value; }
59      private set { ((DoubleValue)this[TrainingAccuracyResultName].Value).Value = value; }
60    }
61    public double TestAccuracy {
62      get { return ((DoubleValue)this[TestAccuracyResultName].Value).Value; }
63      private set { ((DoubleValue)this[TestAccuracyResultName].Value).Value = value; }
64    }
[6913]65    public double TrainingNormalizedGiniCoefficient {
66      get { return ((DoubleValue)this[TrainingNormalizedGiniCoefficientResultName].Value).Value; }
67      protected set { ((DoubleValue)this[TrainingNormalizedGiniCoefficientResultName].Value).Value = value; }
68    }
69    public double TestNormalizedGiniCoefficient {
70      get { return ((DoubleValue)this[TestNormalizedGiniCoefficientResultName].Value).Value; }
71      protected set { ((DoubleValue)this[TestNormalizedGiniCoefficientResultName].Value).Value = value; }
72    }
[11763]73    public ClassificationPerformanceMeasuresResultCollection ClassificationPerformanceMeasures {
74      get { return ((ClassificationPerformanceMeasuresResultCollection)this[ClassificationPerformanceMeasuresResultName].Value); }
75      protected set { (this[ClassificationPerformanceMeasuresResultName].Value) = value; }
76    }
[6589]77    #endregion
78
79    [StorableConstructor]
[16565]80    protected ClassificationSolutionBase(StorableConstructorFlag _) : base(_) { }
[6589]81    protected ClassificationSolutionBase(ClassificationSolutionBase original, Cloner cloner)
82      : base(original, cloner) {
83    }
84    protected ClassificationSolutionBase(IClassificationModel model, IClassificationProblemData problemData)
85      : base(model, problemData) {
86      Add(new Result(TrainingAccuracyResultName, "Accuracy of the model on the training partition (percentage of correctly classified instances).", new PercentValue()));
87      Add(new Result(TestAccuracyResultName, "Accuracy of the model on the test partition (percentage of correctly classified instances).", new PercentValue()));
[6913]88      Add(new Result(TrainingNormalizedGiniCoefficientResultName, "Normalized Gini coefficient of the model on the training partition.", new DoubleValue()));
89      Add(new Result(TestNormalizedGiniCoefficientResultName, "Normalized Gini coefficient of the model on the test partition.", new DoubleValue()));
[11763]90      Add(new Result(ClassificationPerformanceMeasuresResultName, @"Classification performance measures.\n
91                              In a multiclass classification all misclassifications of the negative class will be treated as true negatives except on positive class estimations.",
92                            new ClassificationPerformanceMeasuresResultCollection()));
[6589]93    }
94
[7011]95    [StorableHook(HookType.AfterDeserialization)]
96    private void AfterDeserialization() {
[14290]97      if (string.IsNullOrEmpty(Model.TargetVariable))
98        Model.TargetVariable = this.ProblemData.TargetVariable;
99
[7011]100      if (!this.ContainsKey(TrainingNormalizedGiniCoefficientResultName))
101        Add(new Result(TrainingNormalizedGiniCoefficientResultName, "Normalized Gini coefficient of the model on the training partition.", new DoubleValue()));
102      if (!this.ContainsKey(TestNormalizedGiniCoefficientResultName))
103        Add(new Result(TestNormalizedGiniCoefficientResultName, "Normalized Gini coefficient of the model on the test partition.", new DoubleValue()));
[11763]104      if (!this.ContainsKey(ClassificationPerformanceMeasuresResultName)) {
105        Add(new Result(ClassificationPerformanceMeasuresResultName, @"Classification performance measures.\n
106                              In a multiclass classification all misclassifications of the negative class will be treated as true negatives except on positive class estimations.",
107                              new ClassificationPerformanceMeasuresResultCollection()));
[11766]108        CalculateClassificationResults();
[11763]109      }
[7011]110    }
111
[8723]112    protected void CalculateClassificationResults() {
[6589]113      double[] estimatedTrainingClassValues = EstimatedTrainingClassValues.ToArray(); // cache values
[8139]114      double[] originalTrainingClassValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndices).ToArray();
[11763]115
[6589]116      double[] estimatedTestClassValues = EstimatedTestClassValues.ToArray(); // cache values
[8139]117      double[] originalTestClassValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TestIndices).ToArray();
[6589]118
[11766]119      var positiveClassName = ProblemData.PositiveClass;
[11763]120      double positiveClassValue = ProblemData.GetClassValue(positiveClassName);
121      ClassificationPerformanceMeasuresCalculator trainingPerformanceCalculator = new ClassificationPerformanceMeasuresCalculator(positiveClassName, positiveClassValue);
122      ClassificationPerformanceMeasuresCalculator testPerformanceCalculator = new ClassificationPerformanceMeasuresCalculator(positiveClassName, positiveClassValue);
123
[6589]124      OnlineCalculatorError errorState;
[6961]125      double trainingAccuracy = OnlineAccuracyCalculator.Calculate(originalTrainingClassValues, estimatedTrainingClassValues, out errorState);
[6589]126      if (errorState != OnlineCalculatorError.None) trainingAccuracy = double.NaN;
[6961]127      double testAccuracy = OnlineAccuracyCalculator.Calculate(originalTestClassValues, estimatedTestClassValues, out errorState);
[6589]128      if (errorState != OnlineCalculatorError.None) testAccuracy = double.NaN;
129
130      TrainingAccuracy = trainingAccuracy;
131      TestAccuracy = testAccuracy;
[6913]132
133      double trainingNormalizedGini = NormalizedGiniCalculator.Calculate(originalTrainingClassValues, estimatedTrainingClassValues, out errorState);
134      if (errorState != OnlineCalculatorError.None) trainingNormalizedGini = double.NaN;
135      double testNormalizedGini = NormalizedGiniCalculator.Calculate(originalTestClassValues, estimatedTestClassValues, out errorState);
136      if (errorState != OnlineCalculatorError.None) testNormalizedGini = double.NaN;
137
138      TrainingNormalizedGiniCoefficient = trainingNormalizedGini;
139      TestNormalizedGiniCoefficient = testNormalizedGini;
[11763]140
[13801]141      ClassificationPerformanceMeasures.Reset();
142
[11763]143      trainingPerformanceCalculator.Calculate(originalTrainingClassValues, estimatedTrainingClassValues);
144      if (trainingPerformanceCalculator.ErrorState == OnlineCalculatorError.None)
145        ClassificationPerformanceMeasures.SetTrainingResults(trainingPerformanceCalculator);
146
147      testPerformanceCalculator.Calculate(originalTestClassValues, estimatedTestClassValues);
148      if (testPerformanceCalculator.ErrorState == OnlineCalculatorError.None)
149        ClassificationPerformanceMeasures.SetTestResults(testPerformanceCalculator);
[13100]150
[13102]151      if (ProblemData.Classes == 2) {
152        var f1Training = FOneScoreCalculator.Calculate(originalTrainingClassValues, estimatedTrainingClassValues, out errorState);
153        if (errorState == OnlineCalculatorError.None) ClassificationPerformanceMeasures.TrainingF1Score = f1Training;
154        var f1Test = FOneScoreCalculator.Calculate(originalTestClassValues, estimatedTestClassValues, out errorState);
155        if (errorState == OnlineCalculatorError.None) ClassificationPerformanceMeasures.TestF1Score = f1Test;
156      }
[13100]157
158      var mccTraining = MatthewsCorrelationCoefficientCalculator.Calculate(originalTrainingClassValues, estimatedTrainingClassValues, out errorState);
159      if (errorState == OnlineCalculatorError.None) ClassificationPerformanceMeasures.TrainingMatthewsCorrelation = mccTraining;
160      var mccTest = MatthewsCorrelationCoefficientCalculator.Calculate(originalTestClassValues, estimatedTestClassValues, out errorState);
161      if (errorState == OnlineCalculatorError.None) ClassificationPerformanceMeasures.TestMatthewsCorrelation = mccTest;
[6589]162    }
163
164    public abstract IEnumerable<double> EstimatedClassValues { get; }
165    public abstract IEnumerable<double> EstimatedTrainingClassValues { get; }
166    public abstract IEnumerable<double> EstimatedTestClassValues { get; }
167
168    public abstract IEnumerable<double> GetEstimatedClassValues(IEnumerable<int> rows);
[8723]169
170    protected override void RecalculateResults() {
171      CalculateClassificationResults();
172    }
[6589]173  }
174}
Note: See TracBrowser for help on using the repository browser.