source: branches/DatasetFeatureCorrelation/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/FeatureCorrelation.cs @ 8483

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2012 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.ComponentModel;
using System.Linq;
using HeuristicLab.Analysis;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.PluginInfrastructure;

namespace HeuristicLab.Problems.DataAnalysis {
  [StorableClass]
  [Item("FeatureCorrelation", "Represents the correlation of features in a data set.")]
  public class FeatureCorrelation : HeatMap {

    private const string PearsonsR = "Pearsons R";
    private const string PearsonsRSquared = "Pearsons R Squared";
    private const string HoeffdingsDependence = "Hoeffdings Dependence";
    private const string SpearmansRank = "Spearmans Rank";
    public IEnumerable<string> CorrelationCalculators {
      get { return new List<string>() { PearsonsR, PearsonsRSquared, HoeffdingsDependence, SpearmansRank }; }
    }

    private const string AllSamples = "All Samples";
    private const string TrainingSamples = "Training Samples";
    private const string TestSamples = "Test Samples";
    public IEnumerable<string> Partitions {
      get { return new List<string>() { AllSamples, TrainingSamples, TestSamples }; }
    }

    private IDataAnalysisProblemData problemData;
    public IDataAnalysisProblemData ProblemData {
      get { return problemData; }
      set {
        if (problemData != value) {
          problemData = value;
          columnNames = value.Dataset.DoubleVariables.ToList();
          rowNames = value.Dataset.DoubleVariables.ToList();
          OnProblemDataChanged();
        }
      }
    }

    private BackgroundWorker bw;

    public FeatureCorrelation()
      : base() {
      this.Title = "Feature Correlation";
      this.columnNames = Enumerable.Range(1, 2).Select(x => x.ToString()).ToList();
      this.rowNames = Enumerable.Range(1, 2).Select(x => x.ToString()).ToList();
      sortableView = true;
    }

    public FeatureCorrelation(IDataAnalysisProblemData problemData) {
      this.problemData = problemData;
      this.Title = "Feature Correlation";
      this.columnNames = problemData.Dataset.DoubleVariables.ToList();
      this.rowNames = problemData.Dataset.DoubleVariables.ToList();
      sortableView = true;

      CalculateElements(problemData.Dataset);
    }
    protected FeatureCorrelation(FeatureCorrelation original, Cloner cloner)
      : base(original, cloner) {
      this.Title = "Feature Correlation";
      this.problemData = original.problemData;
      this.columnNames = original.problemData.Dataset.DoubleVariables.ToList();
      this.rowNames = original.problemData.Dataset.DoubleVariables.ToList();
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new FeatureCorrelation(this, cloner);
    }

    public void Recalculate(string calc, string partition) {
      CalculateElements(problemData.Dataset, calc, partition);
    }

    private void CalculateElements(Dataset dataset) {
      CalculateElements(dataset, CorrelationCalculators.First(), Partitions.First());
    }

    private void CalculateElements(Dataset dataset, string calc, string partition) {
      if (bw == null || bw.IsBusy) {
        if (bw != null) {
          bw.CancelAsync();
        }
        bw = new BackgroundWorker();
        bw.WorkerReportsProgress = true;
        bw.WorkerSupportsCancellation = true;
        bw.DoWork += new DoWorkEventHandler(bw_DoWork);
        bw.ProgressChanged += new ProgressChangedEventHandler(bw_ProgressChanged);
        bw.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bw_RunWorkerCompleted);
      }
      bw.RunWorkerAsync(new BackgroundWorkerInfo { Dataset = dataset, Calculator = calc, Partition = partition });
      if (calc.Equals(PearsonsR) || calc.Equals(SpearmansRank)) {
        Maximum = 1.0;
        Minimum = -1.0;
      } else if (calc.Equals(HoeffdingsDependence)) {
        Maximum = 1.0;
        Minimum = -0.5;
      } else {
        Maximum = 1.0;
        Minimum = 0.0;
      }
    }

