Changeset 14249 for branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Symbolic

Timestamp:

08/09/16 15:34:33 (9 years ago)

Author:

gkronber

Message:

#2650 added new symbol FactorVariable (renamed previous symbol to BinaryFactorVariable)
Work in progress.

Location:

branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4

Files:

• Grammars/ArithmeticExpressionGrammar.cs (modified) (1 diff)
• Grammars/FullFunctionalExpressionGrammar.cs (modified) (3 diffs)
• Grammars/TypeCoherentExpressionGrammar.cs (modified) (3 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj (modified) (1 diff)
• Interpreter/OpCodes.cs (modified) (2 diffs)
• Interpreter/SymbolicDataAnalysisExpressionTreeILEmittingInterpreter.cs (modified) (2 diffs)
• Interpreter/SymbolicDataAnalysisExpressionTreeInterpreter.cs (modified) (2 diffs)
• Interpreter/SymbolicDataAnalysisExpressionTreeLinearInterpreter.cs (modified) (2 diffs)
• SymbolicDataAnalysisExpressionTreeSimplifier.cs (modified) (1 diff)
• SymbolicDataAnalysisProblem.cs (modified) (1 diff)
• SymbolicDataAnalysisSingleObjectiveProblem.cs (modified) (1 diff)
• SymbolicDataAnalysisSolutionImpactValuesCalculator.cs (modified) (1 diff)
• Symbols/BinaryFactorVariable.cs (modified) (2 diffs)
• Symbols/BinaryFactorVariableTreeNode.cs (modified) (1 diff)
• Symbols/FactorVariable.cs (added)
• Symbols/FactorVariableTreeNode.cs (added)

branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/ArithmeticExpressionGrammar.cs

@@ -53 +53 @@
       constant.MaxValue = 20;
       var variableSymbol = new HeuristicLab.Problems.DataAnalysis.Symbolic.Variable();
-      var factorVariableSymbol = new BinaryFactorVariable();
+      var binFactorVariableSymbol = new BinaryFactorVariable();
+      var factorVariableSymbol = new FactorVariable();
 
-      var allSymbols = new List<Symbol>() { add, sub, mul, div, constant, variableSymbol, factorVariableSymbol };
+      var allSymbols = new List<Symbol>() { add, sub, mul, div, constant, variableSymbol, binFactorVariableSymbol, factorVariableSymbol};
       var functionSymbols = new List<Symbol>() { add, sub, mul, div };
 

branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/FullFunctionalExpressionGrammar.cs

@@ -115 +115 @@
       constant.MaxValue = 20;
       var variableSymbol = new HeuristicLab.Problems.DataAnalysis.Symbolic.Variable();
-      var factorVariable = new BinaryFactorVariable();
+      var binFactorVariable = new BinaryFactorVariable();
+      var factorVariable = new FactorVariable();
       var laggedVariable = new LaggedVariable();
       laggedVariable.InitialFrequency = 0.0;
@@ -124 +125 @@
       var allSymbols = new List<Symbol>() { add, sub, mul, div, mean, sin, cos, tan, log, square, pow, sqrt, root, exp,
         airyA, airyB, bessel, cosineIntegral, dawson, erf, expIntegralEi, fresnelCosineIntegral, fresnelSineIntegral, gamma, hypCosineIntegral, hypSineIntegral, norm, psi, sineIntegral,
-        @if, gt, lt, and, or, not,xor, timeLag, integral, derivative, constant, variableSymbol, factorVariable, laggedVariable,autoregressiveVariable, variableCondition };
+        @if, gt, lt, and, or, not,xor, timeLag, integral, derivative, constant, variableSymbol, binFactorVariable, factorVariable, laggedVariable,autoregressiveVariable, variableCondition };
       var unaryFunctionSymbols = new List<Symbol>() { square, sqrt, sin, cos, tan, log, exp, not, timeLag, integral, derivative,
         airyA, airyB, bessel, cosineIntegral, dawson, erf, expIntegralEi, fresnelCosineIntegral, fresnelSineIntegral, gamma, hypCosineIntegral, hypSineIntegral, norm, psi, sineIntegral
@@ -131 +132 @@
       var binaryFunctionSymbols = new List<Symbol>() { pow, root, gt, lt, variableCondition };
       var ternarySymbols = new List<Symbol>() { add, sub, mul, div, mean, and, or, xor };
-      var terminalSymbols = new List<Symbol>() { variableSymbol, factorVariable, constant, laggedVariable, autoregressiveVariable };
+      var terminalSymbols = new List<Symbol>() { variableSymbol, binFactorVariable, factorVariable, constant, laggedVariable, autoregressiveVariable };
 
       foreach (var symb in allSymbols)

branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/TypeCoherentExpressionGrammar.cs

@@ -104 +104 @@
       constant.MaxValue = 20;
       var variableSymbol = new Variable();
-      var factorVariable = new BinaryFactorVariable();
+      var binFactorVariable = new BinaryFactorVariable();
+      var factorVariable = new FactorVariable();
       var laggedVariable = new LaggedVariable();
       var autoregressiveVariable = new AutoregressiveTargetVariable();
@@ -115 +116 @@
       var specialFunctions = new GroupSymbol(SpecialFunctionsName, new List<ISymbol> { airyA, airyB, bessel, cosineIntegral, dawson, erf, expIntegralEi, 
         fresnelCosineIntegral,fresnelSineIntegral,gamma,hypCosineIntegral,hypSineIntegral,norm, psi, sineIntegral});
-      var terminalSymbols = new GroupSymbol(TerminalsName, new List<ISymbol> { constant, variableSymbol, factorVariable });
+      var terminalSymbols = new GroupSymbol(TerminalsName, new List<ISymbol> { constant, variableSymbol, binFactorVariable, factorVariable });
       var realValuedSymbols = new GroupSymbol(RealValuedSymbolsName, new List<ISymbol>() { arithmeticSymbols, trigonometricSymbols, exponentialAndLogarithmicSymbols, specialFunctions, terminalSymbols });
 
@@ -123 +124 @@
       var comparisonSymbols = new GroupSymbol(ComparisonsName, new List<ISymbol> { gt, lt });
       var booleanOperationSymbols = new GroupSymbol(BooleanOperatorsName, new List<ISymbol> { and, or, not, xor });
-      var conditionalSymbols = new GroupSymbol(ConditionalSymbolsName, new List<ISymbol> { conditionSymbols, comparisonSymbols, booleanOperationSymbols }); // TODO: factorVariableBool?
+      var conditionalSymbols = new GroupSymbol(ConditionalSymbolsName, new List<ISymbol> { conditionSymbols, comparisonSymbols, booleanOperationSymbols }); 
 
       var timeSeriesSymbols = new GroupSymbol(TimeSeriesSymbolsName, new List<ISymbol> { timeLag, integral, derivative, laggedVariable, autoregressiveVariable });

branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj

@@ -199 +199 @@
     <Compile Include="Symbols\AiryB.cs" />
     <Compile Include="Symbols\Bessel.cs" />
+    <Compile Include="Symbols\BinaryFactorVariable.cs" />
+    <Compile Include="Symbols\BinaryFactorVariableTreeNode.cs" />
+    <Compile Include="Symbols\FactorVariableTreeNode.cs" />
     <Compile Include="Symbols\FactorVariable.cs" />
-    <Compile Include="Symbols\FactorVariableTreeNode.cs" />
     <Compile Include="Symbols\VariableBase.cs" />
     <Compile Include="Symbols\VariableTreeNodeBase.cs" />

branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/OpCodes.cs

@@ -84 +84 @@
     public const byte Bessel = 44;
     public const byte FactorVariable = 46;
+    public const byte BinaryFactorVariable = 47;
+
 
     private static Dictionary<Type, byte> symbolToOpcode = new Dictionary<Type, byte>() {
@@ -132 +134 @@
       { typeof(Erf), OpCodes.Erf},
       { typeof(Bessel), OpCodes.Bessel},
-      { typeof(BinaryFactorVariable), OpCodes.FactorVariable }
+      { typeof(FactorVariable), OpCodes.FactorVariable },
+      { typeof(BinaryFactorVariable), OpCodes.BinaryFactorVariable }
     };
 

branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeILEmittingInterpreter.cs

@@ -66 +66 @@
     private static MethodInfo erf = thisType.GetMethod("Erf", new Type[] { typeof(double) });
     private static MethodInfo bessel = thisType.GetMethod("Bessel", new Type[] { typeof(double) });
-    private static MethodInfo string_eq = typeof(string).GetMethod("Equals", new Type[] {typeof(string)});
+    private static MethodInfo string_eq = typeof(string).GetMethod("Equals", new Type[] { typeof(string) });
     #endregion
 
@@ -628 +628 @@
             return;
           }
