Changeset 4543 for trunk/sources/HeuristicLab.Problems.DataAnalysis

Timestamp:

10/01/10 12:31:04 (14 years ago)

Author:

gkronber

Message:

Adapted SVM classes to work correctly for overlapping training / test partitions. #1226

Location:

trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3

Files:

• DataAnalysisProblemData.cs (modified) (2 diffs)
• SupportVectorMachine/SupportVectorMachineCrossValidationEvaluator.cs (modified) (6 diffs)
• SupportVectorMachine/SupportVectorMachineModel.cs (modified) (1 diff)
• SupportVectorMachine/SupportVectorMachineModelCreator.cs (modified) (4 diffs)
• SupportVectorMachine/SupportVectorMachineModelEvaluator.cs (modified) (3 diffs)
• SupportVectorMachine/SupportVectorMachineUtil.cs (modified) (1 diff)

trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/DataAnalysisProblemData.cs

@@ -180 +180 @@
       get {
         return Enumerable.Range(TrainingSamplesStart.Value, TrainingSamplesEnd.Value - TrainingSamplesStart.Value)
-                         .Where(i => i > 0 && i < Dataset.Rows && (i < TestSamplesStart.Value || TestSamplesEnd.Value <= i));
+                         .Where(i => i >= 0 && i < Dataset.Rows && (i < TestSamplesStart.Value || TestSamplesEnd.Value <= i));
       }
     }
@@ -186 +186 @@
       get {
         return Enumerable.Range(TestSamplesStart.Value, TestSamplesEnd.Value - TestSamplesStart.Value)
-           .Where(i => i > 0 && i < Dataset.Rows);
+           .Where(i => i >= 0 && i < Dataset.Rows);
       }
     }

trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/SupportVectorMachine/SupportVectorMachineCrossValidationEvaluator.cs

