Changeset 4469

Timestamp:

09/22/10 12:14:38 (14 years ago)

Author:

mkommend

Message:

Added logic to remove the test samples from the training samples (ticket #939).

Location:

branches/HeuristicLab.Classification

Files:

• HeuristicLab.Problems.DataAnalysis.Classification.Views/3.3/ConfusionMatrixView.cs (modified) (2 diffs)
• HeuristicLab.Problems.DataAnalysis.Classification.Views/3.3/RocCurvesView.cs (modified) (2 diffs)
• HeuristicLab.Problems.DataAnalysis.Classification.Views/3.3/SymbolicClassificationSolutionView.cs (modified) (3 diffs)
• HeuristicLab.Problems.DataAnalysis.Classification/3.3/Symbolic/Analyzer/ValidationBestSymbolicClassificationSolutionAnalyzer.cs (modified) (3 diffs)
• HeuristicLab.Problems.DataAnalysis.Classification/3.3/Symbolic/SymbolicClassificationSolution.cs (modified) (2 diffs)

branches/HeuristicLab.Classification/HeuristicLab.Problems.DataAnalysis.Classification.Views/3.3/ConfusionMatrixView.cs

@@ -105 +105 @@
 
         double[,] confusionMatrix = new double[Content.ProblemData.NumberOfClasses, Content.ProblemData.NumberOfClasses];
-        int start;
-        int end;
+        IEnumerable<int> rows;
 
         if (cmbSamples.SelectedItem.ToString() == TrainingSamples) {
-          start = Content.ProblemData.TrainingSamplesStart.Value;
-          end = Content.ProblemData.TrainingSamplesEnd.Value;
+          rows = Content.ProblemData.TrainingIndizes;
         } else if (cmbSamples.SelectedItem.ToString() == TestSamples) {
-          start = Content.ProblemData.TestSamplesStart.Value;
-          end = Content.ProblemData.TestSamplesEnd.Value;
+          rows = Content.ProblemData.TestIndizes;
         } else throw new InvalidOperationException();
 
@@ -123 +120 @@
         }
 