-        case OpCodes.FactorVariable: {
-            BinaryFactorVariableTreeNode varNode = currentInstr.dynamicNode as BinaryFactorVariableTreeNode;
-            il.Emit(System.Reflection.Emit.OpCodes.Ldarg_1); // load columns array
-            il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, (int)currentInstr.data);
-            // load correct column of the current variable
-            il.Emit(System.Reflection.Emit.OpCodes.Ldelem_Ref);
-            il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // rowIndex
-            if (!state.InLaggedContext) {
-              il.Emit(System.Reflection.Emit.OpCodes.Call, listGetValue);
-              il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, varNode.VariableValue); 
-              il.Emit(System.Reflection.Emit.OpCodes.Call, string_eq);
-              throw new NotSupportedException();
-              // TODO: convert bool to 1 / 0?
-            } else {
-              var nanResult = il.DefineLabel();
-              var normalResult = il.DefineLabel();
-              il.Emit(System.Reflection.Emit.OpCodes.Dup);
-              il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_0);
-              il.Emit(System.Reflection.Emit.OpCodes.Blt, nanResult);
-              il.Emit(System.Reflection.Emit.OpCodes.Dup);
-              il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, ds.Rows);
-              il.Emit(System.Reflection.Emit.OpCodes.Bge, nanResult);
-              il.Emit(System.Reflection.Emit.OpCodes.Call, listGetValue);
-              il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, varNode.VariableValue);
-              il.Emit(System.Reflection.Emit.OpCodes.Call, string_eq);
-              throw new NotSupportedException();
-              // TODO: convert bool to 1 / 0?
-              il.Emit(System.Reflection.Emit.OpCodes.Br, normalResult);
-              il.MarkLabel(nanResult);
-              il.Emit(System.Reflection.Emit.OpCodes.Pop); // rowIndex
-              il.Emit(System.Reflection.Emit.OpCodes.Pop); // column reference
-              il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, double.NaN);
-              il.MarkLabel(normalResult);
-            }
-            return;
+        case OpCodes.FactorVariable:
+        case OpCodes.BinaryFactorVariable: {
+            throw new NotSupportedException();
           }
         case OpCodes.LagVariable: {

branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeInterpreter.cs

@@ -146 +146 @@
         } else if (instr.opCode == OpCodes.FactorVariable) {
           var factorTreeNode = instr.dynamicNode as BinaryFactorVariableTreeNode;
-          instr.data = dataset.GetReadOnlyStringValues(factorTreeNode.VariableName); 
+          instr.data = dataset.GetReadOnlyStringValues(factorTreeNode.VariableName);
         } else if (instr.opCode == OpCodes.LagVariable) {
           var laggedVariableTreeNode = (LaggedVariableTreeNode)instr.dynamicNode;
@@ -459 +459 @@
             return ((IList<double>)currentInstr.data)[row] * variableTreeNode.Weight;
           }