    private void bw_DoWork(object sender, DoWorkEventArgs e) {
      BackgroundWorker worker = sender as BackgroundWorker;

      BackgroundWorkerInfo bwInfo = (BackgroundWorkerInfo)e.Argument;
      Dataset dataset = bwInfo.Dataset;
      string partition = bwInfo.Partition;
      string calc = bwInfo.Calculator;

      IList<string> doubleVariableNames = dataset.DoubleVariables.ToList();
      OnlineCalculatorError error;
      int length = doubleVariableNames.Count;
      double[,] elements = new double[length, length];

      double calculations = (Math.Pow(length, 2) + length) / 2;

      worker.ReportProgress(0);

      for (int i = 0; i < length; i++) {
        for (int j = 0; j < i + 1; j++) {
          if (worker.CancellationPending) {
            e.Cancel = true;
            return;
          }

          IEnumerable<double> var1 = dataset.GetDoubleValues(doubleVariableNames[i]);
          IEnumerable<double> var2 = dataset.GetDoubleValues(doubleVariableNames[j]);
          if (partition.Equals(TrainingSamples)) {
            var1 = var1.Skip(problemData.TrainingPartition.Start).Take(problemData.TrainingPartition.End - problemData.TrainingPartition.Start);
            var2 = var2.Skip(problemData.TrainingPartition.Start).Take(problemData.TrainingPartition.End - problemData.TrainingPartition.Start);
          } else if (partition.Equals(TestSamples)) {
            var1 = var1.Skip(problemData.TestPartition.Start).Take(problemData.TestPartition.End - problemData.TestPartition.Start);
            var2 = var2.Skip(problemData.TestPartition.Start).Take(problemData.TestPartition.End - problemData.TestPartition.Start);
          }

          if (calc.Equals(HoeffdingsDependence)) {
            elements[i, j] = HoeffdingsDependenceCalculator.Calculate(var1, var2, out error);
          } else if (calc.Equals(SpearmansRank)) {
            elements[i, j] = SpearmansRankCorrelationCoefficientCalculator.Calculate(var1, var2, out error);
          } else if (calc.Equals(PearsonsRSquared)) {
            elements[i, j] = OnlinePearsonsRSquaredCalculator.Calculate(var1, var2, out error);
          } else {
            elements[i, j] = OnlinePearsonsRSquaredCalculator.CalculateR(var1, var2, out error);
          }
          elements[j, i] = elements[i, j];
          if (!error.Equals(OnlineCalculatorError.None)) {
            worker.ReportProgress(100);
            throw new ArgumentException("Calculator returned " + error + Environment.NewLine + "Maybe try another calculator.");
          }
          worker.ReportProgress((int)Math.Round((((Math.Pow(i, 2) + i) / 2 + j + 1.0) / calculations) * 100));
        }
      }
      e.Result = elements;
    }

    private void bw_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) {
      BackgroundWorker worker = sender as BackgroundWorker;
      if (!e.Cancelled && !worker.CancellationPending) {
        if (!(e.Error == null)) {
          ErrorHandling.ShowErrorDialog(e.Error);
        } else {
          matrix = (double[,])e.Result;
          OnReset();
        }
      }
    }

    #region events
    public delegate void ProgressCalculationHandler(object sender, ProgressChangedEventArgs e);
    public event ProgressCalculationHandler ProgressCalculation;
    protected void bw_ProgressChanged(object sender, ProgressChangedEventArgs e) {
      BackgroundWorker worker = sender as BackgroundWorker;
      if (!worker.CancellationPending && ProgressCalculation != null) {
        ProgressCalculation(sender, e);
      }
    }

    public event EventHandler ProblemDataChanged;
    protected virtual void OnProblemDataChanged() {
      EventHandler handler = ProblemDataChanged;
      if (handler != null)
        handler(this, EventArgs.Empty);
    }
    #endregion

    protected class BackgroundWorkerInfo {
      public Dataset Dataset { get; set; }
      public string Calculator { get; set; }
      public string Partition { get; set; }
    }
  }
}