Changeset 15455

Timestamp:

11/07/17 13:15:55 (7 years ago)

Author:

bwerth

Message:

#2847 added WeightedEuclideanDistance && fixed minor bug in scatterPlot colloring

Location:

branches/Weighted TSNE/3.4/TSNE

Files:

• Distances/WeightedEuclideanDistance.cs (added)
• TSNEAlgorithm.cs (modified) (13 diffs)
• TSNEStatic.cs (modified) (5 diffs)
• TSNEUtils.cs (modified) (2 diffs)

branches/Weighted TSNE/3.4/TSNE/TSNEAlgorithm.cs

@@ -29 +29 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
@@ -57 +58 @@
     }
 
-    #region parameter names
+    #region Parameter names
     private const string DistanceFunctionParameterName = "DistanceFunction";
     private const string PerplexityParameterName = "Perplexity";
@@ -76 +77 @@
     #endregion
 
-    #region result names
+    #region Result names
     private const string IterationResultName = "Iteration";
     private const string ErrorResultName = "Error";
@@ -84 +85 @@
     #endregion
 
-    #region parameter properties
+    #region Parameter properties
     public IFixedValueParameter<DoubleValue> PerplexityParameter {
       get { return Parameters[PerplexityParameterName] as IFixedValueParameter<DoubleValue>; }
@@ -202 +203 @@
     #endregion
 
+    #region Storable poperties
+    [Storable]
+    private Dictionary<string, List<int>> dataRowNames;
+    [Storable]
+    private Dictionary<string, ScatterPlotDataRow> dataRows;
+    [Storable]
+    private TSNEStatic<double[]>.TSNEState state;
+    [Storable]
+    private int iter;
+    #endregion
+
     #region Constructors & Cloning
     [StorableConstructor]
     private TSNEAlgorithm(bool deserializing) : base(deserializing) { }
 
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterParameterEvents();
+    }
     private TSNEAlgorithm(TSNEAlgorithm original, Cloner cloner) : base(original, cloner) {
       if (original.dataRowNames != null)
@@ -250 +266 @@
       EtaParameter.Hidden = false;
       Problem = new RegressionProblem();
-    }
-    #endregion
-
-    [Storable]
-    private Dictionary<string, List<int>> dataRowNames;
-    [Storable]
-    private Dictionary<string, ScatterPlotDataRow> dataRows;
-    [Storable]
-    private TSNEStatic<double[]>.TSNEState state;
-    [Storable]
-    private int iter;
+      RegisterParameterEvents();
+    }
+    #endregion
 
     public override void Prepare() {
@@ -285 +293 @@
       }
       for (; iter < MaxIterations && !cancellationToken.IsCancellationRequested; iter++) {
-        if (iter % UpdateInterval == 0)
-          Analyze(state);
+        if (iter % UpdateInterval == 0) Analyze(state);
         TSNEStatic<double[]>.Iterate(state);
       }
       Analyze(state);
-      dataRowNames = null;
-      dataRows = null;
-      state = null;
     }
 
@@ -306 +310 @@
       Problem.ProblemDataChanged += OnProblemDataChanged;
     }
+
     protected override void DeregisterProblemEvents() {
       base.DeregisterProblemEvents();
@@ -311 +316 @@
     }
 
