source: branches/M5Regression/HeuristicLab.Algorithms.DataAnalysis/3.4/PCA/PrincipleComponentAnalysis.cs @ 15430

using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Threading;
using HeuristicLab.Analysis;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Optimization;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Problems.DataAnalysis;

namespace HeuristicLab.Algorithms.DataAnalysis {
  [StorableClass]
  [Creatable(CreatableAttribute.Categories.DataAnalysis, Priority = 95)]
  [Item("PrincipleComponentAnalysis", "Standard Principle Component Analyis")]
  public sealed class PrincipleComponentAnalysis : FixedDataAnalysisAlgorithm<IRegressionProblem> {
    private const string NormalizationParameterName = "Normalization";
    public IFixedValueParameter<BoolValue> NormalizationParameter {
      get { return Parameters[NormalizationParameterName] as IFixedValueParameter<BoolValue>; }
    }
    public bool Normalization {
      get { return NormalizationParameter.Value.Value; }
    }

    [StorableConstructor]
    private PrincipleComponentAnalysis(bool deserializing) : base(deserializing) { }
    private PrincipleComponentAnalysis(PrincipleComponentAnalysis original, Cloner cloner) : base(original, cloner) { }
    public PrincipleComponentAnalysis() {
      Problem = new RegressionProblem();
      Parameters.Add(new FixedValueParameter<BoolValue>(NormalizationParameterName, "Whether the data should be zero centered and have variance of 1 for each variable, so different scalings are ignored.", new BoolValue(true)));
    }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() { }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new PrincipleComponentAnalysis(this, cloner);
    }

    protected override void Run(CancellationToken cancellationToken) {
      var data = Problem.ProblemData.Dataset;
      var attributes = Problem.ProblemData.AllowedInputVariables.ToArray();
      var solution = PrincipleComponentAnalysisStatic.Create(data, Problem.ProblemData.AllIndices, attributes, Normalization);
      var res = solution.ProjectData(Problem.ProblemData.Dataset, Problem.ProblemData.AllIndices);
      Results.Add(new Result("ProjectedData", new DoubleMatrix(res)));
      Results.Add(new Result("Variances", new DoubleArray(solution.Variances)));
      CreateScatterPlot(Problem.ProblemData.TargetVariable, res);
    }

    #region Fancy ScatterPlot
    private void CreateScatterPlot(string classesName, double[,] lowDimData) {
      var results = Results;
      var dataRowNames = new Dictionary<string, List<int>>();
      var dataRows = new Dictionary<string, ScatterPlotDataRow>();
      var problemData = Problem.ProblemData;

      //color datapoints acording to classes variable (be it double or string)
      if (problemData.Dataset.VariableNames.Contains(classesName)) {
        if (((Dataset) problemData.Dataset).VariableHasType<string>(classesName)) {
          var classes = problemData.Dataset.GetStringValues(classesName).ToArray();
          for (var i = 0; i < classes.Length; i++) {
            if (!dataRowNames.ContainsKey(classes[i])) dataRowNames.Add(classes[i], new List<int>());
            dataRowNames[classes[i]].Add(i);
          }
        }
        else if (((Dataset) problemData.Dataset).VariableHasType<double>(classesName)) {
          const int contours = 8;
          Dictionary<int, string> contourMap;
          IClusteringModel clusterModel;
          double[][] borders;
          CreateClusters(problemData, classesName, contours, out clusterModel, out contourMap, out borders);

          var contourorder = borders.Select((x, i) => new {x, i}).OrderBy(x => x.x[0]).Select(x => x.i).ToArray();
          for (var i = 0; i < contours; i++) {
            var c = contourorder[i];
            var contourname = contourMap[c];
            dataRowNames.Add(contourname, new List<int>());
            dataRows.Add(contourname, new ScatterPlotDataRow(contourname, "", new List<Point2D<double>>()));
            dataRows[contourname].VisualProperties.Color = GetHeatMapColor(i, contours);
            dataRows[contourname].VisualProperties.PointSize = i + 3;
          }

          var allClusters = clusterModel.GetClusterValues(problemData.Dataset, problemData.AllIndices).ToArray();
          for (var i = 0; i < problemData.Dataset.Rows; i++) dataRowNames[contourMap[allClusters[i] - 1]].Add(i);
        }
      }
      else {
        dataRowNames.Add("Training", problemData.TrainingIndices.ToList());
        dataRowNames.Add("Test", problemData.TestIndices.ToList());
      }

      var plotName = "PjoctedDataPlot";
      var plot = new ScatterPlot(plotName, "");
      results.Add(new Result(plotName, "Plot of the projected data", plot));
      foreach (var rowName in dataRowNames.Keys) {
        if (!plot.Rows.ContainsKey(rowName))
          plot.Rows.Add(dataRows.ContainsKey(rowName) ? dataRows[rowName] : new ScatterPlotDataRow(rowName, "", new List<Point2D<double>>()));
        plot.Rows[rowName].Points.Replace(dataRowNames[rowName].Select(i => new Point2D<double>(lowDimData[i, 0], lowDimData[i, 1 % lowDimData.GetLength(1)])));
      }
    }

    private static void CreateClusters(IDataAnalysisProblemData data, string target, int contours, out IClusteringModel contourCluster, out Dictionary<int, string> contourNames, out double[][] borders) {
      contourCluster = KMeansClustering.CreateKMeansSolution(new ClusteringProblemData((Dataset) data.Dataset, new[] {target}), contours, 3).Model;

      borders = Enumerable.Range(0, contours).Select(x => new[] {double.MaxValue, double.MinValue}).ToArray();
      var clusters = contourCluster.GetClusterValues(data.Dataset, data.AllIndices).ToArray();
      var targetvalues = data.Dataset.GetDoubleValues(target).ToArray();
      foreach (var i in data.AllIndices) {
        var cl = clusters[i] - 1;
        var clv = targetvalues[i];
        if (borders[cl][0] > clv) borders[cl][0] = clv;
        if (borders[cl][1] < clv) borders[cl][1] = clv;
      }

      contourNames = new Dictionary<int, string>();
      for (var i = 0; i < contours; i++)
        contourNames.Add(i, "[" + borders[i][0] + ";" + borders[i][1] + "]");
    }

    private static Color GetHeatMapColor(int contourNr, int noContours) {
      var hue = contourNr / (double) noContours;
      const double saturation = 0.999f;
      const double value = 0.999f;

      if (hue > 0.999f) { hue = 0.999f; }
      if (hue < 0.001f) { hue = 0.001f; }

      var h6 = hue * 6f;
      if (h6.IsAlmost(6f)) { h6 = 0f; }
      var ihue = (int) h6;
      var p = value * (1f - saturation);
      var q = value * (1f - saturation * (h6 - ihue));
      var t = value * (1f - saturation * (1f - (h6 - ihue)));
      switch (ihue) {
        case 0: return Color.FromArgb((int) (value * 255), (int) (t * 255), (int) (p * 255));
        case 1: return Color.FromArgb((int) (q * 255), (int) (value * 255), (int) (p * 255));
        case 2: return Color.FromArgb((int) (p * 255), (int) (value * 255), (int) (t * 255));
        case 3: return Color.FromArgb((int) (p * 255), (int) (q * 255), (int) (value * 255));
        case 4: return Color.FromArgb((int) (t * 255), (int) (p * 255), (int) (value * 255));
        default: return Color.FromArgb((int) (value * 255), (int) (p * 255), (int) (q * 255));
      }
    }
    #endregion
  }
}