-        double[] targetValues = Content.ProblemData.Dataset.GetVariableValues(Content.ProblemData.TargetVariable.Value, start, end);
-        double[] predictedValues = Content.EstimatedClassValues.Skip(start).Take(end - start).ToArray();
+        double[] targetValues = Content.ProblemData.Dataset.GetEnumeratedVariableValues(Content.ProblemData.TargetVariable.Value, rows).ToArray();
+        double[] predictedValues = Content.GetEstimatedClassValues(rows).ToArray();
 
         for (int i = 0; i < targetValues.Length; i++) {

branches/HeuristicLab.Classification/HeuristicLab.Problems.DataAnalysis.Classification.Views/3.3/RocCurvesView.cs

@@ -97 +97 @@
 
         int slices = 100;
-        int samplesStart = Content.ProblemData.TrainingSamplesStart.Value;
-        int samplesEnd = Content.ProblemData.TrainingSamplesEnd.Value;
+        IEnumerable<int> rows;
 
         if (cmbSamples.SelectedItem.ToString() == TrainingSamples) {
-          samplesStart = Content.ProblemData.TrainingSamplesStart.Value;
-          samplesEnd = Content.ProblemData.TrainingSamplesEnd.Value;
+          rows = Content.ProblemData.TrainingIndizes;
         } else if (cmbSamples.SelectedItem.ToString() == TestSamples) {
-          samplesStart = Content.ProblemData.TestSamplesStart.Value;
-          samplesEnd = Content.ProblemData.TestSamplesEnd.Value;
+          rows = Content.ProblemData.TestIndizes;
         } else throw new InvalidOperationException();
 
-        double[] estimatedValues = Content.EstimatedValues.Skip(samplesStart).Take(samplesEnd - samplesStart).ToArray();
-        double[] targetClassValues = Content.ProblemData.Dataset.GetVariableValues(Content.ProblemData.TargetVariable.Value)
-          .Skip(samplesStart).Take(samplesEnd - samplesStart).ToArray();
+        double[] estimatedValues = Content.GetEstimatedValues(rows).ToArray();
+        double[] targetClassValues = Content.ProblemData.Dataset.GetEnumeratedVariableValues(Content.ProblemData.TargetVariable.Value, rows).ToArray();
         double minThreshold = estimatedValues.Min();
         double maxThreshold = estimatedValues.Max();
@@ -122 +118 @@
           List<ROCPoint> rocPoints = new List<ROCPoint>();
           int positives = targetClassValues.Where(c => c.IsAlmost(classValue)).Count();
-          int negatives = samplesEnd - samplesStart - positives;
+          int negatives = targetClassValues.Length - positives;
 
           for (double lowerThreshold = minThreshold; lowerThreshold < maxThreshold; lowerThreshold += thresholdIncrement) {

branches/HeuristicLab.Classification/HeuristicLab.Problems.DataAnalysis.Classification.Views/3.3/SymbolicClassificationSolutionView.cs

@@ -134 +134 @@
 
     private void FillSeriesWithDataPoints(Series series) {
-      int row = Content.ProblemData.TrainingSamplesStart.Value;
-      foreach (double estimatedValue in Content.EstimatedTrainingValues) {
+      List<double> estimatedValues = Content.EstimatedValues.ToList();
+      foreach (int row in Content.ProblemData.TrainingIndizes) {
+        double estimatedValue = estimatedValues[row];
         double targetValue = Content.ProblemData.Dataset[Content.ProblemData.TargetVariable.Value, row];
-        if (targetValue == (double)series.Tag) {
+        if (targetValue.IsAlmost((double)series.Tag)) {
           double jitterValue = random.NextDouble() * 2.0 - 1.0;
           DataPoint point = new DataPoint();
@@ -145 +146 @@
           series.Points.Add(point);
         }
-        row++;
-      }
-
-      row = Content.ProblemData.TestSamplesStart.Value;
-      foreach (double estimatedValue in Content.EstimatedTestValues) {
+      }
+
+      foreach (int row in Content.ProblemData.TestIndizes) {
+        double estimatedValue = estimatedValues[row];
         double targetValue = Content.ProblemData.Dataset[Content.ProblemData.TargetVariable.Value, row];
         if (targetValue == (double)series.Tag) {
@@ -159 +159 @@
           series.Points.Add(point);
         }
-        row++;
-      }
+      }
+
       UpdateCursorInterval();
     }

branches/HeuristicLab.Classification/HeuristicLab.Problems.DataAnalysis.Classification/3.3/Symbolic/Analyzer/ValidationBestSymbolicClassificationSolutionAnalyzer.cs

@@ -217 +217 @@
       int count = (int)((validationEnd - validationStart) * RelativeNumberOfEvaluatedSamples.Value);
       if (count == 0) count = 1;
-      IEnumerable<int> rows = RandomEnumerable.SampleRandomNumbers(seed, validationStart, validationEnd, count);
+      IEnumerable<int> rows = RandomEnumerable.SampleRandomNumbers(seed, validationStart, validationEnd, count)
+         .Where(row => row < ClassificationProblemData.TestSamplesStart.Value || ClassificationProblemData.TestSamplesEnd.Value <= row);
 
       double upperEstimationLimit = UpperEstimationLimit != null ? UpperEstimationLimit.Value : double.PositiveInfinity;
@@ -244 +245 @@
       if (newBest) {
         double alpha, beta;
-        int trainingStart = ClassificationProblemData.TrainingSamplesStart.Value;
-        int trainingEnd = ClassificationProblemData.TrainingSamplesEnd.Value;
-        IEnumerable<int> trainingRows = Enumerable.Range(trainingStart, trainingEnd - trainingStart);
         SymbolicRegressionScaledMeanSquaredErrorEvaluator.Calculate(SymbolicExpressionTreeInterpreter, bestTree,
           lowerEstimationLimit, upperEstimationLimit,
           ClassificationProblemData.Dataset, targetVariable,
-          trainingRows, out beta, out alpha);
+          ClassificationProblemData.TrainingIndizes, out beta, out alpha);
 
         // scale tree for solution
@@ -275 +273 @@
 
       IEnumerable<double> trainingValues = ClassificationProblemData.Dataset.GetEnumeratedVariableValues(
-        ClassificationProblemData.TargetVariable.Value,
-        ClassificationProblemData.TrainingSamplesStart.Value,
-        ClassificationProblemData.TrainingSamplesEnd.Value);
+        ClassificationProblemData.TargetVariable.Value, ClassificationProblemData.TrainingIndizes);
       IEnumerable<double> testValues = ClassificationProblemData.Dataset.GetEnumeratedVariableValues(
-        ClassificationProblemData.TargetVariable.Value,
-        ClassificationProblemData.TestSamplesStart.Value,
-        ClassificationProblemData.TestSamplesEnd.Value);
+        ClassificationProblemData.TargetVariable.Value, ClassificationProblemData.TestIndizes);
 
       OnlineAccuracyEvaluator accuracyEvaluator = new OnlineAccuracyEvaluator();

branches/HeuristicLab.Classification/HeuristicLab.Problems.DataAnalysis.Classification/3.3/Symbolic/SymbolicClassificationSolution.cs

@@ -62 +62 @@
 
       List<KeyValuePair<double, double>> estimatedTargetValues =
-         (from row in Enumerable.Range(ProblemData.TrainingSamplesStart.Value, ProblemData.TrainingSamplesEnd.Value - ProblemData.TrainingSamplesStart.Value)
+         (from row in ProblemData.TrainingIndizes
           select new KeyValuePair<double, double>(
             estimatedValues[row],
@@ -131 +131 @@
 
     public IEnumerable<double> EstimatedClassValues {
-      get {
-        double[] classValues = ProblemData.SortedClassValues.ToArray();
-        foreach (double value in EstimatedValues) {
-          int classIndex = 0;
-          while (value > actualThresholds[classIndex + 1])
-            classIndex++;
-          yield return classValues[classIndex];
-        }
-      }
+      get { return GetEstimatedClassValues(Enumerable.Range(0, ProblemData.Dataset.Rows)); }
     }
 
     public IEnumerable<double> EstimatedTrainingClassValues {
-      get {
-        int start = ProblemData.TrainingSamplesStart.Value;
-        int n = ProblemData.TrainingSamplesEnd.Value - start;
-        return EstimatedClassValues.Skip(start).Take(n).ToList();
-      }
+      get { return GetEstimatedClassValues(ProblemData.TrainingIndizes); }
     }
 
     public IEnumerable<double> EstimatedTestClassValues {
-      get {
-        int start = ProblemData.TestSamplesStart.Value;
-        int n = ProblemData.TestSamplesEnd.Value - start;
-        return EstimatedClassValues.Skip(start).Take(n).ToList();
+      get { return GetEstimatedClassValues(ProblemData.TestIndizes); }
+    }
+
+    public IEnumerable<double> GetEstimatedClassValues(IEnumerable<int> rows) {
+      double[] classValues = ProblemData.SortedClassValues.ToArray();
+      foreach (int row in rows) {
+        double value = estimatedValues[row];
+        int classIndex = 0;
+        while (value > actualThresholds[classIndex + 1])
+          classIndex++;
+        yield return classValues[classIndex];
       }
     }