Changeset 8454 for branches/NCA/HeuristicLab.Algorithms.NCA/3.3/NCAModel.cs

Timestamp:

08/09/12 02:17:57 (12 years ago)

Author:

abeham

Message:

#1913:

• Refactored NCAModel and NeighborhoodComponentsAnalysis algorithm
• Model now includes NearestNeighborModel
• Algorithm has ability to be canceled (basically recreated the optimization loop of mincgoptimize)
• Scaling should work properly now

File:

• branches/NCA/HeuristicLab.Algorithms.NCA/3.3/NCAModel.cs (modified) (5 diffs)

branches/NCA/HeuristicLab.Algorithms.NCA/3.3/NCAModel.cs

@@ -20 +20 @@
 #endregion
 
-using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -35 +34 @@
 
     [Storable]
-    private string targetVariable;
-    [Storable]
-    private string[] allowedInputVariables;
-    [Storable]
-    private double[] classValues;
-    /// <summary>
-    /// Get a clone of the class values
-    /// </summary>
-    public double[] ClassValues {
-      get { return (double[])classValues.Clone(); }
-    }
-    [Storable]
-    private int k;
+    private Scaling scaling;
     [Storable]
     private double[,] transformationMatrix;
-    /// <summary>
-    /// Get a clone of the transformation matrix
-    /// </summary>
     public double[,] TransformationMatrix {
       get { return (double[,])transformationMatrix.Clone(); }
     }
     [Storable]
-    private double[,] transformedTrainingset;
-    /// <summary>
-    /// Get a clone of the transformed trainingset
-    /// </summary>
-    public double[,] TransformedTrainingset {
-      get { return (double[,])transformedTrainingset.Clone(); }
-    }
+    private string[] allowedInputVariables;
     [Storable]
-    private Scaling scaling;
+    private string targetVariable;
+    [Storable]
+    private INearestNeighbourModel nnModel;
+    [Storable]
+    private Dictionary<double, double> nn2ncaClassMapping;
+    [Storable]
+    private Dictionary<double, double> nca2nnClassMapping;
 
     [StorableConstructor]
@@ -71 +55 @@
     protected NCAModel(NCAModel original, Cloner cloner)
       : base(original, cloner) {
-      k = original.k;
-      targetVariable = original.targetVariable;
-      allowedInputVariables = (string[])original.allowedInputVariables.Clone();
-      if (original.classValues != null)
-        this.classValues = (double[])original.classValues.Clone();
-      if (original.transformationMatrix != null)
-        this.transformationMatrix = (double[,])original.transformationMatrix.Clone();
-      if (original.transformedTrainingset != null)
-        this.transformedTrainingset = (double[,])original.transformedTrainingset.Clone();
       this.scaling = cloner.Clone(original.scaling);
+      this.transformationMatrix = (double[,])original.transformationMatrix.Clone();
+      this.allowedInputVariables = (string[])original.allowedInputVariables.Clone();
+      this.targetVariable = original.targetVariable;
+      this.nnModel = cloner.Clone(original.nnModel);
+      this.nn2ncaClassMapping = original.nn2ncaClassMapping.ToDictionary(x => x.Key, y => y.Value);
+      this.nca2nnClassMapping = original.nca2nnClassMapping.ToDictionary(x => x.Key, y => y.Value);
     }
