source: branches/HeuristicLab.Classification/HeuristicLab.Problems.DataAnalysis.Classification/3.3/Symbolic/SymbolicClassificationSolution.cs @ 4366

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Problems.DataAnalysis.Regression.Symbolic;

namespace HeuristicLab.Problems.DataAnalysis.Classification {
  /// <summary>
  /// Represents a solution for a symbolic regression problem which can be visualized in the GUI.
  /// </summary>
  [Item("SymbolicClassificationSolution", "Represents a solution for a symbolic classification problem which can be visualized in the GUI.")]
  [StorableClass]
  public sealed class SymbolicClassificationSolution : DataAnalysisSolution, IClassificationSolution {
    private SymbolicClassificationSolution() : base() { }
    public SymbolicClassificationSolution(ClassificationProblemData 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; }
    }

    public new ClassificationProblemData ProblemData {
      get { return (ClassificationProblemData)base.ProblemData; }
      set { base.ProblemData = value; }
    }

    public new SymbolicRegressionModel Model {
      get { return (SymbolicRegressionModel)base.Model; }
      set { base.Model = value; }
    }

    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();
      RecalculateClassIntermediates();
      OnEstimatedValuesChanged();
    }

    private void RecalculateClassIntermediates() {
      int slices = 1000;

      List<KeyValuePair<double, double>> estimatedTargetValues =
        (from row in Enumerable.Range(ProblemData.TrainingSamplesStart.Value, ProblemData.TrainingSamplesEnd.Value - ProblemData.TrainingSamplesStart.Value)
         select new KeyValuePair<double, double>(
           estimatedValues[row],
           ProblemData.Dataset[ProblemData.TargetVariable.Value, row])).ToList();

      List<double> originalClasses = ProblemData.Dataset.GetVariableValues(ProblemData.TargetVariable.Value).Distinct().OrderBy(x => x).ToList();
      int numberOfClasses = originalClasses.Count;

      double[] thresholds = new double[numberOfClasses + 1];
      thresholds[0] = double.NegativeInfinity;
      thresholds[thresholds.Length - 1] = double.PositiveInfinity;


      for (int i = 1; i < thresholds.Length - 1; i++) {
        double lowerThreshold = thresholds[i - 1];
        double actualThreshold = originalClasses[i - 1];
        double thresholdIncrement = (originalClasses[i] - originalClasses[i - 1]) / slices;

        double bestThreshold = double.NaN;
        double bestQuality = double.NegativeInfinity;

        while (actualThreshold < originalClasses[i]) {
          int truePosivites = 0;
          int falsePosivites = 0;
          int trueNegatives = 0;
          int falseNegatives = 0;

          foreach (KeyValuePair<double, double> estimatedTarget in estimatedTargetValues) {
            //all positives
            if (estimatedTarget.Value.IsAlmost(originalClasses[i - 1])) {
              if (estimatedTarget.Key > lowerThreshold && estimatedTarget.Key < actualThreshold)
                truePosivites++;
              else
                falseNegatives++;
            }
              //all negatives
            else {
              if (estimatedTarget.Key > lowerThreshold && estimatedTarget.Key < actualThreshold)
                falsePosivites++;
              else
                trueNegatives++;
            }
          }

          //mkommend 30.08.2010
          //matthews correlation coefficient taken from http://en.wikipedia.org/wiki/Matthews_correlation_coefficient
          //MCC = [(TP * FP) - (FP * FN)] / sqrt((TP + FP) * (TP + FN) * (TN + FP) * (TN + FN))
          double dividend = truePosivites * falsePosivites - falsePosivites * falseNegatives;
          double divisor = Math.Sqrt((truePosivites + falsePosivites) * (truePosivites + falsePosivites) *
            (trueNegatives + falsePosivites) * (trueNegatives + falseNegatives));
          if (divisor == 0)
            divisor = 1;

          double mcc = dividend / divisor;

          if (bestQuality < mcc) {
            bestQuality = mcc;
            bestThreshold = actualThreshold;
          }
          actualThreshold += thresholdIncrement;
        }
        thresholds[i] = bestThreshold;
      }
      this.optimalThresholds = new List<double>(thresholds);
      this.actualThresholds = optimalThresholds;
    }

    #region properties
    private List<double> optimalThresholds;
    private List<double> actualThresholds;
    public IEnumerable<double> Thresholds {
      get {
        if (actualThresholds == null) RecalculateEstimatedValues();
        return actualThresholds;
      }
      set {
        if (actualThresholds != null && actualThresholds.SequenceEqual(value))
          return;
        actualThresholds = new List<double>(value);
        OnThresholdsChanged();
      }
    }

    private List<double> estimatedValues;
    public override IEnumerable<double> EstimatedValues {
      get {
        if (estimatedValues == null) RecalculateEstimatedValues();
        return estimatedValues.AsEnumerable();
      }
    }

    public IEnumerable<double> EstimatedClassValues {
      get {
        double[] classValues = ProblemData.SortedClassValues.ToArray();
        foreach (double value in EstimatedValues) {
          int classIndex = 0;
          while (value > actualThresholds[classIndex + 1])
            classIndex++;
          yield return classValues[classIndex];
        }
      }
    }

    public override IEnumerable<double> EstimatedTrainingValues {
      get {
        if (estimatedValues == null) RecalculateEstimatedValues();
        int start = ProblemData.TrainingSamplesStart.Value;
        int n = ProblemData.TrainingSamplesEnd.Value - start;
        return estimatedValues.Skip(start).Take(n).ToList();
      }
    }
    public IEnumerable<double> EstimatedTrainingClassValues {
      get {
        int start = ProblemData.TrainingSamplesStart.Value;
        int n = ProblemData.TrainingSamplesEnd.Value - start;
        return EstimatedClassValues.Skip(start).Take(n).ToList();
      }
    }

    public override IEnumerable<double> EstimatedTestValues {
      get {
        if (estimatedValues == null) RecalculateEstimatedValues();
        int start = ProblemData.TestSamplesStart.Value;
        int n = ProblemData.TestSamplesEnd.Value - start;
        return estimatedValues.Skip(start).Take(n).ToList();
      }
    }
    public IEnumerable<double> EstimatedTestClassValues {
      get {
        int start = ProblemData.TestSamplesStart.Value;
        int n = ProblemData.TestSamplesEnd.Value - start;
        return EstimatedClassValues.Skip(start).Take(n).ToList();
      }
    }
    #endregion

    public event EventHandler ThresholdsChanged;
    private void OnThresholdsChanged() {
      var handler = ThresholdsChanged;
      if (handler != null)
        ThresholdsChanged(this, EventArgs.Empty);
    }
  }
}