Changeset 3905

Timestamp:

06/08/10 17:47:15 (14 years ago)

Author:

gkronber

Message:

Implemented calculation of variable impacts as integral over relative variable frequencies. #1036

Location:

trunk/sources

Files:

• HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/SymbolicExpressionTreeNode.cs (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis.Regression/3.3/Analyzers/RegressionSolutionAnalyzer.cs (modified) (6 diffs)
• HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/Analyzers/BestSymbolicRegressionSolutionAnalyzer.cs (modified) (6 diffs)
• HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/Analyzers/SymbolicRegressionVariableFrequencyAnalyzer.cs (modified) (2 diffs)

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/SymbolicExpressionTreeNode.cs

@@ -121 +121 @@
 
     public IEnumerable<SymbolicExpressionTreeNode> IterateNodesPrefix() {
-      return (new SymbolicExpressionTreeNode[] { this })
-        .Concat(SubTrees.SelectMany(tree => tree.IterateNodesPrefix()));
+      if (SubTrees != null) {
+        return (new SymbolicExpressionTreeNode[] { this })
+          .Concat(SubTrees.SelectMany(tree => tree.IterateNodesPrefix()));
+      } else {
+        return new SymbolicExpressionTreeNode[] { this };
+      }
     }
 
     public IEnumerable<SymbolicExpressionTreeNode> IterateNodesPostfix() {
-      return SubTrees.SelectMany(tree => tree.IterateNodesPrefix())
-        .Concat(new SymbolicExpressionTreeNode[] { this });
+      if (SubTrees != null) {
+        return SubTrees.SelectMany(tree => tree.IterateNodesPrefix())
+          .Concat(new SymbolicExpressionTreeNode[] { this });
+      } else {
+        return new SymbolicExpressionTreeNode[] { this };
+      }
     }
     public IEnumerable<Symbol> GetAllowedSymbols(int argumentIndex) {

trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Analyzers/RegressionSolutionAnalyzer.cs

@@ -44 +44 @@
     private const string LowerEstimationLimitParameterName = "LowerEstimationLimit";
     private const string BestSolutionQualityParameterName = "BestSolutionQuality";
+    private const string GenerationsParameterName = "Generations";
     private const string ResultsParameterName = "Results";
     private const string BestSolutionResultName = "Best solution (on validiation set)";
@@ -52 +53 @@
     private const string BestSolutionTrainingRelativeError = "Best solution average relative error (training)";
     private const string BestSolutionTestRelativeError = "Best solution average relative error (test)";
+    private const string BestSolutionGeneration = "Best solution generation";
 
     #region parameter properties
@@ -71 +73 @@
     public ILookupParameter<ResultCollection> ResultsParameter {
       get { return (ILookupParameter<ResultCollection>)Parameters[ResultsParameterName]; }
+    }
+    public ILookupParameter<IntValue> GenerationsParameter {
+      get {
+        return (ILookupParameter<IntValue>)Parameters[GenerationsParameterName];
+      }
     }
     #endregion
@@ -98 +105 @@
       Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>(QualityParameterName, "The qualities of the symbolic regression trees which should be analyzed."));
       Parameters.Add(new LookupParameter<DoubleValue>(BestSolutionQualityParameterName, "The quality of the best regression solution."));
+      Parameters.Add(new LookupParameter<IntValue>(GenerationsParameterName, "The number of generations calculated so far."));
       Parameters.Add(new LookupParameter<ResultCollection>(ResultsParameterName, "The result collection where the best symbolic regression solution should be stored."));
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    public void Initialize() {
+      // backwards compatibility
+      if (!Parameters.ContainsKey(GenerationsParameterName)) {
+        Parameters.Add(new LookupParameter<IntValue>(GenerationsParameterName, "The number of generations calculated so far."));
+      }
     }
 
@@ -135 +151 @@
         Results[BestSolutionTrainingRelativeError].Value = new DoubleValue(trainingRelError);
         Results[BestSolutionTestRelativeError].Value = new DoubleValue(testRelError);
+        Results[BestSolutionGeneration].Value = new IntValue(GenerationsParameter.ActualValue.Value);
       } else {
         Results.Add(new Result(BestSolutionResultName, solution));
@@ -143 +160 @@
         Results.Add(new Result(BestSolutionTrainingRelativeError, new DoubleValue(trainingRelError)));
         Results.Add(new Result(BestSolutionTestRelativeError, new DoubleValue(testRelError)));
+        Results.Add(new Result(BestSolutionGeneration, new IntValue(GenerationsParameter.ActualValue.Value)));
       }
       #endregion

trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/Analyzers/BestSymbolicRegressionSolutionAnalyzer.cs

@@ -35 +35 @@
 using HeuristicLab.Problems.DataAnalysis;
 using HeuristicLab.Problems.DataAnalysis.Evaluators;
