Changeset 2041 for trunk/sources/HeuristicLab.Modeling

Timestamp:

06/10/09 19:05:34 (16 years ago)

Author:

gkronber

Message:

Implemented base classes for variable impact analysis and implemented specific operators for GP. #644 (Variable impact of CEDMA models should be calculated and stored in the result DB)

Location:

trunk/sources/HeuristicLab.Modeling/3.2

Files:

• HeuristicLab.Modeling-3.2.csproj (modified) (1 diff)
• IModel.cs (modified) (1 diff)
• Model.cs (modified) (2 diffs)
• VariableEvaluationImpactCalculator.cs (added)
• VariableImpactCalculatorBase.cs (added)
• VariableQualityImpactCalculator.cs (modified) (1 diff)

trunk/sources/HeuristicLab.Modeling/3.2/HeuristicLab.Modeling-3.2.csproj

@@ -83 +83 @@
   <ItemGroup>
     <Compile Include="ClassificationProblemInjector.cs" />
+    <Compile Include="VariableImpactCalculatorBase.cs" />
+    <Compile Include="VariableEvaluationImpactCalculator.cs" />
     <Compile Include="Model.cs" />
     <Compile Include="IModel.cs" />

trunk/sources/HeuristicLab.Modeling/3.2/IModel.cs

@@ -45 +45 @@
     double ValidationVarianceAccountedFor { get; }
     double TestVarianceAccountedFor { get; }
-    double GetVariableImpact(string variableName);
+    double GetVariableEvaluationImpact(string variableName);
+    double GetVariableQualityImpact(string variableName);
 
     IItem Data { get; }

trunk/sources/HeuristicLab.Modeling/3.2/Model.cs

@@ -120 +120 @@
     }
 