-    public NCAModel(double[,] transformedTrainingset, Scaling scaling, double[,] transformationMatrix, int k, string targetVariable, IEnumerable<string> allowedInputVariables, double[] classValues = null)
-      : base() {
-      this.name = ItemName;
-      this.description = ItemDescription;
-      this.transformedTrainingset = transformedTrainingset;
+    public NCAModel(int k, double[,] scaledData, Scaling scaling, double[,] transformationMatrix, string targetVariable, IEnumerable<double> targetVector, IEnumerable<string> allowedInputVariables) {
+      Name = ItemName;
+      Description = ItemDescription;
       this.scaling = scaling;
       this.transformationMatrix = transformationMatrix;
-      this.k = k;
+      this.allowedInputVariables = allowedInputVariables.ToArray();
       this.targetVariable = targetVariable;
-      this.allowedInputVariables = allowedInputVariables.ToArray();
-      if (classValues != null)
-        this.classValues = (double[])classValues.Clone();
+
+      nca2nnClassMapping = targetVector.Distinct().OrderBy(x => x).Select((v, i) => new { Index = (double)i, Class = v }).ToDictionary(x => x.Class, y => y.Index);
+      nn2ncaClassMapping = nca2nnClassMapping.ToDictionary(x => x.Value, y => y.Key);
+
+      var transformedData = ReduceWithTarget(scaledData, targetVector.Select(x => nca2nnClassMapping[x]));
+
+      var kdtree = new alglib.nearestneighbor.kdtree();
+      alglib.nearestneighbor.kdtreebuild(transformedData, transformedData.GetLength(0), transformedData.GetLength(1) - 1, 1, 2, kdtree);
+
+      nnModel = new NearestNeighbourModel(kdtree, k, targetVariable,
+        Enumerable.Range(0, transformationMatrix.GetLength(1)).Select(x => x.ToString()),
+        nn2ncaClassMapping.Keys.ToArray());
     }
 
@@ -101 +89 @@
 
     public IEnumerable<double> GetEstimatedClassValues(Dataset dataset, IEnumerable<int> rows) {
-      var k = Math.Min(this.k, transformedTrainingset.GetLength(0));
-      var transformedRow = new double[transformationMatrix.GetLength(1)];
-      var kVotes = new SortedList<double, double>(k + 1);
-      foreach (var r in rows) {
-        for (int i = 0; i < transformedRow.Length; i++) transformedRow[i] = 0;
-        int j = 0;
-        foreach (var v in allowedInputVariables) {
-          var values = scaling.GetScaledValues(dataset, v, rows);
-          double val = dataset.GetDoubleValue(v, r);
-          for (int i = 0; i < transformedRow.Length; i++)
-            transformedRow[i] += val * transformationMatrix[j, i];
-          j++;
+      var unknownClasses = dataset.GetDoubleValues(targetVariable, rows).Where(x => !nca2nnClassMapping.ContainsKey(x));
+      if (unknownClasses.Any())
+        foreach (var uc in unknownClasses) {
+          nca2nnClassMapping[uc] = nca2nnClassMapping.Count;
+          nn2ncaClassMapping[nca2nnClassMapping[uc]] = uc;
         }
-        kVotes.Clear();
-        for (int a = 0; a < transformedTrainingset.GetLength(0); a++) {
-          double d = 0;
-          for (int y = 0; y < transformedRow.Length; y++) {
-            d += (transformedRow[y] - transformedTrainingset[a, y]) * (transformedRow[y] - transformedTrainingset[a, y]);
-          }
-          while (kVotes.ContainsKey(d)) d += 1e-12;
-          if (kVotes.Count <= k || kVotes.Last().Key > d) {
-            kVotes.Add(d, classValues[a]);
-            if (kVotes.Count > k) kVotes.RemoveAt(kVotes.Count - 1);
-          }
-        }
-        yield return kVotes.Values.ToLookup(x => x).MaxItems(x => x.Count()).First().Key;
-      }
+      var transformedData = ReduceWithTarget(dataset, rows, dataset.GetDoubleValues(targetVariable, rows).Select(x => nca2nnClassMapping[x]));
+      var ds = new Dataset(Enumerable.Range(0, transformationMatrix.GetLength(1)).Select(x => x.ToString()).Concat(targetVariable.ToEnumerable()), transformedData);
+      return nnModel.GetEstimatedClassValues(ds, Enumerable.Range(0, ds.Rows)).Select(x => nn2ncaClassMapping[x]);
     }
+
     public NCAClassificationSolution CreateClassificationSolution(IClassificationProblemData problemData) {
       return new NCAClassificationSolution(problemData, this);
     }
+
     IClassificationSolution IClassificationModel.CreateClassificationSolution(IClassificationProblemData problemData) {
       return CreateClassificationSolution(problemData);
@@ -137 +109 @@
 
     public double[,] Reduce(Dataset dataset, IEnumerable<int> rows) {
-      var result = new double[rows.Count(), transformationMatrix.GetLength(1)];
-      int v = 0;
-      foreach (var r in rows) {
-        int i = 0;
-        foreach (var variable in allowedInputVariables) {
-          double val = dataset.GetDoubleValue(variable, r);
-          for (int j = 0; j < result.GetLength(1); j++)
-            result[v, j] += val * transformationMatrix[i, j];
-          i++;
-        }
-        v++;
-      }
+      var scaledData = AlglibUtil.PrepareAndScaleInputMatrix(dataset, allowedInputVariables, rows, scaling);
+      return Reduce(scaledData);
+    }
+
+    private double[,] Reduce(double[,] scaledData) {
+      var result = new double[scaledData.GetLength(0), transformationMatrix.GetLength(1)];
+      for (int i = 0; i < scaledData.GetLength(0); i++)
+        for (int j = 0; j < scaledData.GetLength(1); j++)
+          for (int x = 0; x < transformationMatrix.GetLength(1); x++) {
+            result[i, x] += scaledData[i, j] * transformationMatrix[j, x];
+          }
+      return result;
+    }
+
+    private double[,] ReduceWithTarget(Dataset dataset, IEnumerable<int> rows, IEnumerable<double> targetValues) {
+      var scaledData = AlglibUtil.PrepareAndScaleInputMatrix(dataset, allowedInputVariables, rows, scaling);
+      return ReduceWithTarget(scaledData, targetValues);
+    }
+
+    private double[,] ReduceWithTarget(double[,] scaledData, IEnumerable<double> targetValues) {
+      var result = new double[scaledData.GetLength(0), transformationMatrix.GetLength(1) + 1];
+      for (int i = 0; i < scaledData.GetLength(0); i++)
+        for (int j = 0; j < scaledData.GetLength(1); j++)
+          for (int x = 0; x < transformationMatrix.GetLength(1); x++) {
+            result[i, x] += scaledData[i, j] * transformationMatrix[j, x];
+          }
+
+      int r = 0;
+      foreach (var d in targetValues) result[r++, transformationMatrix.GetLength(1)] = d;
+
       return result;
     }