-        case OpCodes.FactorVariable: {
+        case OpCodes.BinaryFactorVariable: {
             if (row < 0 || row >= dataset.Rows) return double.NaN;
             var factorVarTreeNode = currentInstr.dynamicNode as BinaryFactorVariableTreeNode;
             return ((IList<string>)currentInstr.data)[row] == factorVarTreeNode.VariableValue ? factorVarTreeNode.Weight : 0;
+          }
+        case OpCodes.FactorVariable: {
+            if (row < 0 || row >= dataset.Rows) return double.NaN;
+            var factorVarTreeNode = currentInstr.dynamicNode as FactorVariableTreeNode;
+            return factorVarTreeNode.GetValue(((IList<string>)currentInstr.data)[row]);
           }
         case OpCodes.LagVariable: {

branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeLinearInterpreter.cs

@@ -148 +148 @@
             instr.value = ((IList<double>)instr.data)[row] * variableTreeNode.Weight;
           }
+        } else if (instr.opCode == OpCodes.BinaryFactorVariable) {
+          if (row < 0 || row >= dataset.Rows) instr.value = double.NaN;
+          else {
+            var factorTreeNode = instr.dynamicNode as BinaryFactorVariableTreeNode;
+            instr.value = ((IList<string>)instr.data)[row] == factorTreeNode.VariableValue ? factorTreeNode.Weight : 0;
+          }
         } else if (instr.opCode == OpCodes.FactorVariable) {
           if (row < 0 || row >= dataset.Rows) instr.value = double.NaN;
           else {
-            var factorTreeNode = instr.dynamicNode as BinaryFactorVariableTreeNode;
-            instr.value = ((IList<string>)instr.data)[row] == factorTreeNode.VariableValue ? factorTreeNode.Weight : 0;
+            var factorTreeNode = instr.dynamicNode as FactorVariableTreeNode;
+            instr.value = factorTreeNode.GetValue(((IList<string>)instr.data)[row]);
           }
         } else if (instr.opCode == OpCodes.LagVariable) {
@@ -398 +404 @@
             }
             break;
