Changeset 6566

Timestamp:

07/12/11 18:53:51 (13 years ago)

Author:

gkronber

Message:

#1581: implemented caching for SVM models.

Location:

trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4

Files:

• CrossValidation.cs (modified) (4 diffs)
• SupportVectorMachine/SupportVectorMachineModel.cs (modified) (2 diffs)

trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/CrossValidation.cs

@@ -363 +363 @@
 
     public void CollectResultValues(IDictionary<string, IItem> results) {
+      var clonedResults = (ResultCollection)this.results.Clone();
+      foreach (var result in clonedResults) {
+        results.Add(result.Name, result.Value);
+      }
+    }
+
+    private void AggregateResultValues(IDictionary<string, IItem> results) {
       Dictionary<string, List<double>> resultValues = new Dictionary<string, List<double>>();
       IEnumerable<IRun> runs = clonedAlgorithms.Select(alg => alg.Runs.FirstOrDefault()).Where(run => run != null);
@@ -397 +404 @@
       List<IResult> aggregatedResults = new List<IResult>();
       foreach (KeyValuePair<string, List<IRegressionSolution>> solutions in resultSolutions) {
-        var problemDataClone = (IRegressionProblemData)Problem.ProblemData.Clone();
+        // clone manually to correctly clone references between cloned root objects 
+        Cloner cloner = new Cloner();
+        var problemDataClone = (IRegressionProblemData)cloner.Clone(Problem.ProblemData);
+        // set partitions of problem data clone correctly
         problemDataClone.TrainingPartition.Start = SamplesStart.Value; problemDataClone.TrainingPartition.End = SamplesEnd.Value;
         problemDataClone.TestPartition.Start = SamplesStart.Value; problemDataClone.TestPartition.End = SamplesEnd.Value;
-        var ensembleSolution = new RegressionEnsembleSolution(solutions.Value.Select(x => x.Model), problemDataClone,
-          solutions.Value.Select(x => x.ProblemData.TrainingPartition),
-          solutions.Value.Select(x => x.ProblemData.TestPartition));
+        // clone models
+        var ensembleSolution = new RegressionEnsembleSolution(
+          solutions.Value.Select(x => cloner.Clone(x.Model)),
+          problemDataClone,
+          solutions.Value.Select(x => cloner.Clone(x.ProblemData.TrainingPartition)),
+          solutions.Value.Select(x => cloner.Clone(x.ProblemData.TestPartition)));
 
         aggregatedResults.Add(new Result(solutions.Key + " (ensemble)", ensembleSolution));
@@ -425 +438 @@
       var aggregatedResults = new List<IResult>();
       foreach (KeyValuePair<string, List<IClassificationSolution>> solutions in resultSolutions) {
-        var problemDataClone = (IClassificationProblemData)Problem.ProblemData.Clone();
+        // clone manually to correctly clone references between cloned root objects 
+        Cloner cloner = new Cloner();
+        var problemDataClone = (IClassificationProblemData)cloner.Clone(Problem.ProblemData);
+        // set partitions of problem data clone correctly
         problemDataClone.TrainingPartition.Start = SamplesStart.Value; problemDataClone.TrainingPartition.End = SamplesEnd.Value;
         problemDataClone.TestPartition.Start = SamplesStart.Value; problemDataClone.TestPartition.End = SamplesEnd.Value;
-        var ensembleSolution = new ClassificationEnsembleSolution(solutions.Value.Select(x => x.Model), problemDataClone,
-          solutions.Value.Select(x => x.ProblemData.TrainingPartition),
-          solutions.Value.Select(x => x.ProblemData.TestPartition));
+        // clone models
+        var ensembleSolution = new ClassificationEnsembleSolution(
+          solutions.Value.Select(x => cloner.Clone(x.Model)), 
+          problemDataClone,
+          solutions.Value.Select(x => cloner.Clone(x.ProblemData.TrainingPartition)),
+          solutions.Value.Select(x => cloner.Clone(x.ProblemData.TestPartition)));
 
         aggregatedResults.Add(new Result(solutions.Key + " (ensemble)", ensembleSolution));
@@ -702 +721 @@
       stopPending = false;
       Dictionary<string, IItem> collectedResults = new Dictionary<string, IItem>();
-      CollectResultValues(collectedResults);
+      AggregateResultValues(collectedResults);
       results.AddRange(collectedResults.Select(x => new Result(x.Key, x.Value)).Cast<IResult>().ToArray());
       runsCounter++;

trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorMachineModel.cs

@@ -98 +98 @@
       this.targetVariable = original.targetVariable;
       this.allowedInputVariables = (string[])original.allowedInputVariables.Clone();
+      foreach (var dataset in original.cachedPredictions.Keys) {
+        this.cachedPredictions.Add(cloner.Clone(dataset), (double[])original.cachedPredictions[dataset].Clone());
+      }
       if (original.classValues != null)
         this.classValues = (double[])original.classValues.Clone();
@@ -145 +148 @@
     }
     #endregion
+    // cache for predictions, which is cloned but not persisted, must be cleared when the model is changed
+    private Dictionary<Dataset, double[]> cachedPredictions = new Dictionary<Dataset, double[]>();
     private IEnumerable<double> GetEstimatedValuesHelper(Dataset dataset, IEnumerable<int> rows) {
+      if (!cachedPredictions.ContainsKey(dataset)) {
+        // create an array of cached predictions which is initially filled with NaNs
+        double[] predictions = Enumerable.Repeat(double.NaN, dataset.Rows).ToArray();
+        CalculatePredictions(dataset, rows, predictions);
+        cachedPredictions.Add(dataset, predictions);
+      }
+      // get the array of predictions and select the subset of requested rows
+      double[] p = cachedPredictions[dataset];
+      var requestedPredictions = from r in rows
+                                 select p[r];
+      // check if the requested predictions contain NaNs 
+      // (this means for the request rows some predictions have not been cached)
+      if (requestedPredictions.Any(x => double.IsNaN(x))) {
+        // updated the predictions for currently requested rows
+        CalculatePredictions(dataset, rows, p);
+        cachedPredictions[dataset] = p;
+        // now we can be sure that for the current rows all predictions are available
+        return from r in rows
+               select p[r];
+      } else {
+        // there were no NaNs => just return the cached predictions
+        return requestedPredictions;
+      }
+    }
+
+    private void CalculatePredictions(Dataset dataset, IEnumerable<int> rows, double[] predictions) {
+      // calculate and cache predictions for the currently requested rows
       SVM.Problem problem = SupportVectorMachineUtil.CreateSvmProblem(dataset, targetVariable, allowedInputVariables, rows);
       SVM.Problem scaledProblem = Scaling.Scale(RangeTransform, problem);
 
-      foreach (var row in Enumerable.Range(0, scaledProblem.Count)) {
-        yield return SVM.Prediction.Predict(Model, scaledProblem.X[row]);
-      }
-    }
+      // row is the index in the original dataset, 
+      // i is the index in the scaled dataset (containing only the necessary rows)
+      int i = 0;
+      foreach (var row in rows) {
+        predictions[row] = SVM.Prediction.Predict(Model, scaledProblem.X[i]);
+        i++;
+      }
+    }
+
     #region events
     public event EventHandler Changed;
     private void OnChanged(EventArgs e) {
+      cachedPredictions.Clear();
       var handlers = Changed;
       if (handlers != null)