-    public double GetVariableImpact(string variableName) {
-      if (variableImpacts.ContainsKey(variableName)) return variableImpacts[variableName];
+    public double GetVariableQualityImpact(string variableName) {
+      if (variableQualityImpacts.ContainsKey(variableName)) return variableQualityImpacts[variableName];
+      else return 1.0;
+    }
+
+    public double GetVariableEvaluationImpact(string variableName) {
+      if (variableEvaluationImpacts.ContainsKey(variableName)) return variableEvaluationImpacts[variableName];
       else return 0.0;
     }
@@ -133 +138 @@
     #endregion
 
-    private Dictionary<string, double> variableImpacts = new Dictionary<string, double>();
-    public void SetVariableImpact(string variableName, double impact) {
-      variableImpacts[variableName] = impact;
+    private Dictionary<string, double> variableQualityImpacts = new Dictionary<string, double>();
+    public void SetVariableQualityImpact(string variableName, double impact) {
+      variableQualityImpacts[variableName] = impact;
     }
 
-    public void SetVariableImpact(int variableIndex, double impact) {
-      variableImpacts[dataset.GetVariableName(variableIndex)] = impact;
+    public void SetVariableQualityImpact(int variableIndex, double impact) {
+      variableQualityImpacts[dataset.GetVariableName(variableIndex)] = impact;
+    }
+
+    private Dictionary<string, double> variableEvaluationImpacts = new Dictionary<string, double>();
+    public void SetVariableEvaluationImpact(string variableName, double impact) {
+      variableEvaluationImpacts[variableName] = impact;
+    }
+
+    public void SetVariableEvaluationImpact(int variableIndex, double impact) {
+      variableEvaluationImpacts[dataset.GetVariableName(variableIndex)] = impact;
     }
   }

trunk/sources/HeuristicLab.Modeling/3.2/VariableQualityImpactCalculator.cs

@@ -30 +30 @@
 
 namespace HeuristicLab.Modeling {
-  public class VariableQualityImpactCalculator : OperatorBase {
+  public abstract class VariableQualityImpactCalculator : VariableImpactCalculatorBase<double> {
     public override string Description {
       get { return @"Calculates the impact of all allowed input variables on the quality of the model using evaluator supplied as suboperator."; }
     }
 
-    public VariableQualityImpactCalculator()
-      : base() {
-      AddVariableInfo(new VariableInfo("Dataset", "Dataset", typeof(Dataset), VariableKind.In));
-      AddVariableInfo(new VariableInfo("TargetVariable", "TargetVariable", typeof(IntData), VariableKind.In));
-      AddVariableInfo(new VariableInfo("AllowedFeatures", "Indexes of allowed input variables", typeof(ItemList<IntData>), VariableKind.In));
-      AddVariableInfo(new VariableInfo("TrainingSamplesStart", "TrainingSamplesStart", typeof(IntData), VariableKind.In));
-      AddVariableInfo(new VariableInfo("TrainingSamplesEnd", "TrainingSamplesEnd", typeof(IntData), VariableKind.In));
-      AddVariableInfo(new VariableInfo("VariableQualityImpacts", "Effect on quality of model (percentage of original quality) if variable is replaced by its mean.", typeof(ItemList), VariableKind.New));
+    public override string OutputVariableName {
+      get { return "VariableQualityImpacts"; }
     }
 
-    public override IOperation Apply(IScope scope) {
-      ItemList<IntData> allowedFeatures = GetVariableValue<ItemList<IntData>>("AllowedFeatures", scope, true);
-      int targetVariable = GetVariableValue<IntData>("TargetVariable", scope, true).Data;
-      Dataset dataset = GetVariableValue<Dataset>("Dataset", scope, true);
-      Dataset dirtyDataset = (Dataset)dataset.Clone();
-      int start = GetVariableValue<IntData>("TrainingSamplesStart", scope, true).Data;
-      int end = GetVariableValue<IntData>("TrainingSamplesEnd", scope, true).Data;
-
-      if (SubOperators.Count < 1) throw new InvalidOperationException("VariableQualityImpactCalculator needs a suboperator to evaluate the model");
-      IOperator evaluationOperator = this.SubOperators[0];
-      ItemList variableQualityImpacts = new ItemList();
-
-      // calculateReferenceQuality
-      double referenceQuality = CalculateQuality(scope, dataset, evaluationOperator);
-
-      for (int i = 0; i < allowedFeatures.Count; i++) {
-        int currentVariable = allowedFeatures[i].Data;
-        var oldValues = ReplaceVariableValues(dirtyDataset, currentVariable , CalculateNewValues(dirtyDataset, currentVariable, start, end), start, end);
-        double newQuality = CalculateQuality(scope, dirtyDataset, evaluationOperator);
-        double ratio = newQuality / referenceQuality;
-        ItemList row = new ItemList();
-        row.Add(new StringData(dataset.GetVariableName(currentVariable)));
-        row.Add(new DoubleData(ratio));
-        variableQualityImpacts.Add(row);
-        ReplaceVariableValues(dirtyDataset, currentVariable, oldValues, start, end);
-      }
-      scope.AddVariable(new Variable(scope.TranslateName("VariableQualityImpacts"), variableQualityImpacts));
-      return null;
+    protected override double CalculateImpact(double referenceValue, double newValue) {
+      return newValue / referenceValue;
     }
 
-    private double CalculateQuality(IScope scope, Dataset dataset, IOperator evaluationOperator) {
-      Scope s = new Scope();
-      s.AddVariable(new Variable("Dataset", dataset));
-      scope.AddSubScope(s);
-      evaluationOperator.Execute(s);
-      double quality = s.GetVariableValue<DoubleData>("Quality", false).Data;
-      scope.RemoveSubScope(s);
-      return quality;
+    protected override double CalculateValue(IScope scope, Dataset dataset, int targetVariable, int start, int end) {
+      return CalculateQuality(scope, dataset, targetVariable, start, end);
     }
 
-    private IEnumerable<double> ReplaceVariableValues(Dataset ds, int variableIndex, IEnumerable<double> newValues, int start, int end) {
-      double[] oldValues = new double[end - start];
-      for (int i = 0; i < end - start; i++) oldValues[i] = ds.GetValue(i + start, variableIndex);
-      if (newValues.Count() != end - start) throw new ArgumentException("The length of the new values sequence doesn't match the required length (number of replaced values)");
-
-      int index = start;
-      ds.FireChangeEvents = false;
-      foreach(double v in newValues) {
-        ds.SetValue(index++, variableIndex, v);
-      }
-      ds.FireChangeEvents = true;
-      ds.FireChanged();
-      return oldValues;
-    }
-
-    private IEnumerable<double> CalculateNewValues(Dataset ds, int variableIndex, int start, int end) {
-      double mean = ds.GetMean(variableIndex, start, end);
-      return Enumerable.Repeat(mean, end - start);
-    }
+    protected abstract double CalculateQuality(IScope scope, Dataset dataset, int targetVariable, int start, int end);
   }
 }