+    protected override void OnStopped() {
+      base.OnStopped();
+      state = null;
+      dataRowNames = null;
+      dataRows = null;
+    }
+
     private void OnProblemDataChanged(object sender, EventArgs args) {
       if (Problem == null || Problem.ProblemData == null) return;
+      OnPerplexityChanged(this, null);
+      Problem.ProblemData.Changed += OnPerplexityChanged;
+      Problem.ProblemData.Changed += OnColumnsChanged;
+      Problem.ProblemData.Dataset.RowsChanged += OnPerplexityChanged;
+      Problem.ProblemData.Dataset.ColumnsChanged += OnColumnsChanged;
       if (!Parameters.ContainsKey(ClassesNameParameterName)) return;
       ClassesNameParameter.ValidValues.Clear();
       foreach (var input in Problem.ProblemData.InputVariables) ClassesNameParameter.ValidValues.Add(input);
+    }
+    private void OnColumnsChanged(object sender, EventArgs e) {
+      if (Problem == null || Problem.ProblemData == null || Problem.ProblemData.Dataset == null || !Parameters.ContainsKey(DistanceFunctionParameterName)) return;
+      DistanceFunctionParameter.ValidValues.OfType<WeightedEuclideanDistance>().Single().Weights = new RealVector(Problem.ProblemData.AllowedInputVariables.Select(x => 1.0).ToArray());
+    }
+
+    private void RegisterParameterEvents() {
+      PerplexityParameter.Value.ValueChanged -= OnPerplexityChanged;
+      PerplexityParameter.Value.ValueChanged += OnPerplexityChanged;
+    }
+
+    private void OnPerplexityChanged(object sender, EventArgs e) {
+      if (Problem == null || Problem.ProblemData == null || Problem.ProblemData.Dataset == null || !Parameters.ContainsKey(PerplexityParameterName)) return;
+      PerplexityParameter.Value.ValueChanged -= OnPerplexityChanged;
+      PerplexityParameter.Value.Value = Math.Max(1, Math.Min((Problem.ProblemData.Dataset.Rows - 1) / 3.0, Perplexity));
+      PerplexityParameter.Value.ValueChanged += OnPerplexityChanged;
     }
     #endregion
@@ -327 +360 @@
       var problemData = Problem.ProblemData;
 
+      if (!results.ContainsKey(IterationResultName)) results.Add(new Result(IterationResultName, new IntValue(0)));
+      if (!results.ContainsKey(ErrorResultName)) results.Add(new Result(ErrorResultName, new DoubleValue(0)));
+      if (!results.ContainsKey(ScatterPlotResultName)) results.Add(new Result(ScatterPlotResultName, "Plot of the projected data", new ScatterPlot(DataResultName, "")));
+      if (!results.ContainsKey(DataResultName)) results.Add(new Result(DataResultName, "Projected Data", new DoubleMatrix()));
+      if (!results.ContainsKey(ErrorPlotResultName)) {
+        var errortable = new DataTable(ErrorPlotResultName, "Development of errors during gradient descent") {
+          VisualProperties = {
+            XAxisTitle = "UpdateIntervall",
+            YAxisTitle = "Error",
+            YAxisLogScale = true
+          }
+        };
+        errortable.Rows.Add(new DataRow("Errors"));
+        errortable.Rows["Errors"].VisualProperties.StartIndexZero = true;
+        results.Add(new Result(ErrorPlotResultName, errortable));
+      }
+
       //color datapoints acording to classes variable (be it double or string)