+using HeuristicLab.Analysis;
 
 namespace HeuristicLab.Problems.DataAnalysis.Regression.Symbolic.Analyzers {
@@ -43 +44 @@
     private const string SymbolicExpressionTreeInterpreterParameterName = "SymbolicExpressionTreeInterpreter";
     private const string BestSolutionInputvariableCountResultName = "Variables used by best solution";
+    private const string VariableFrequenciesParameterName = "VariableFrequencies";
+    private const string VariableImpactsResultName = "Integrated variable frequencies";
     private const string BestSolutionParameterName = "BestSolution";
 
@@ -55 +58 @@
       get { return (ILookupParameter<SymbolicRegressionSolution>)Parameters[BestSolutionParameterName]; }
     }
+    public ILookupParameter<DataTable> VariableFrequenciesParameter {
+      get { return (ILookupParameter<DataTable>)Parameters[VariableFrequenciesParameterName]; }
+    }
     #endregion
     #region properties
@@ -63 +69 @@
       get { return SymbolicExpressionTreeParameter.ActualValue; }
     }
+    public DataTable VariableFrequencies {
+      get { return VariableFrequenciesParameter.ActualValue; }
+    }
     #endregion
 
@@ -69 +78 @@
       Parameters.Add(new ScopeTreeLookupParameter<SymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic expression trees to analyze."));
       Parameters.Add(new ValueLookupParameter<ISymbolicExpressionTreeInterpreter>(SymbolicExpressionTreeInterpreterParameterName, "The interpreter that should be used for the analysis of symbolic expression trees."));
+      Parameters.Add(new LookupParameter<DataTable>(VariableFrequenciesParameterName, "The variable frequencies table to use for the calculation of variable impacts"));
       Parameters.Add(new LookupParameter<SymbolicRegressionSolution>(BestSolutionParameterName, "The best symbolic regression solution."));
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void Initialize() {
+      if (!Parameters.ContainsKey(VariableFrequenciesParameterName)) {
+        Parameters.Add(new LookupParameter<DataTable>(VariableFrequenciesParameterName, "The variable frequencies table to use for the calculation of variable impacts"));
+      }
     }
 
@@ -89 +106 @@
         if (Results.ContainsKey(BestSolutionInputvariableCountResultName)) {
           Results[BestSolutionInputvariableCountResultName].Value = new IntValue(model.InputVariables.Count());
+          Results[VariableImpactsResultName].Value = CalculateVariableImpacts();
         } else {
           Results.Add(new Result(BestSolutionInputvariableCountResultName, new IntValue(model.InputVariables.Count())));
+          Results.Add(new Result(VariableImpactsResultName, CalculateVariableImpacts()));
         }
       }
       return BestSolutionParameter.ActualValue;
+    }
+
+    private DoubleMatrix CalculateVariableImpacts() {
+      if (VariableFrequencies != null) {
+        var impacts = new DoubleMatrix(VariableFrequencies.Rows.Count, 1, new string[] { "Impact" }, VariableFrequencies.Rows.Select(x => x.Name));
+        int rowIndex = 0;
+        foreach (var dataRow in VariableFrequencies.Rows) {
+          string variableName = dataRow.Name;
+          double integral = 0;
+          if (dataRow.Values.Count > 1) {
+            double baseline = dataRow.Values.First();
+            integral = (from value in dataRow.Values
+                        select value - baseline)
+                              .Sum();
+          }
+          impacts[rowIndex++, 0] = integral;
+        }
+        return impacts;
+      } else return new DoubleMatrix(1, 1);
     }
 

trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/Analyzers/SymbolicRegressionVariableFrequencyAnalyzer.cs

@@ -60 +60 @@
     #endregion
     #region properties
-    public DataTable VariableImpacts {
+    public DataTable VariableFrequencies {
       get { return VariableFrequenciesParameter.ActualValue; }
       set { VariableFrequenciesParameter.ActualValue = value; }
@@ -80 +80 @@
       ResultCollection results = ResultsParameter.ActualValue;
 
-      if (VariableImpacts == null) {
-        VariableImpacts = new DataTable("Variable frequencies", "Relative frequency of variable references aggregated over the whole population.");
+      if (VariableFrequencies == null) {
+        VariableFrequencies = new DataTable("Variable frequencies", "Relative frequency of variable references aggregated over the whole population.");
         // add a data row for each input variable
         foreach (var inputVariable in inputVariables)
-          VariableImpacts.Rows.Add(new DataRow(inputVariable));
-        results.Add(new Result("Variable frequencies", VariableImpacts));
+          VariableFrequencies.Rows.Add(new DataRow(inputVariable));
+        results.Add(new Result("Variable frequencies", VariableFrequencies));
       }
       foreach (var pair in VariableFrequencyAnalyser.CalculateVariableFrequencies(expressions, inputVariables)) {
-        VariableImpacts.Rows[pair.Key].Values.Add(pair.Value);
-        results["Variable frequencies"].Value = VariableImpacts;
+        VariableFrequencies.Rows[pair.Key].Values.Add(pair.Value);
+        results["Variable frequencies"].Value = VariableFrequencies;
       }