@@ -29 +29 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using SVM;
+using System.Collections.Generic;
 
 namespace HeuristicLab.Problems.DataAnalysis.SupportVectorMachine {
@@ -143 +144 @@
 
     public override IOperation Apply() {
-      double reductionRatio = 1.0;
+      double reductionRatio = 1.0; // TODO: make parameter
       if (ActualSamplesParameter.ActualValue != null)
         reductionRatio = ActualSamplesParameter.ActualValue.Value;
-
-      int reducedRows = (int)((SamplesEnd.Value - SamplesStart.Value) * reductionRatio);
+      IEnumerable<int> rows = 
+        Enumerable.Range(SamplesStart.Value, SamplesEnd.Value - SamplesStart.Value)
+        .Where(i => i < DataAnalysisProblemData.TestSamplesStart.Value || DataAnalysisProblemData.TestSamplesEnd.Value <= i);
+
+      // create a new DataAnalysisProblemData instance
       DataAnalysisProblemData reducedProblemData = (DataAnalysisProblemData)DataAnalysisProblemData.Clone();
-      reducedProblemData.Dataset = CreateReducedDataset(RandomParameter.ActualValue, reducedProblemData.Dataset, reductionRatio, SamplesStart.Value, SamplesEnd.Value);
+      reducedProblemData.Dataset = 
+        CreateReducedDataset(RandomParameter.ActualValue, reducedProblemData.Dataset, rows, reductionRatio);
+      reducedProblemData.TrainingSamplesStart.Value = 0;
+      reducedProblemData.TrainingSamplesEnd.Value = reducedProblemData.Dataset.Rows;
+      reducedProblemData.TestSamplesStart.Value = reducedProblemData.Dataset.Rows;
+      reducedProblemData.TestSamplesEnd.Value = reducedProblemData.Dataset.Rows;
+      reducedProblemData.ValidationPercentage.Value = 0;
 
       double quality = PerformCrossValidation(reducedProblemData,
-                             SamplesStart.Value, SamplesStart.Value + reducedRows,
                              SvmType.Value, KernelType.Value,
                              Cost.Value, Nu.Value, Gamma.Value, Epsilon.Value, NumberOfFolds.Value);
@@ -160 +169 @@
     }
 
-    private Dataset CreateReducedDataset(IRandom random, Dataset dataset, double reductionRatio, int start, int end) {
-      int n = (int)((end - start) * reductionRatio);
+    private Dataset CreateReducedDataset(IRandom random, Dataset dataset, IEnumerable<int> rowIndices, double reductionRatio) {
+      
       // must not make a fink:
       // => select n rows randomly from start..end
@@ -168 +177 @@
 
       // all possible rowIndexes from start..end
-      int[] rowIndexes = Enumerable.Range(start, end - start).ToArray();
+      int[] rowIndexArr = rowIndices.ToArray();
+      int n = (int)Math.Max(1.0, rowIndexArr.Length * reductionRatio);
 
       // knuth shuffle
-      for (int i = rowIndexes.Length - 1; i > 0; i--) {
+      for (int i = rowIndexArr.Length - 1; i > 0; i--) {
         int j = random.Next(0, i);
         // swap
-        int tmp = rowIndexes[i];
-        rowIndexes[i] = rowIndexes[j];
-        rowIndexes[j] = tmp;
+        int tmp = rowIndexArr[i];
+        rowIndexArr[i] = rowIndexArr[j];
+        rowIndexArr[j] = tmp;
       }
 
       // take the first n indexes (selected n rowIndexes from start..end)
       // now order by index
-      var orderedRandomIndexes = rowIndexes.Take(n).OrderBy(x => x).ToArray();
-
-      // now build a dataset collecting the rows from orderedRandomIndexes into the dataset starting at index start
-      double[,] reducedData = dataset.GetClonedData();
+      int[] orderedRandomIndexes = 
+        rowIndexArr.Take(n)
+        .OrderBy(x => x)
+        .ToArray();
+
+      // now build a dataset containing only rows from orderedRandomIndexes 
+      double[,] reducedData = new double[n, dataset.Columns];
       for (int i = 0; i < n; i++) {
         for (int column = 0; column < dataset.Columns; column++) {
-          reducedData[start + i, column] = dataset[orderedRandomIndexes[i], column];
+          reducedData[i, column] = dataset[orderedRandomIndexes[i], column];
         }
       }
@@ -198 +211 @@
       double cost, double nu, double gamma, double epsilon,
       int nFolds) {
-      return PerformCrossValidation(problemData, problemData.TrainingSamplesStart.Value, problemData.TrainingSamplesEnd.Value, svmType, kernelType, cost, nu, gamma, epsilon, nFolds);
+      return PerformCrossValidation(problemData, problemData.TrainingIndizes, svmType, kernelType, cost, nu, gamma, epsilon, nFolds);
     }
 
     public static double PerformCrossValidation(
       DataAnalysisProblemData problemData,
-      int start, int end,
+      IEnumerable<int> rowIndices,
       string svmType, string kernelType,
       double cost, double nu, double gamma, double epsilon,
@@ -221 +234 @@
 
 
-      SVM.Problem problem = SupportVectorMachineUtil.CreateSvmProblem(problemData, start, end);
+      SVM.Problem problem = SupportVectorMachineUtil.CreateSvmProblem(problemData, rowIndices);
       SVM.RangeTransform rangeTransform = SVM.RangeTransform.Compute(problem);
       SVM.Problem scaledProblem = Scaling.Scale(rangeTransform, problem);

trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/SupportVectorMachine/SupportVectorMachineModel.cs

@@ -72 +72 @@
 
     public IEnumerable<double> GetEstimatedValues(DataAnalysisProblemData problemData, int start, int end) {
-      SVM.Problem problem = SupportVectorMachineUtil.CreateSvmProblem(problemData, start, end);
+      SVM.Problem problem = SupportVectorMachineUtil.CreateSvmProblem(problemData, Enumerable.Range(start, end - start));
       SVM.Problem scaledProblem = Scaling.Scale(RangeTransform, problem);
 
       return (from row in Enumerable.Range(0, scaledProblem.Count)
-              select SVM.Prediction.Predict(Model, scaledProblem.X[row])).ToList();
+              select SVM.Prediction.Predict(Model, scaledProblem.X[row]))
+              .ToList();
     }
 

trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/SupportVectorMachine/SupportVectorMachineModelCreator.cs

@@ -27 +27 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using SVM;
+using System.Collections.Generic;
+using System.Linq;
 
 namespace HeuristicLab.Problems.DataAnalysis.SupportVectorMachine {
@@ -125 +127 @@
 
     public override IOperation Apply() {
+      int start = SamplesStart.Value;
+      int end = SamplesEnd.Value;
+      IEnumerable<int> rows = 
+        Enumerable.Range(start, end-start)
+        .Where(i => i < DataAnalysisProblemData.TestSamplesStart.Value || DataAnalysisProblemData.TestSamplesEnd.Value <= i);
+
       SupportVectorMachineModel model = TrainModel(DataAnalysisProblemData,
-                             SamplesStart.Value, SamplesEnd.Value,
+                             rows,
                              SvmType.Value, KernelType.Value,
                              Cost.Value, Nu.Value, Gamma.Value, Epsilon.Value);
@@ -138 +146 @@
       string svmType, string kernelType,
       double cost, double nu, double gamma, double epsilon) {
-      return TrainModel(problemData, problemData.TrainingSamplesStart.Value, problemData.TrainingSamplesEnd.Value, svmType, kernelType, cost, nu, gamma, epsilon);
+      return TrainModel(problemData, problemData.TrainingIndizes, svmType, kernelType, cost, nu, gamma, epsilon);
     }
 
     public static SupportVectorMachineModel TrainModel(
       DataAnalysisProblemData problemData,
-      int start, int end,
+      IEnumerable<int> trainingIndizes,
       string svmType, string kernelType,
       double cost, double nu, double gamma, double epsilon) {
@@ -160 +168 @@
 
 
-      SVM.Problem problem = SupportVectorMachineUtil.CreateSvmProblem(problemData, start, end);
+      SVM.Problem problem = SupportVectorMachineUtil.CreateSvmProblem(problemData, trainingIndizes);
       SVM.RangeTransform rangeTransform = SVM.RangeTransform.Compute(problem);
       SVM.Problem scaledProblem = Scaling.Scale(rangeTransform, problem);

trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/SupportVectorMachine/SupportVectorMachineModelEvaluator.cs

@@ -26 +26 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using SVM;
+using System.Collections.Generic;
+using System.Linq;
 
 namespace HeuristicLab.Problems.DataAnalysis.SupportVectorMachine {
@@ -80 +82 @@
       int start = SamplesStart.Value;
       int end = SamplesEnd.Value;
+      IEnumerable<int> rows =
+        Enumerable.Range(start, end - start)
+        .Where(i => i < DataAnalysisProblemData.TestSamplesStart.Value || DataAnalysisProblemData.TestSamplesEnd.Value <= i);
 
-      ValuesParameter.ActualValue = new DoubleMatrix(Evaluate(SupportVectorMachineModel, DataAnalysisProblemData, start, end));
+      ValuesParameter.ActualValue = new DoubleMatrix(Evaluate(SupportVectorMachineModel, DataAnalysisProblemData, rows));
       return base.Apply();
     }
 
-    public static double[,] Evaluate(SupportVectorMachineModel model, DataAnalysisProblemData problemData, int start, int end) {
-      SVM.Problem problem = SupportVectorMachineUtil.CreateSvmProblem(problemData, start, end);
+    public static double[,] Evaluate(SupportVectorMachineModel model, DataAnalysisProblemData problemData, IEnumerable<int> rowIndices) {
+      SVM.Problem problem = SupportVectorMachineUtil.CreateSvmProblem(problemData, rowIndices);
       SVM.Problem scaledProblem = model.RangeTransform.Scale(problem);
 
@@ -92 +97 @@
 
       double[,] values = new double[scaledProblem.Count, 2];
+      var rowEnumerator = rowIndices.GetEnumerator();
       for (int i = 0; i < scaledProblem.Count; i++) {
-        values[i, 0] = problemData.Dataset[start + i, targetVariableIndex];
+        rowEnumerator.MoveNext();
+        values[i, 0] = problemData.Dataset[rowEnumerator.Current, targetVariableIndex];
         values[i, 1] = SVM.Prediction.Predict(model.Model, scaledProblem.X[i]);
       }

trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/SupportVectorMachine/SupportVectorMachineUtil.cs

@@ -29 +29 @@
     /// </summary>
     /// <param name="problemData">The problem data to transform</param>
-    /// <param name="start">The index of the first row of <paramref name="problemData"/> to copy to the output.</param>
-    /// <param name="end">The last of the first row of <paramref name="problemData"/> to copy to the output.</param>
+    /// <param name="rowIndices">The rows of the dataset that should be contained in the resulting SVM-problem</param>
     /// <returns>A problem data type that can be used to train a support vector machine.</returns>
-    public static SVM.Problem CreateSvmProblem(DataAnalysisProblemData problemData, int start, int end) {
-      int rowCount = end - start;
-      var targetVector = problemData.Dataset.GetVariableValues(problemData.TargetVariable.Value, start, end);
+    public static SVM.Problem CreateSvmProblem(DataAnalysisProblemData problemData, IEnumerable<int> rowIndices) {
+      double[] targetVector =
+        problemData.Dataset.GetEnumeratedVariableValues(problemData.TargetVariable.Value, rowIndices)
+        .ToArray();
 
       SVM.Node[][] nodes = new SVM.Node[targetVector.Length][];
       List<SVM.Node> tempRow;
       int maxNodeIndex = 0;
-      for (int row = 0; row < rowCount; row++) {
+      int svmProblemRowIndex = 0;
+      foreach (int row in rowIndices) {
         tempRow = new List<SVM.Node>();
         foreach (var inputVariable in problemData.InputVariables.CheckedItems) {
           int col = problemData.Dataset.GetVariableIndex(inputVariable.Value.Value);
-          double value = problemData.Dataset[start + row, col];
+          double value = problemData.Dataset[row, col];
           if (!double.IsNaN(value)) {
-            int nodeIndex = col + 1; // make sure the smallest nodeIndex = 1
+            int nodeIndex = col + 1; // make sure the smallest nodeIndex is 1 (libSVM convention)
             tempRow.Add(new SVM.Node(nodeIndex, value));
             if (nodeIndex > maxNodeIndex) maxNodeIndex = nodeIndex;
           }
         }
-        nodes[row] = tempRow.OrderBy(x => x.Index).ToArray(); // make sure the values are sorted by node index
+        nodes[svmProblemRowIndex++] = tempRow.OrderBy(x => x.Index).ToArray(); // make sure the values are sorted by node index
       }