-      if (problemData.Dataset.VariableNames.Contains(ClassesName)) {
-        var classificationData = problemData as ClassificationProblemData;
-        if (classificationData != null && classificationData.TargetVariable.Equals(ClassesName)) {
-          var classNames = classificationData.ClassValues.Zip(classificationData.ClassNames, (v, n) => new {v, n}).ToDictionary(x => x.v, x => x.n);
-          var classes = classificationData.Dataset.GetDoubleValues(classificationData.TargetVariable, allIndices).Select(v => classNames[v]).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);
-          }
+      if (!problemData.Dataset.VariableNames.Contains(ClassesName)) {
+        dataRowNames.Add("Training", problemData.TrainingIndices.ToList());
+        dataRowNames.Add("Test", problemData.TestIndices.ToList());
+        return;
+      }
+      var classificationData = problemData as ClassificationProblemData;
+      if (classificationData != null && classificationData.TargetVariable.Equals(ClassesName)) {
+        var classNames = classificationData.ClassValues.Zip(classificationData.ClassNames, (v, n) => new {v, n}).ToDictionary(x => x.v, x => x.n);
+        var classes = classificationData.Dataset.GetDoubleValues(classificationData.TargetVariable, allIndices).Select(v => classNames[v]).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<string>(ClassesName)) {
-          var classes = problemData.Dataset.GetStringValues(ClassesName, allIndices).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<string>(ClassesName)) {
+        var classes = problemData.Dataset.GetStringValues(ClassesName, allIndices).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)) {
-          var clusterdata = new Dataset(problemData.Dataset.DoubleVariables, problemData.Dataset.DoubleVariables.Select(v => problemData.Dataset.GetDoubleValues(v, allIndices).ToList()));
-          const int contours = 8;
-          Dictionary<int, string> contourMap;
-          IClusteringModel clusterModel;
-          double[][] borders;
-          CreateClusters(clusterdata, 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(clusterdata, Enumerable.Range(0, clusterdata.Rows)).ToArray();
-          for (var i = 0; i < clusterdata.Rows; i++) dataRowNames[contourMap[allClusters[i] - 1]].Add(i);
+      }
+      else if (((Dataset) problemData.Dataset).VariableHasType<double>(ClassesName)) {
+        var clusterdata = new Dataset(problemData.Dataset.DoubleVariables, problemData.Dataset.DoubleVariables.Select(v => problemData.Dataset.GetDoubleValues(v, allIndices).ToList()));
+        const int contours = 8;
+        Dictionary<int, string> contourMap;
+        IClusteringModel clusterModel;
+        double[][] borders;
+        CreateClusters(clusterdata, 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);
         }
-        else if (((Dataset) problemData.Dataset).VariableHasType<DateTime>(ClassesName)) {
-          var clusterdata = new Dataset(problemData.Dataset.DateTimeVariables, problemData.Dataset.DateTimeVariables.Select(v => problemData.Dataset.GetDoubleValues(v, allIndices).ToList()));
-          const int contours = 8;
-          Dictionary<int, string> contourMap;
-          IClusteringModel clusterModel;
-          double[][] borders;
-          CreateClusters(clusterdata, 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(clusterdata, Enumerable.Range(0, clusterdata.Rows)).ToArray();
-          for (var i = 0; i < clusterdata.Rows; i++) dataRowNames[contourMap[allClusters[i] - 1]].Add(i);
+        var allClusters = clusterModel.GetClusterValues(clusterdata, Enumerable.Range(0, clusterdata.Rows)).ToArray();
+        for (var i = 0; i < clusterdata.Rows; i++) dataRowNames[contourMap[allClusters[i] - 1]].Add(i);
+      }
+      else if (((Dataset) problemData.Dataset).VariableHasType<DateTime>(ClassesName)) {
+        var clusterdata = new Dataset(problemData.Dataset.DateTimeVariables, problemData.Dataset.DateTimeVariables.Select(v => problemData.Dataset.GetDoubleValues(v, allIndices).ToList()));
+        const int contours = 8;
+        Dictionary<int, string> contourMap;
+        IClusteringModel clusterModel;
+        double[][] borders;
+        CreateClusters(clusterdata, 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);
         }
-        else {
-          dataRowNames.Add("Training", problemData.TrainingIndices.ToList());
-          dataRowNames.Add("Test", problemData.TestIndices.ToList());
-        }
-
-        if (!results.ContainsKey(IterationResultName)) results.Add(new Result(IterationResultName, new IntValue(0)));
-        else ((IntValue) results[IterationResultName].Value).Value = 0;
-
-        if (!results.ContainsKey(ErrorResultName)) results.Add(new Result(ErrorResultName, new DoubleValue(0)));
-        else ((DoubleValue) results[ErrorResultName].Value).Value = 0;
-
-        if (!results.ContainsKey(ErrorPlotResultName)) results.Add(new Result(ErrorPlotResultName, new DataTable(ErrorPlotResultName, "Development of errors during gradient descent")));
-        else results[ErrorPlotResultName].Value = new DataTable(ErrorPlotResultName, "Development of errors during gradient descent");
-
-        var plot = results[ErrorPlotResultName].Value as DataTable;
-        if (plot == null) throw new ArgumentException("could not create/access error data table in results collection");
-
-        if (!plot.Rows.ContainsKey("errors")) plot.Rows.Add(new DataRow("errors"));
-        plot.Rows["errors"].Values.Clear();
-        plot.Rows["errors"].VisualProperties.StartIndexZero = true;
-
-        results.Add(new Result(ScatterPlotResultName, "Plot of the projected data", new ScatterPlot(DataResultName, "")));
-        results.Add(new Result(DataResultName, "Projected Data", new DoubleMatrix()));
+        var allClusters = clusterModel.GetClusterValues(clusterdata, Enumerable.Range(0, clusterdata.Rows)).ToArray();
+        for (var i = 0; i < clusterdata.Rows; i++) dataRowNames[contourMap[allClusters[i] - 1]].Add(i);
+      }
+      else {
+        dataRowNames.Add("Training", problemData.TrainingIndices.ToList());
+        dataRowNames.Add("Test", problemData.TestIndices.ToList());
       }
     }