+          case OpCodes.BinaryFactorVariable: {
+              var factorVariableTreeNode = instr.dynamicNode as BinaryFactorVariableTreeNode;
+              instr.data = dataset.GetReadOnlyStringValues(factorVariableTreeNode.VariableName);
+            }
+            break;
           case OpCodes.FactorVariable: {
-              var factorVariableTreeNode = instr.dynamicNode as BinaryFactorVariableTreeNode;
+              var factorVariableTreeNode = instr.dynamicNode as FactorVariableTreeNode;
               instr.data = dataset.GetReadOnlyStringValues(factorVariableTreeNode.VariableName);
             }

branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeSimplifier.cs

@@ -183 +183 @@
     }
     private bool IsVariableBase(ISymbolicExpressionTreeNode node) {
-      return node.Symbol is VariableBase;
+      return node is VariableTreeNodeBase;
     }
     private bool IsConstant(ISymbolicExpressionTreeNode node) {

branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisProblem.cs

@@ -226 +226 @@
             .ToDictionary(varName => varName, varName => ds.GetStringValues(varName).Distinct().ToList());
         }
+      } foreach (var factorSymbol in grammar.Symbols.OfType<FactorVariable>()) {
+        if (!factorSymbol.Fixed) {
+          factorSymbol.AllVariableNames = problemData.InputVariables.Select(x => x.Value).Where(x => ds.VariableHasType<string>(x));
+          factorSymbol.VariableNames = problemData.AllowedInputVariables.Where(x => ds.VariableHasType<string>(x));
+          factorSymbol.VariableValues = factorSymbol.VariableNames
+            .ToDictionary(varName => varName, varName => ds.GetStringValues(varName).Distinct().ToList());
+        }
       }
     }

branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisSingleObjectiveProblem.cs

@@ -73 +73 @@
     }
 
-    public SymbolicDataAnalysisSingleObjectiveProblem(T problemData, U evaluator, V solutionCreator)
+    protected SymbolicDataAnalysisSingleObjectiveProblem(T problemData, U evaluator, V solutionCreator)
       : base(problemData, evaluator, solutionCreator) {
       Parameters.Add(new FixedValueParameter<BoolValue>(MaximizationParameterName, "Set to false if the problem should be minimized."));

branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisSolutionImpactValuesCalculator.cs

@@ -43 +43 @@
       //optimization: constant nodes return always the same value
       ConstantTreeNode constantNode = node as ConstantTreeNode;
-      BinaryFactorVariableTreeNode factorNode = node as BinaryFactorVariableTreeNode;
+      BinaryFactorVariableTreeNode binaryFactorNode = node as BinaryFactorVariableTreeNode;
+      FactorVariableTreeNode factorNode = node as FactorVariableTreeNode;
       if (constantNode != null) {
         yield return constantNode.Value;
-      } else if (factorNode != null) {
+      } else if (binaryFactorNode != null) {
         // valid replacements are either all off or all on
         yield return 0;
         yield return 1;
+      } else if (factorNode != null) {
+        foreach (var w in factorNode.Weights) yield return w;
+        yield return 0.0;
       } else {
         var rootSymbol = new ProgramRootSymbol().CreateTreeNode();

branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/BinaryFactorVariable.cs

@@ -32 +32 @@
   public class BinaryFactorVariable : VariableBase {
 
-    private Dictionary<string, List<string>> variableValues;
+    private readonly Dictionary<string, List<string>> variableValues;
 
     [Storable]
@@ -63 +63 @@
 
     public override ISymbolicExpressionTreeNode CreateTreeNode() {
-      return new FactorVariableTreeNode(this);
+      return new BinaryFactorVariableTreeNode(this);
     }
 

branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/BinaryFactorVariableTreeNode.cs

@@ -44 +44 @@
       variableValue = original.variableValue;
     }
-    protected BinaryFactorVariableTreeNode() { }
     public BinaryFactorVariableTreeNode(BinaryFactorVariable variableSymbol) : base(variableSymbol) { }