source: branches/HeuristicLab.VariableInteractionNetworks/HeuristicLab.VariableInteractionNetworks.Views/3.3/VariableInteractionNetworkView.cs @ 12230

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2015 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.Drawing;
using System.Linq;
using System.Windows.Forms;
using HeuristicLab.Common;
using HeuristicLab.Data;
using HeuristicLab.MainForm;
using HeuristicLab.MainForm.WindowsForms;
using HeuristicLab.Optimization;
using HeuristicLab.Problems.DataAnalysis;
using HeuristicLab.Problems.DataAnalysis.Symbolic;
using HeuristicLab.Problems.DataAnalysis.Symbolic.Regression;
using System.Collections;

namespace HeuristicLab.VariableInteractionNetworks.Views {
  [View("Variable Interaction Network")]
  [Content(typeof(RunCollection), IsDefaultView = false)]

  public sealed partial class VariableInteractionNetworkView : AsynchronousContentView {
    private const string variableImpactResultName = "Variable impacts";
    public new RunCollection Content {
      get { return (RunCollection)base.Content; }
      set { base.Content = value; }
    }

    public VariableInteractionNetworkView() {
      InitializeComponent();
    }

    #region events
    
  //  #region Event Handlers (Content)
    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
        CalculateAdjacencyMatrix();
      }
    }
    #endregion

    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 CalculateAdjacencyMatrix()
    {
        var runCollection = Content;
        var groupRunCollection = Content.GroupBy(x => ((IRegressionProblemData)x.Parameters["ProblemData"]).TargetVariable).ToList();

        var allVariableImpacts = runCollection.Select(run => (DoubleMatrix)run.Results[variableImpactResultName]);
        var variableNames = (from variableImpact in allVariableImpacts
                             from variableName in variableImpact.RowNames
                             select variableName).Distinct().ToArray();

        var adjMatrix = new DoubleMatrix(variableNames.Length, variableNames.Length);
        var adjRow = groupRunCollection.Select(x => CalculateAdjacencyRows(x)).ToList();
        var targets = groupRunCollection.Select(x => x.Key);

        adjMatrix.RowNames = targets;
        adjMatrix.ColumnNames = adjMatrix.RowNames;

        for (int j = 0; j < groupRunCollection.Count; ++j) 
        {
            var g = groupRunCollection[j];
            var matrix = CalculateAdjacencyRows(g);
            var variables = new List<Tuple<string, double>>();
            var columnNames = matrix.ColumnNames.ToList();
            
            for (int i = 0; i < matrix.Columns; ++i)
            {
                variables.Add(new Tuple<string, double>(columnNames[i], matrix[0, i]));
            }
            variables.Add(new Tuple<string, double>(g.Key, 0));
            variables.Sort((a, b) => a.Item1.CompareTo(b.Item1));
            for (int i = 0; i < variables.Count; ++i)
            {
                adjMatrix[j, i] = variables[i].Item2;
            }
        }
        viewHost1.Content = adjMatrix;
    }

    private DoubleMatrix CalculateAdjacencyRows(IEnumerable<IRun> runs)
    {
        IEnumerable<DoubleMatrix> allVariableImpacts = (from run in runs
                                                      select run.Results[variableImpactResultName]).Cast<DoubleMatrix>();
        var variableNames = (from variableImpact in allVariableImpacts
                                           from variableName in variableImpact.RowNames
                                           select variableName)
                                          .Distinct().ToArray();
       
        List<string> variableNamesList = (from variableName in variableNames
                                          where GetVariableImpacts(variableName, allVariableImpacts).Any(x => !x.IsAlmost(0.0))
                                          select variableName)
                                         .ToList();

        var inputVariables = runs.Select(x => ((IRegressionProblemData)x.Parameters["ProblemData"]).InputVariables).ToArray();     
        var runNames = runs.Select(x => x.Name).ToArray();
        var runsArray = runs.ToArray();
        DoubleMatrix varImpactMatrix = CalculateVariableImpactMatrix(runsArray, runNames);
        var targetMatrix = new DoubleMatrix(1, variableNames.Length);

        for (int i = 0; i < varImpactMatrix.Rows; ++i)
        {
            targetMatrix[0, i] = varImpactMatrix[i, runNames.Length];
        }
   
        targetMatrix.RowNames = new[] { "Target" };
        targetMatrix.ColumnNames = variableNames;

        return targetMatrix;
    }

    //taken from RunCollectionVariableImpactView
    private IEnumerable<double> GetVariableImpacts(string variableName, IEnumerable<DoubleMatrix> allVariableImpacts)
    {
        foreach (DoubleMatrix runVariableImpacts in allVariableImpacts)
        {
            int row = 0;
            foreach (string rowName in runVariableImpacts.RowNames)
            {
                if (rowName == variableName)
                    yield return runVariableImpacts[row, 0];
                row++;
            }
        }
    }

    //adapted from RunCollectionVariableImpactView
    private DoubleMatrix CalculateVariableImpactMatrix(IRun[] runs, string[] runNames)
    {
        IEnumerable<DoubleMatrix> allVariableImpacts = (from run in runs
                                                        select run.Results[variableImpactResultName]).Cast<DoubleMatrix>();
        IEnumerable<string> variableNames = (from variableImpact in allVariableImpacts
                                             from variableName in variableImpact.RowNames
                                             select variableName).Distinct();

        // filter variableNames: only include names that have at least one non-zero value in a run
        List<string> variableNamesList = (from variableName in variableNames
                                          where GetVariableImpacts(variableName, allVariableImpacts).Any(x => !x.IsAlmost(0.0))
                                          select variableName).ToList();

        List<string> columnNames = new List<string>(runNames);
        columnNames.Add("Mean");
      
        int numberOfRuns = runs.Length;

        DoubleMatrix matrix = new DoubleMatrix(variableNamesList.Count, numberOfRuns + 1);
        matrix.SortableView = true;
        matrix.ColumnNames = columnNames;

        List<List<double>> variableImpactsOverRuns = (from variableName in variableNamesList
                                                      select GetVariableImpacts(variableName, allVariableImpacts).ToList()).ToList();

        for (int row = 0; row < variableImpactsOverRuns.Count; row++)
        {
            matrix[row, numberOfRuns] = Math.Round(variableImpactsOverRuns[row].Average(), 3);
        }

        // fill matrix with impacts from runs
        for (int i = 0; i < runs.Length; i++)
        {
            IRun run = runs[i];
            DoubleMatrix runVariableImpacts = (DoubleMatrix)run.Results[variableImpactResultName];
            for (int j = 0; j < runVariableImpacts.Rows; j++)
            {
                int rowIndex = variableNamesList.FindIndex(s => s == runVariableImpacts.RowNames.ElementAt(j));
                if (rowIndex > -1)
                {
                    matrix[rowIndex, i] = Math.Round(runVariableImpacts[j, 0], 3);
                }
            }
        }
        return matrix;
    }
  }
}