@@ -414 +446 @@
       var plot = results[ErrorPlotResultName].Value as DataTable;
       if (plot == null) throw new ArgumentException("Could not create/access error data table in results collection.");
-      var errors = plot.Rows["errors"].Values;
+      var errors = plot.Rows["Errors"].Values;
       var c = tsneState.EvaluateError();
       errors.Add(c);
@@ -430 +462 @@
         if (!plot.Rows.ContainsKey(rowName)) {
           plot.Rows.Add(dataRows.ContainsKey(rowName) ? dataRows[rowName] : new ScatterPlotDataRow(rowName, "", new List<Point2D<double>>()));
-          plot.Rows[rowName].VisualProperties.PointSize = 6;
+          plot.Rows[rowName].VisualProperties.PointSize = 8;
         }
         plot.Rows[rowName].Points.Replace(dataRowNames[rowName].Select(i => new Point2D<double>(lowDimData[i, 0], lowDimData[i, 1])));
@@ -504 +536 @@
     }
 
+    //taken from https://stackoverflow.com/a/17099130
     private static Color HsVtoRgb(double hue, double saturation, double value) {
-      while (hue > 1f) { hue -= 1f; }
-      while (hue < 0f) { hue += 1f; }
-      while (saturation > 1f) { saturation -= 1f; }
-      while (saturation < 0f) { saturation += 1f; }
-      while (value > 1f) { value -= 1f; }
-      while (value < 0f) { value += 1f; }
-      if (hue > 0.999f) { hue = 0.999f; }
-      if (hue < 0.001f) { hue = 0.001f; }
-      if (saturation > 0.999f) { saturation = 0.999f; }
-      if (saturation < 0.001f) { return Color.FromArgb((int) (value * 255f), (int) (value * 255f), (int) (value * 255f)); }
-      if (value > 0.999f) { value = 0.999f; }
-      if (value < 0.001f) { value = 0.001f; }
-
-      var h6 = hue * 6f;
-      if (h6.IsAlmost(6f)) { h6 = 0f; }
+      while (hue > 1.0) { hue -= 1.0; }
+      while (hue < 0.0) { hue += 1.0; }
+      while (saturation > 1.0) { saturation -= 1.0; }
+      while (saturation < 0.0) { saturation += 1.0; }
+      while (value > 1.0) { value -= 1.0; }
+      while (value < 0.0) { value += 1.0; }
+      if (hue > 0.999) { hue = 0.999; }
+      if (hue < 0.001) { hue = 0.001; }
+      if (saturation > 0.999) { saturation = 0.999; }
+      if (saturation < 0.001) { return Color.FromArgb((int) (value * 255.0), (int) (value * 255.0), (int) (value * 255.0)); }
+      if (value > 0.999) { value = 0.999; }
+      if (value < 0.001) { value = 0.001; }
+
+      var h6 = hue * 6.0;
+      if (h6.IsAlmost(6.0)) { h6 = 0.0; }
       var ihue = (int) h6;
-      var p = value * (1f - saturation);
-      var q = value * (1f - saturation * (h6 - ihue));
-      var t = value * (1f - saturation * (1f - (h6 - ihue)));
+      var p = value * (1.0 - saturation);
+      var q = value * (1.0 - saturation * (h6 - ihue));
+      var t = value * (1.0 - saturation * (1.0 - (h6 - ihue)));
       switch (ihue) {
         case 0:

branches/Weighted TSNE/3.4/TSNE/TSNEStatic.cs

@@ -216 +216 @@
           newData[i, j] = rand.NextDouble() * .0001;
 
-        if (data[0] is IReadOnlyList<double> && !randomInit) {
-          for (var i = 0; i < noDatapoints; i++)
-          for (var j = 0; j < newDimensions; j++) {
-            var row = (IReadOnlyList<double>) data[i];
-            newData[i, j] = row[j % row.Count];
-          }
+        if (!(data[0] is IReadOnlyList<double>) || randomInit) return;
+        for (var i = 0; i < noDatapoints; i++)
+        for (var j = 0; j < newDimensions; j++) {
+          var row = (IReadOnlyList<double>) data[i];
+          newData[i, j] = row[j % row.Count];
         }
       }
@@ -404 +403 @@
         }
       }
