Changeset 16036 for branches/2904_CalculateImpacts/3.4/Implementation/Regression/RegressionSolutionVariableImpactsCalculator.cs

Timestamp:

08/01/18 14:01:08 (3 years ago)

Author:

fholzing

Message:

#2904: Streamlined the variableimpactcalculator code on both Regression and Classification. Taken over the regression-code for classification with some minor adaptations.

File:

• branches/2904_CalculateImpacts/3.4/Implementation/Regression/RegressionSolutionVariableImpactsCalculator.cs (modified) (3 diffs)

branches/2904_CalculateImpacts/3.4/Implementation/Regression/RegressionSolutionVariableImpactsCalculator.cs

@@ -100 +100 @@
     #endregion
 
-    #region Public Methods/Wrappers
     //mkommend: annoying name clash with static method, open to better naming suggestions
     public IEnumerable<Tuple<string, double>> Calculate(IRegressionSolution solution) {
@@ -159 +158 @@
       ReplacementMethodEnum replacementMethod = ReplacementMethodEnum.Shuffle,
       FactorReplacementMethodEnum factorReplacementMethod = FactorReplacementMethodEnum.Best) {
-
       double impact = 0;
-
-      // calculate impacts for double variables
+      OnlineCalculatorError error;
+      IRandom random;
+      double replacementValue;
+      IEnumerable<double> newEstimates = null;
+      double newValue = 0;
+
       if (modifiableDataset.VariableHasType<double>(variableName)) {
-        impact = CalculateImpactForNumericalVariables(variableName, model, modifiableDataset, rows, targetValues, originalValue, replacementMethod);
+        #region NumericalVariable
+        var originalValues = modifiableDataset.GetReadOnlyDoubleValues(variableName).ToList();
+        List<double> replacementValues;
+
+        switch (replacementMethod) {
+          case ReplacementMethodEnum.Median:
+            replacementValue = rows.Select(r => originalValues[r]).Median();
+            replacementValues = Enumerable.Repeat(replacementValue, modifiableDataset.Rows).ToList();
+            break;
+          case ReplacementMethodEnum.Average:
+            replacementValue = rows.Select(r => originalValues[r]).Average();
+            replacementValues = Enumerable.Repeat(replacementValue, modifiableDataset.Rows).ToList();
+            break;
+          case ReplacementMethodEnum.Shuffle:
+            // new var has same empirical distribution but the relation to y is broken
+            random = new FastRandom(31415);
+            // prepare a complete column for the dataset
+            replacementValues = Enumerable.Repeat(double.NaN, modifiableDataset.Rows).ToList();
+            // shuffle only the selected rows
+            var shuffledValues = rows.Select(r => originalValues[r]).Shuffle(random).ToList();
+            int i = 0;
+            // update column values 
+            foreach (var r in rows) {
+              replacementValues[r] = shuffledValues[i++];
+            }
+            break;
+          case ReplacementMethodEnum.Noise:
+            var avg = rows.Select(r => originalValues[r]).Average();
+            var stdDev = rows.Select(r => originalValues[r]).StandardDeviation();
+            random = new FastRandom(31415);
+            // prepare a complete column for the dataset
+            replacementValues = Enumerable.Repeat(double.NaN, modifiableDataset.Rows).ToList();
+            // update column values 
+            foreach (var r in rows) {
+              replacementValues[r] = NormalDistributedRandom.NextDouble(random, avg, stdDev);
+            }
+            break;
+
+          default:
+            throw new ArgumentException(string.Format("ReplacementMethod {0} cannot be handled.", replacementMethod));
+        }
+
+        newEstimates = GetReplacedEstimates(originalValues, model, variableName, modifiableDataset, rows, replacementValues);
+        newValue = CalculateVariableImpact(targetValues, newEstimates, out error);
+        if (error != OnlineCalculatorError.None) { throw new InvalidOperationException("Error during calculation with replaced inputs."); }
+
+        impact = originalValue - newValue;
+        #endregion
       } else if (modifiableDataset.VariableHasType<string>(variableName)) {
-        impact = CalculateImpactForFactorVariables(variableName, model, modifiableDataset, rows, targetValues, originalValue, factorReplacementMethod);
+        #region FactorVariable
+        var originalValues = modifiableDataset.GetReadOnlyStringValues(variableName).ToList();
+        List<string> replacementValues;
+
+        switch (factorReplacementMethod) {
+          case FactorReplacementMethodEnum.Best:
+            // try replacing with all possible values and find the best replacement value
+            var smallestImpact = double.PositiveInfinity;
+            foreach (var repl in modifiableDataset.GetStringValues(variableName, rows).Distinct()) {
+              newEstimates = GetReplacedEstimates(originalValues, model, variableName, modifiableDataset, rows, Enumerable.Repeat(repl, modifiableDataset.Rows).ToList());
+              newValue = CalculateVariableImpact(targetValues, newEstimates, out error);
+              if (error != OnlineCalculatorError.None) throw new InvalidOperationException("Error during calculation with replaced inputs.");
+
+              var curImpact = originalValue - newValue;
+              if (curImpact < smallestImpact) smallestImpact = curImpact;
+            }
+            impact = smallestImpact;
+            break;
+          case FactorReplacementMethodEnum.Mode:
+            var mostCommonValue = rows.Select(r => originalValues[r])
+              .GroupBy(v => v)
+              .OrderByDescending(g => g.Count())
+              .First().Key;
+            replacementValues = Enumerable.Repeat(mostCommonValue, modifiableDataset.Rows).ToList();
+
+            newEstimates = GetReplacedEstimates(originalValues, model, variableName, modifiableDataset, rows, replacementValues);
+            newValue = CalculateVariableImpact(targetValues, newEstimates, out error);
+            if (error != OnlineCalculatorError.None) throw new InvalidOperationException("Error during calculation with replaced inputs.");
+
+            impact = originalValue - newValue;
+            break;
+          case FactorReplacementMethodEnum.Shuffle:
+            // new var has same empirical distribution but the relation to y is broken
+            random = new FastRandom(31415);
+            // prepare a complete column for the dataset
+            replacementValues = Enumerable.Repeat(string.Empty, modifiableDataset.Rows).ToList();
+            // shuffle only the selected rows
+            var shuffledValues = rows.Select(r => originalValues[r]).Shuffle(random).ToList();
+            int i = 0;
+            // update column values 
+            foreach (var r in rows) {
+              replacementValues[r] = shuffledValues[i++];
+            }
+
+            newEstimates = GetReplacedEstimates(originalValues, model, variableName, modifiableDataset, rows, replacementValues);
+            newValue = CalculateVariableImpact(targetValues, newEstimates, out error);
+            if (error != OnlineCalculatorError.None) throw new InvalidOperationException("Error during calculation with replaced inputs.");
+
+            impact = originalValue - newValue;
+            break;
+          default:
+            throw new ArgumentException(string.Format("FactorReplacementMethod {0} cannot be handled.", factorReplacementMethod));
+        }
+        #endregion
       } else {
         throw new NotSupportedException("Variable not supported");
       }
+
       return impact;
     }
