source: branches/2904_CalculateImpacts/3.4/Implementation/Regression/RegressionSolutionVariableImpactsCalculator.cs @ 16002

Last change on this file since 16002 was 16002, checked in by fholzing, 3 years ago

#2904: Fixed static Property

File size: 17.7 KB
Line 
1#region License Information
2
3/* HeuristicLab
4 * Copyright (C) 2002-2018 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
5 *
6 * This file is part of HeuristicLab.
7 *
8 * HeuristicLab is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * (at your option) any later version.
12 *
13 * HeuristicLab is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
20 */
21
22#endregion
23
24using System;
25using System.Collections;
26using System.Collections.Generic;
27using System.Linq;
28using HeuristicLab.Common;
29using HeuristicLab.Core;
30using HeuristicLab.Data;
31using HeuristicLab.Parameters;
32using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
33using HeuristicLab.Random;
34
35namespace HeuristicLab.Problems.DataAnalysis {
36  [StorableClass]
37  [Item("RegressionSolution Impacts Calculator", "Calculation of the impacts of input variables for any regression solution")]
38  public sealed class RegressionSolutionVariableImpactsCalculator : ParameterizedNamedItem {
39    public enum ReplacementMethodEnum {
40      Median,
41      Average,
42      Shuffle,
43      Noise
44    }
45    public enum FactorReplacementMethodEnum {
46      Best,
47      Mode,
48      Shuffle
49    }
50    public enum DataPartitionEnum {
51      Training,
52      Test,
53      All
54    }
55
56    //The PerasonsR²-Calculator is the default, but can be overwritten to any other IOnlineCalculator
57    //Just remember to reset it after you're done
58    private static IOnlineCalculator calculator = new OnlinePearsonsRSquaredCalculator();
59    public static IOnlineCalculator Calculator
60    {
61      get { return calculator; }
62      set { calculator = value; }
63    }
64
65    private const string ReplacementParameterName = "Replacement Method";
66    private const string DataPartitionParameterName = "DataPartition";
67
68    public IFixedValueParameter<EnumValue<ReplacementMethodEnum>> ReplacementParameter
69    {
70      get { return (IFixedValueParameter<EnumValue<ReplacementMethodEnum>>)Parameters[ReplacementParameterName]; }
71    }
72    public IFixedValueParameter<EnumValue<DataPartitionEnum>> DataPartitionParameter
73    {
74      get { return (IFixedValueParameter<EnumValue<DataPartitionEnum>>)Parameters[DataPartitionParameterName]; }
75    }
76
77    public ReplacementMethodEnum ReplacementMethod
78    {
79      get { return ReplacementParameter.Value.Value; }
80      set { ReplacementParameter.Value.Value = value; }
81    }
82    public DataPartitionEnum DataPartition
83    {
84      get { return DataPartitionParameter.Value.Value; }
85      set { DataPartitionParameter.Value.Value = value; }
86    }
87
88
89    [StorableConstructor]
90    private RegressionSolutionVariableImpactsCalculator(bool deserializing) : base(deserializing) { }
91    private RegressionSolutionVariableImpactsCalculator(RegressionSolutionVariableImpactsCalculator original, Cloner cloner)
92      : base(original, cloner) { }
93    public override IDeepCloneable Clone(Cloner cloner) {
94      return new RegressionSolutionVariableImpactsCalculator(this, cloner);
95    }
96
97    public RegressionSolutionVariableImpactsCalculator()
98      : base() {
99      Parameters.Add(new FixedValueParameter<EnumValue<ReplacementMethodEnum>>(ReplacementParameterName, "The replacement method for variables during impact calculation.", new EnumValue<ReplacementMethodEnum>(ReplacementMethodEnum.Median)));
100      Parameters.Add(new FixedValueParameter<EnumValue<DataPartitionEnum>>(DataPartitionParameterName, "The data partition on which the impacts are calculated.", new EnumValue<DataPartitionEnum>(DataPartitionEnum.Training)));
101    }
102
103    //mkommend: annoying name clash with static method, open to better naming suggestions
104    public IEnumerable<Tuple<string, double>> Calculate(IRegressionSolution solution) {
105      return CalculateImpacts(solution, DataPartition, ReplacementMethod);
106    }
107
108    public static IEnumerable<Tuple<string, double>> CalculateImpacts(
109      IRegressionSolution solution,
110      DataPartitionEnum data = DataPartitionEnum.Training,
111      ReplacementMethodEnum replacementMethod = ReplacementMethodEnum.Median,
112      FactorReplacementMethodEnum factorReplacementMethod = FactorReplacementMethodEnum.Best,
113      Func<double, string, bool> progressCallback = null) {
114      return CalculateImpacts(solution.Model, solution.ProblemData, solution.EstimatedValues, data, replacementMethod, factorReplacementMethod, progressCallback);
115    }
116
117    public static IEnumerable<Tuple<string, double>> CalculateImpacts(
118      IRegressionModel model,
119      IRegressionProblemData problemData,
120      IEnumerable<double> estimatedValues,
121      DataPartitionEnum data = DataPartitionEnum.Training,
122      ReplacementMethodEnum replacementMethod = ReplacementMethodEnum.Median,
123      FactorReplacementMethodEnum factorReplacementMethod = FactorReplacementMethodEnum.Best,
124      Func<double, string, bool> progressCallback = null) {
125      IEnumerable<int> rows;
126
127      switch (data) {
128        case DataPartitionEnum.All:
129          rows = problemData.AllIndices;
130          break;
131        case DataPartitionEnum.Test:
132          rows = problemData.TestIndices;
133          break;
134        case DataPartitionEnum.Training:
135          rows = problemData.TrainingIndices;
136          break;
137        default:
138          throw new NotSupportedException("DataPartition not supported");
139      }
140
141      return CalculateImpacts(model, problemData, estimatedValues, rows, replacementMethod, factorReplacementMethod, progressCallback);
142    }
143
144    public static IEnumerable<Tuple<string, double>> CalculateImpacts(
145     IRegressionModel model,
146     IRegressionProblemData problemData,
147     IEnumerable<double> estimatedValues,
148     IEnumerable<int> rows,
149     ReplacementMethodEnum replacementMethod = ReplacementMethodEnum.Median,
150     FactorReplacementMethodEnum factorReplacementMethod = FactorReplacementMethodEnum.Best,
151     Func<double, string, bool> progressCallback = null) {
152
153      IEnumerable<double> targetValues;
154      double originalValue = -1;
155
156      PrepareData(rows, problemData, estimatedValues, out targetValues, out originalValue);
157
158      var impacts = new Dictionary<string, double>();
159      var inputvariables = new HashSet<string>(problemData.AllowedInputVariables.Union(model.VariablesUsedForPrediction));
160      var allowedInputVariables = problemData.Dataset.VariableNames.Where(v => inputvariables.Contains(v)).ToList();
161
162      int curIdx = 0;
163      int count = allowedInputVariables
164        .Where(v => problemData.Dataset.VariableHasType<double>(v) || problemData.Dataset.VariableHasType<string>(v))
165        .Count();
166
167      foreach (var inputVariable in allowedInputVariables) {
168        //Report the current progress in percent. If the callback returns true, it means the execution shall be stopped
169        if (progressCallback != null) {
170          curIdx++;
171          if (progressCallback((double)curIdx / count, string.Format("Calculating impact for variable {0} ({1} of {2})", inputVariable, curIdx, count))) { return null; }
172        }
173        impacts[inputVariable] = CalculateImpact(inputVariable, model, problemData.Dataset, rows, targetValues, originalValue, replacementMethod, factorReplacementMethod);
174      }
175
176      return impacts.OrderByDescending(i => i.Value).Select(i => Tuple.Create(i.Key, i.Value));
177    }
178
179    public static double CalculateImpact(string variableName,
180      IRegressionSolution solution,
181      IEnumerable<int> rows,
182      IEnumerable<double> targetValues,
183      double originalValue,
184      DataPartitionEnum data = DataPartitionEnum.Training,
185      ReplacementMethodEnum replacementMethod = ReplacementMethodEnum.Median,
186      FactorReplacementMethodEnum factorReplacementMethod = FactorReplacementMethodEnum.Best) {
187      return CalculateImpact(variableName, solution.Model, solution.ProblemData.Dataset, rows, targetValues, originalValue, replacementMethod, factorReplacementMethod);
188    }
189
190    public static double CalculateImpact(string variableName,
191      IRegressionModel model,
192      IDataset dataset,
193      IEnumerable<int> rows,
194      IEnumerable<double> targetValues,
195      double originalValue,
196      ReplacementMethodEnum replacementMethod = ReplacementMethodEnum.Median,
197      FactorReplacementMethodEnum factorReplacementMethod = FactorReplacementMethodEnum.Best) {
198
199      double impact = 0;
200      var modifiableDataset = ((Dataset)dataset).ToModifiable();
201
202      // calculate impacts for double variables
203      if (dataset.VariableHasType<double>(variableName)) {
204        impact = CalculateImpactForDouble(variableName, model, modifiableDataset, rows, targetValues, originalValue, replacementMethod);
205      } else if (dataset.VariableHasType<string>(variableName)) {
206        impact = CalculateImpactForString(variableName, model, dataset, modifiableDataset, rows, targetValues, originalValue, factorReplacementMethod);
207      } else {
208        throw new NotSupportedException("Variable not supported");
209      }
210      return impact;
211    }
212
213    private static void PrepareData(IEnumerable<int> rows,
214      IRegressionProblemData problemData,
215      IEnumerable<double> estimatedValues,
216      out IEnumerable<double> targetValues,
217      out double originalValue) {
218      OnlineCalculatorError error;
219
220      var targetVariableValueList = problemData.TargetVariableValues.ToList();
221      targetValues = rows.Select(v => targetVariableValueList.ElementAt(v));
222      var estimatedValuesPartition = rows.Select(v => estimatedValues.ElementAt(v));
223      originalValue = CalculateValue(targetValues, estimatedValuesPartition, out error);
224
225      if (error != OnlineCalculatorError.None) throw new InvalidOperationException("Error during calculation.");
226    }
227
228    private static double CalculateImpactForDouble(string variableName,
229      IRegressionModel model,
230      ModifiableDataset modifiableDataset,
231      IEnumerable<int> rows,
232      IEnumerable<double> targetValues,
233      double originalValue,
234      ReplacementMethodEnum replacementMethod) {
235      OnlineCalculatorError error;
236      var newEstimates = EvaluateModelWithReplacedVariable(model, variableName, modifiableDataset, rows, replacementMethod);
237      var newValue = CalculateValue(targetValues, newEstimates, out error);
238      if (error != OnlineCalculatorError.None) { throw new InvalidOperationException("Error during calculation with replaced inputs."); }
239      return originalValue - newValue;
240    }
241
242    private static double CalculateImpactForString(string variableName,
243      IRegressionModel model,
244      IDataset problemData,
245      ModifiableDataset modifiableDataset,
246      IEnumerable<int> rows,
247      IEnumerable<double> targetValues,
248      double originalValue,
249      FactorReplacementMethodEnum factorReplacementMethod) {
250
251      OnlineCalculatorError error;
252      if (factorReplacementMethod == FactorReplacementMethodEnum.Best) {
253        // try replacing with all possible values and find the best replacement value
254        var smallestImpact = double.PositiveInfinity;
255        foreach (var repl in problemData.GetStringValues(variableName, rows).Distinct()) {
256          var originalValues = modifiableDataset.GetReadOnlyStringValues(variableName).ToList();
257          var newEstimates = EvaluateModelWithReplacedVariable(originalValues, model, variableName, modifiableDataset, rows, Enumerable.Repeat(repl, problemData.Rows).ToList());
258          var newValue = CalculateValue(targetValues, newEstimates, out error);
259          if (error != OnlineCalculatorError.None) throw new InvalidOperationException("Error during calculation with replaced inputs.");
260
261          var curImpact = originalValue - newValue;
262          if (curImpact < smallestImpact) smallestImpact = curImpact;
263        }
264        return smallestImpact;
265      } else {
266        // for replacement methods shuffle and mode
267        // calculate impacts for factor variables
268        var newEstimates = EvaluateModelWithReplacedVariable(model, variableName, modifiableDataset, rows, factorReplacementMethod);
269        var newValue = CalculateValue(targetValues, newEstimates, out error);
270        if (error != OnlineCalculatorError.None) throw new InvalidOperationException("Error during calculation with replaced inputs.");
271
272        return originalValue - newValue;
273      }
274    }
275
276    private static IEnumerable<double> EvaluateModelWithReplacedVariable(IRegressionModel model, string variable, ModifiableDataset dataset, IEnumerable<int> rows, ReplacementMethodEnum replacement = ReplacementMethodEnum.Median) {
277      var originalValues = dataset.GetReadOnlyDoubleValues(variable).ToList();
278      double replacementValue;
279      List<double> replacementValues;
280      IRandom rand;
281
282      switch (replacement) {
283        case ReplacementMethodEnum.Median:
284          replacementValue = rows.Select(r => originalValues[r]).Median();
285          replacementValues = Enumerable.Repeat(replacementValue, dataset.Rows).ToList();
286          break;
287        case ReplacementMethodEnum.Average:
288          replacementValue = rows.Select(r => originalValues[r]).Average();
289          replacementValues = Enumerable.Repeat(replacementValue, dataset.Rows).ToList();
290          break;
291        case ReplacementMethodEnum.Shuffle:
292          // new var has same empirical distribution but the relation to y is broken
293          rand = new FastRandom(31415);
294          // prepare a complete column for the dataset
295          replacementValues = Enumerable.Repeat(double.NaN, dataset.Rows).ToList();
296          // shuffle only the selected rows
297          var shuffledValues = rows.Select(r => originalValues[r]).Shuffle(rand).ToList();
298          int i = 0;
299          // update column values
300          foreach (var r in rows) {
301            replacementValues[r] = shuffledValues[i++];
302          }
303          break;
304        case ReplacementMethodEnum.Noise:
305          var avg = rows.Select(r => originalValues[r]).Average();
306          var stdDev = rows.Select(r => originalValues[r]).StandardDeviation();
307          rand = new FastRandom(31415);
308          // prepare a complete column for the dataset
309          replacementValues = Enumerable.Repeat(double.NaN, dataset.Rows).ToList();
310          // update column values
311          foreach (var r in rows) {
312            replacementValues[r] = NormalDistributedRandom.NextDouble(rand, avg, stdDev);
313          }
314          break;
315
316        default:
317          throw new ArgumentException(string.Format("ReplacementMethod {0} cannot be handled.", replacement));
318      }
319
320      return EvaluateModelWithReplacedVariable(originalValues, model, variable, dataset, rows, replacementValues);
321    }
322
323    private static IEnumerable<double> EvaluateModelWithReplacedVariable(
324      IRegressionModel model, string variable, ModifiableDataset dataset,
325      IEnumerable<int> rows,
326      FactorReplacementMethodEnum replacement = FactorReplacementMethodEnum.Shuffle) {
327      var originalValues = dataset.GetReadOnlyStringValues(variable).ToList();
328      List<string> replacementValues;
329      IRandom rand;
330
331      switch (replacement) {
332        case FactorReplacementMethodEnum.Mode:
333          var mostCommonValue = rows.Select(r => originalValues[r])
334            .GroupBy(v => v)
335            .OrderByDescending(g => g.Count())
336            .First().Key;
337          replacementValues = Enumerable.Repeat(mostCommonValue, dataset.Rows).ToList();
338          break;
339        case FactorReplacementMethodEnum.Shuffle:
340          // new var has same empirical distribution but the relation to y is broken
341          rand = new FastRandom(31415);
342          // prepare a complete column for the dataset
343          replacementValues = Enumerable.Repeat(string.Empty, dataset.Rows).ToList();
344          // shuffle only the selected rows
345          var shuffledValues = rows.Select(r => originalValues[r]).Shuffle(rand).ToList();
346          int i = 0;
347          // update column values
348          foreach (var r in rows) {
349            replacementValues[r] = shuffledValues[i++];
350          }
351          break;
352        default:
353          throw new ArgumentException(string.Format("FactorReplacementMethod {0} cannot be handled.", replacement));
354      }
355
356      return EvaluateModelWithReplacedVariable(originalValues, model, variable, dataset, rows, replacementValues);
357    }
358
359    private static IEnumerable<double> EvaluateModelWithReplacedVariable(IList originalValues, IRegressionModel model, string variable,
360      ModifiableDataset dataset, IEnumerable<int> rows, IList replacementValues) {
361      dataset.ReplaceVariable(variable, replacementValues);
362      //mkommend: ToList is used on purpose to avoid lazy evaluation that could result in wrong estimates due to variable replacements
363      var estimates = model.GetEstimatedValues(dataset, rows).ToList();
364      dataset.ReplaceVariable(variable, originalValues);
365
366      return estimates;
367    }
368
369    private static double CalculateValue(IEnumerable<double> targets, IEnumerable<double> estimates, out OnlineCalculatorError error) {
370      calculator.Reset();
371      if (targets.Count() != estimates.Count()) {
372        throw new ArgumentException(string.Format("Targets and Estimates must be of equal length ({0},{1})", targets.Count(), estimates.Count()));
373      }
374      foreach (var entry in targets.Zip(estimates, (target, estimate) => new { target, estimate })) {
375        calculator.Add(entry.target, entry.estimate);
376      }
377      error = calculator.ErrorState;
378      return calculator.Value;
379    }
380  }
381}
Note: See TracBrowser for help on using the repository browser.