-
       private static double[][] ComputeDistances(T[] x, IDistance<T> distance) {
         var res = new double[x.Length][];
@@ -422 +420 @@
         // return x.Select(m => x.Select(n => distance.Get(m, n)).ToArray()).ToArray();
       }
-
       private static double EvaluateErrorExact(double[,] p, double[,] y, int n, int d) {
         // Compute the squared Euclidean distance matrix
@@ -450 +447 @@
         return c;
       }
-
       private static double EvaluateErrorApproximate(IReadOnlyList<int> rowP, IReadOnlyList<int> colP, IReadOnlyList<double> valP, double[,] y, double theta) {
         // Get estimate of normalization term
@@ -592 +588 @@
             ? state.gains[i, j] + .2 // +0.2 nd *0.8 are used in two separate implementations of tSNE -> seems to be correct
             : state.gains[i, j] * .8;
-
           if (state.gains[i, j] < .01) state.gains[i, j] = .01;
         }

branches/Weighted TSNE/3.4/TSNE/TSNEUtils.cs

@@ -35 +35 @@
     }
 
-    internal static IList<T> Swap<T>(this IList<T> list, int indexA, int indexB) {
+    internal static void Swap<T>(this IList<T> list, int indexA, int indexB) {
       var tmp = list[indexA];
       list[indexA] = list[indexB];
       list[indexB] = tmp;
-      return list;
     }
 
-    internal static int Partition<T>(this IList<T> list, int left, int right, int pivotindex, IComparer<T> comparer) {
+    private static int Partition<T>(this IList<T> list, int left, int right, int pivotindex, IComparer<T> comparer) {
       var pivotValue = list[pivotindex];
       list.Swap(pivotindex, right);
@@ -67 +66 @@
     /// <param name="comparer">comparer for list elemnts </param>
     /// <returns></returns>
-    internal static T NthElement<T>(this IList<T> list, int left, int right, int n, IComparer<T> comparer) {
+    internal static void NthElement<T>(this IList<T> list, int left, int right, int n, IComparer<T> comparer) {
       while (true) {
-        if (left == right) return list[left];
-        var pivotindex = left + (int)Math.Floor(new System.Random().Next() % (right - (double)left + 1));
+        if (left == right) return;
+        var pivotindex = left + (int) Math.Floor(new System.Random().Next() % (right - (double) left + 1));
         pivotindex = list.Partition(left, right, pivotindex, comparer);
-        if (n == pivotindex) return list[n];
+        if (n == pivotindex) return;
         if (n < pivotindex) right = pivotindex - 1;
         else left = pivotindex + 1;