-    #endregion
-
-    private static double CalculateImpactForNumericalVariables(string variableName,
-      IRegressionModel model,
-      ModifiableDataset modifiableDataset,
-      IEnumerable<int> rows,
-      IEnumerable<double> targetValues,
-      double originalValue,
-      ReplacementMethodEnum replacementMethod) {
-      OnlineCalculatorError error;
-      var newEstimates = GetReplacedValuesForNumericalVariables(model, variableName, modifiableDataset, rows, replacementMethod);
-      var newValue = CalculateVariableImpact(targetValues, newEstimates, out error);
-      if (error != OnlineCalculatorError.None) { throw new InvalidOperationException("Error during calculation with replaced inputs."); }
-      return originalValue - newValue;
-    }
-
-    private static double CalculateImpactForFactorVariables(string variableName,
-      IRegressionModel model,
-      ModifiableDataset modifiableDataset,
-      IEnumerable<int> rows,
-      IEnumerable<double> targetValues,
-      double originalValue,
-      FactorReplacementMethodEnum factorReplacementMethod) {
-
-      OnlineCalculatorError error;
-      if (factorReplacementMethod == FactorReplacementMethodEnum.Best) {
-        // try replacing with all possible values and find the best replacement value
-        var smallestImpact = double.PositiveInfinity;
-        foreach (var repl in modifiableDataset.GetStringValues(variableName, rows).Distinct()) {
-          var originalValues = modifiableDataset.GetReadOnlyStringValues(variableName).ToList();
-          var newEstimates = GetReplacedEstimates(originalValues, model, variableName, modifiableDataset, rows, Enumerable.Repeat(repl, modifiableDataset.Rows).ToList());
-          var newValue = CalculateVariableImpact(targetValues, newEstimates, out error);
-          if (error != OnlineCalculatorError.None) throw new InvalidOperationException("Error during calculation with replaced inputs.");
-
-          var curImpact = originalValue - newValue;
-          if (curImpact < smallestImpact) smallestImpact = curImpact;
-        }
-        return smallestImpact;
-      } else {
-        // for replacement methods shuffle and mode
-        // calculate impacts for factor variables
-        var newEstimates = GetReplacedValuesForFactorVariables(model, variableName, modifiableDataset, rows, factorReplacementMethod);
-        var newValue = CalculateVariableImpact(targetValues, newEstimates, out error);
-        if (error != OnlineCalculatorError.None) throw new InvalidOperationException("Error during calculation with replaced inputs.");
-
-        return originalValue - newValue;
-      }
-    }
-
-    private static IEnumerable<double> GetReplacedValuesForNumericalVariables(
-      IRegressionModel model,
-      string variable,
-      ModifiableDataset dataset,
-      IEnumerable<int> rows,
-      ReplacementMethodEnum replacement = ReplacementMethodEnum.Shuffle) {
-      var originalValues = dataset.GetReadOnlyDoubleValues(variable).ToList();
-      double replacementValue;
-      List<double> replacementValues;
-      IRandom rand;
-
-      switch (replacement) {
-        case ReplacementMethodEnum.Median:
-          replacementValue = rows.Select(r => originalValues[r]).Median();
-          replacementValues = Enumerable.Repeat(replacementValue, dataset.Rows).ToList();
-          break;
-        case ReplacementMethodEnum.Average:
-          replacementValue = rows.Select(r => originalValues[r]).Average();
-          replacementValues = Enumerable.Repeat(replacementValue, dataset.Rows).ToList();
-          break;
-        case ReplacementMethodEnum.Shuffle:
-          // new var has same empirical distribution but the relation to y is broken
-          rand = new FastRandom(31415);
-          // prepare a complete column for the dataset
-          replacementValues = Enumerable.Repeat(double.NaN, dataset.Rows).ToList();
-          // shuffle only the selected rows
-          var shuffledValues = rows.Select(r => originalValues[r]).Shuffle(rand).ToList();
-          int i = 0;
-          // update column values 
-          foreach (var r in rows) {
-            replacementValues[r] = shuffledValues[i++];
-          }
-          break;
-        case ReplacementMethodEnum.Noise:
-          var avg = rows.Select(r => originalValues[r]).Average();
-          var stdDev = rows.Select(r => originalValues[r]).StandardDeviation();
-          rand = new FastRandom(31415);
-          // prepare a complete column for the dataset
-          replacementValues = Enumerable.Repeat(double.NaN, dataset.Rows).ToList();
-          // update column values 
-          foreach (var r in rows) {
-            replacementValues[r] = NormalDistributedRandom.NextDouble(rand, avg, stdDev);
-          }
-          break;
-
-        default:
-          throw new ArgumentException(string.Format("ReplacementMethod {0} cannot be handled.", replacement));
-      }
-
-      return GetReplacedEstimates(originalValues, model, variable, dataset, rows, replacementValues);
-    }
-
-    private static IEnumerable<double> GetReplacedValuesForFactorVariables(
-      IRegressionModel model,
-      string variable,
-      ModifiableDataset dataset,
-      IEnumerable<int> rows,
-      FactorReplacementMethodEnum replacement = FactorReplacementMethodEnum.Shuffle) {
-      var originalValues = dataset.GetReadOnlyStringValues(variable).ToList();
-      List<string> replacementValues;
-      IRandom rand;
-
-      switch (replacement) {
-        case FactorReplacementMethodEnum.Mode:
-          var mostCommonValue = rows.Select(r => originalValues[r])
-            .GroupBy(v => v)
-            .OrderByDescending(g => g.Count())
-            .First().Key;
-          replacementValues = Enumerable.Repeat(mostCommonValue, dataset.Rows).ToList();
-          break;
-        case FactorReplacementMethodEnum.Shuffle:
-          // new var has same empirical distribution but the relation to y is broken
-          rand = new FastRandom(31415);
-          // prepare a complete column for the dataset
-          replacementValues = Enumerable.Repeat(string.Empty, dataset.Rows).ToList();
-          // shuffle only the selected rows
-          var shuffledValues = rows.Select(r => originalValues[r]).Shuffle(rand).ToList();
-          int i = 0;
-          // update column values 
-          foreach (var r in rows) {
-            replacementValues[r] = shuffledValues[i++];
-          }
-          break;
-        default:
-          throw new ArgumentException(string.Format("FactorReplacementMethod {0} cannot be handled.", replacement));
-      }
-
-      return GetReplacedEstimates(originalValues, model, variable, dataset, rows, replacementValues);
-    }
-
+
+    /// <summary>
+    /// Replaces the values of the original model-variables with the replacement variables, calculates the new estimated values 
+    /// and changes the value of the model-variables back to the original ones.
+    /// </summary>
+    /// <param name="originalValues"></param>
+    /// <param name="model"></param>
+    /// <param name="variableName"></param>
+    /// <param name="modifiableDataset"></param>
+    /// <param name="rows"></param>
+    /// <param name="replacementValues"></param>
+    /// <returns></returns>
     private static IEnumerable<double> GetReplacedEstimates(
       IList originalValues,
       IRegressionModel model,
-      string variable,
-      ModifiableDataset dataset,
+      string variableName,
+      ModifiableDataset modifiableDataset,
       IEnumerable<int> rows,
       IList replacementValues) {
-      dataset.ReplaceVariable(variable, replacementValues);
+      modifiableDataset.ReplaceVariable(variableName, replacementValues);
       //mkommend: ToList is used on purpose to avoid lazy evaluation that could result in wrong estimates due to variable replacements
-      var estimates = model.GetEstimatedValues(dataset, rows).ToList();
-      dataset.ReplaceVariable(variable, originalValues);
+      var estimates = model.GetEstimatedValues(modifiableDataset, rows).ToList();
+      modifiableDataset.ReplaceVariable(variableName, originalValues);
 
       return estimates;
     }
 
