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

#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";
    private const string TrainingBestSolutionParameterName = "Best training solution";
    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);

        adjMatrix.RowNames = groupRunCollection.Select(x => x.Key); 
        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;
            }
        }
        viewHost2.Content = CalculateNodeImportance(adjMatrix);
        viewHost3.Content = UpdateAdjacencyMatrixByThreshold(0.2, "x1", adjMatrix);
        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 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;
    }

    private DoubleMatrix UpdateAdjacencyMatrixByThreshold(double threshold, string targetVariable, DoubleMatrix adjMatrix)
    {
        var updatedMatrix = (DoubleMatrix) adjMatrix.Clone();
        var groupRunCollection = Content.GroupBy(x => ((IRegressionProblemData)x.Parameters["ProblemData"]).TargetVariable).ToList();
        string[] targets = adjMatrix.RowNames.ToArray();
        var targetIndex = Array.IndexOf(targets, targetVariable);
        
        for (int j = 0; j < groupRunCollection.Count; ++j)
        {
            if (updatedMatrix[targetIndex, j] < threshold)
            {
                updatedMatrix[targetIndex, j] = 0;
            }          
        }
        return updatedMatrix;
    }

    private DoubleMatrix CalculateNodeImportance(DoubleMatrix adjMatrix)
    {
           DoubleMatrix nodeImportance = new DoubleMatrix(adjMatrix.Rows, 1);
           var variables = new List<Tuple<string, double>>();
           var rowNames = adjMatrix.RowNames.ToList();
           var groupRunCollection = Content.GroupBy(x => ((IRegressionProblemData)x.Parameters["ProblemData"]).TargetVariable).ToList();
           double[] meanQuality = new double[groupRunCollection.Count];

           for (int j = 0; j < groupRunCollection.Count; ++j)
           {
               var g = groupRunCollection[j];
               meanQuality[j] = g.Average(x => ((IRegressionSolution)x.Results[TrainingBestSolutionParameterName]).TrainingRSquared);
           }

           for (int i = 0; i < adjMatrix.Columns; ++i)
           {
               for (int j = 0; j < adjMatrix.Rows; ++j)
               {
                   nodeImportance[i, 0] += adjMatrix[j, i];
               }
               nodeImportance[i, 0] = nodeImportance[i, 0] * meanQuality[i] / (adjMatrix.Rows - 1);
               variables.Add(new Tuple<string, double>(rowNames[i], nodeImportance[i, 0]));
           }
           
           variables.Sort((b,a) => a.Item2.CompareTo(b.Item2));

           for (int i = 0; i < nodeImportance.Rows; ++i)
           {
               nodeImportance[i, 0] = variables[i].Item2;
               rowNames[i] = variables[i].Item1;
           }

           nodeImportance.RowNames = rowNames;
           nodeImportance.ColumnNames = new[] { "Node Importance" };
           return nodeImportance;    
    }

    //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;
    }

    //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++;
            }
        }
    }
  }
}