source: branches/Sliding Window GP/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/SlidingWindowBestSolutionsCollectionView.cs @ 10402

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2014 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.Linq;
using System.Windows.Forms;
using HeuristicLab.Core.Views;
using HeuristicLab.Data;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
using HeuristicLab.MainForm;
using HeuristicLab.Optimization;
using HeuristicLab.Optimization.Views;

namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Views {
  [View("Sliding Window Best Solutions View")]
  [Content(typeof(SlidingWindowBestSolutionsCollection), true)]
  public partial class SlidingWindowBestSolutionsCollectionView : ItemView {
    public new SlidingWindowBestSolutionsCollection Content {
      get { return (SlidingWindowBestSolutionsCollection)base.Content; }
      set { base.Content = value; }
    }
    public SlidingWindowBestSolutionsCollectionView() {
      InitializeComponent();

      qualityMeasure = (int)QualityMeasures.PEARSON;
    }

    enum QualityMeasures { PEARSON, MSE };

    private int qualityMeasure;

    protected override void DeregisterContentEvents() {
      // TODO: Deregister your event handlers here
      enhancedStringConvertibleMatrixView.DataGridView.CellDoubleClick -= enhancedStringConvertibleMatrixView_cellDoubleClick;
      base.DeregisterContentEvents();
    }

    protected override void RegisterContentEvents() {
      base.RegisterContentEvents();
      enhancedStringConvertibleMatrixView.DataGridView.CellDoubleClick += enhancedStringConvertibleMatrixView_cellDoubleClick;
      // TODO: Register your event handlers here
    }

    public void enhancedStringConvertibleMatrixView_cellDoubleClick(object sender, DataGridViewCellEventArgs e) {
      var dataGridView = (DataGridView)sender;
      var cell = dataGridView.SelectedCells[0];
      var bestSolutions = Content.BestSolutions.ToList();
      var tree = bestSolutions[cell.RowIndex];
      var model = Content.CreateModel(tree, Content.Interpreter);
      var solution = Content.CreateSolution(model, Content.ProblemData);
      var result = new Result("Sliding Window Solution", solution);
      var view = MainFormManager.MainForm.ShowContent(result, typeof(ResultView));
      if (view != null) {
        view.ReadOnly = ReadOnly;
        view.Locked = Locked;
      }
    }

    #region Event Handlers (Content)
    // TODO: Put event handlers of the content here
    #endregion

    protected override void OnContentChanged() {
      base.OnContentChanged();
      if (Content == null) {
        // TODO: Add code when content has been changed and is null
      } else {
        // TODO: Add code when content has been changed and is not null
        UpdateQualitiesMap();
      }
    }

    protected override void SetEnabledStateOfControls() {
      base.SetEnabledStateOfControls();
      // TODO: Enable or disable controls based on whether the content is null or the view is set readonly
    }

    #region Event Handlers (child controls)
    // TODO: Put event handlers of child controls here.
    #endregion

    private void comboBox1_SelectedIndexChanged(object sender, System.EventArgs e) {
      var combobox = (ComboBox)sender;
      switch ((string)combobox.SelectedItem) {
        case "Pearson R2": {
            qualityMeasure = (int)QualityMeasures.PEARSON;
            break;
          }
        case "Mean Squared Error": {
            qualityMeasure = (int)QualityMeasures.MSE;
            break;
          }
      }
      UpdateQualitiesMap();
    }

    private void UpdateQualitiesMap() {
      var bestSolutions = Content.BestSolutions.ToList();
      var swPositions = Content.SlidingWindowPositions.ToList();
      var qualitiesMap = new DoubleMatrix(bestSolutions.Count, swPositions.Count + 1);
      qualitiesMap.ColumnNames = Content.SlidingWindowPositions.Select(x => x.Start + "-" + x.End).Concat(new List<string> { "Training" });
      qualitiesMap.RowNames = Enumerable.Range(1, bestSolutions.Count).Select(x => "M" + x);
      double min = 0, max = 0;

      for (int i = 0; i < qualitiesMap.Columns - 1; ++i) {
        var pos = swPositions[i];
        var rows = Enumerable.Range(pos.Start, pos.End - pos.Start).ToList();

        for (int j = 0; j < qualitiesMap.Rows; ++j) {
          var tree = bestSolutions[j];
          var q = CalculateQuality(tree, rows);
          if (min > q) min = q;
          if (max < q) max = q;
          qualitiesMap[j, i] = q;
        }
      }
      // deal separately with the last column which represents the whole training partition interval
      for (int j = 0; j < qualitiesMap.Rows; ++j) {
        var tree = bestSolutions[j];
        var q = CalculateQuality(tree, Content.ProblemData.TrainingIndices);
        if (min > q) min = q;
        if (max < q) max = q;
        qualitiesMap[j, qualitiesMap.Columns - 1] = q;
      }

      enhancedStringConvertibleMatrixView.Minimum = min;
      enhancedStringConvertibleMatrixView.Maximum = max;
      enhancedStringConvertibleMatrixView.Content = qualitiesMap;
    }

    private string GetTargetVariable(IDataAnalysisProblemData problemData) {
      var regressionProblemData = problemData as IRegressionProblemData;
      var classificationProblemData = problemData as IClassificationProblemData;
      if (regressionProblemData != null) return regressionProblemData.TargetVariable;
      if (classificationProblemData != null) return classificationProblemData.TargetVariable;
      throw new NotSupportedException();
    }

    private double CalculateQuality(ISymbolicExpressionTree tree, IEnumerable<int> rows) {
      var estimatedValues = Content.Interpreter.GetSymbolicExpressionTreeValues(tree, Content.ProblemData.Dataset, rows);
      var originalValues = Content.ProblemData.Dataset.GetDoubleValues(GetTargetVariable(Content.ProblemData), rows);
      double quality = 0;
      var errorState = new OnlineCalculatorError();
      switch ((QualityMeasures)qualityMeasure) {
        case QualityMeasures.PEARSON:
          quality = OnlinePearsonsRSquaredCalculator.Calculate(estimatedValues, originalValues, out errorState);
          break;
        case QualityMeasures.MSE:
          quality = OnlineMeanSquaredErrorCalculator.Calculate(estimatedValues, originalValues, out errorState);
          break;
      }
      return errorState == OnlineCalculatorError.None ? quality : double.NaN;
    }
  }
}