-    public static double CalculateVariableImpact(IEnumerable<double> originalValues, IEnumerable<double> estimatedValues, out OnlineCalculatorError errorState) {
-      IEnumerator<double> firstEnumerator = originalValues.GetEnumerator();
+    /// <summary>
+    /// Calculates and returns the VariableImpact (calculated via Pearsons R²).
+    /// </summary>
+    /// <param name="targetValues">The actual values</param>
+    /// <param name="estimatedValues">The calculated/replaced values</param>
+    /// <param name="errorState"></param>
+    /// <returns></returns>
+    public static double CalculateVariableImpact(IEnumerable<double> targetValues, IEnumerable<double> estimatedValues, out OnlineCalculatorError errorState) {
+      //Theoretically, all calculators implement a static Calculate-Method which provides the same functionality
+      //as the code below does. But this way we can easily swap the calculator later on, so the user  
+      //could choose a Calculator during runtime in future versions.
+      IOnlineCalculator calculator = new OnlinePearsonsRSquaredCalculator();
+      IEnumerator<double> firstEnumerator = targetValues.GetEnumerator();
       IEnumerator<double> secondEnumerator = estimatedValues.GetEnumerator();
-      var calculator = new OnlinePearsonsRSquaredCalculator();
 
       // always move forward both enumerators (do not use short-circuit evaluation!)
@@ -349 +335 @@
     }
 
+    /// <summary>
+    /// Returns a collection of the row-indices for a given DataPartition (training or test)
+    /// </summary>
+    /// <param name="dataPartition"></param>
+    /// <param name="problemData"></param>
+    /// <returns></returns>
     public static IEnumerable<int> GetPartitionRows(DataPartitionEnum dataPartition, IRegressionProblemData problemData) {
       IEnumerable<int> rows;