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

Timestamp:

08/05/16 14:25:28 (8 years ago)

Author:

gkronber

Message:

#2650: work in progress..

Location:

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

Files:

• HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj (modified) (1 diff)
• Interpreter/SymbolicDataAnalysisExpressionTreeILEmittingInterpreter.cs (modified) (2 diffs)
• Interpreter/SymbolicDataAnalysisExpressionTreeInterpreter.cs (modified) (1 diff)
• Interpreter/SymbolicDataAnalysisExpressionTreeLinearInterpreter.cs (modified) (1 diff)
• SymbolicDataAnalysisExpressionTreeSimplifier.cs (modified) (1 diff)
• Symbols/FactorVariable.cs (modified) (3 diffs)
• Symbols/FactorVariableTreeNode.cs (modified) (4 diffs)
• Symbols/LaggedVariable.cs (modified) (1 diff)
• Symbols/LaggedVariableTreeNode.cs (modified) (1 diff)
• Symbols/Variable.cs (modified) (1 diff)
• Symbols/VariableBase.cs (added)
• Symbols/VariableTreeNode.cs (modified) (1 diff)
• Symbols/VariableTreeNodeBase.cs (added)

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

@@ -200 +200 @@
     <Compile Include="Symbols\FactorVariable.cs" />
     <Compile Include="Symbols\FactorVariableTreeNode.cs" />
+    <Compile Include="Symbols\VariableBase.cs" />
+    <Compile Include="Symbols\VariableTreeNodeBase.cs" />
     <Compile Include="Symbols\Xor.cs" />
     <Compile Include="Symbols\Erf.cs" />

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

@@ -639 +639 @@
               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 {
@@ -652 +653 @@
               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);

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

@@ -462 +462 @@
             if (row < 0 || row >= dataset.Rows) return double.NaN;
             var factorVarTreeNode = currentInstr.dynamicNode as FactorVariableTreeNode;
-            return ((IList<string>)currentInstr.data)[row] == factorVarTreeNode.VariableValue ? 1 : 0;
+            return ((IList<string>)currentInstr.data)[row] == factorVarTreeNode.VariableValue ? factorVarTreeNode.Weight : 0;
           }
         case OpCodes.LagVariable: {

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

@@ -152 +152 @@
           else {
             var factorTreeNode = instr.dynamicNode as FactorVariableTreeNode;
-            instr.value = ((IList<string>)instr.data)[row] == factorTreeNode.VariableValue ? 1 : 0;
+            instr.value = ((IList<string>)instr.data)[row] == factorTreeNode.VariableValue ? factorTreeNode.Weight : 0;
           }
         } else if (instr.opCode == OpCodes.LagVariable) {

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

@@ -833 +833 @@
       var subtrees = new List<ISymbolicExpressionTreeNode>(sum.Subtrees);
       while (sum.Subtrees.Any()) sum.RemoveSubtree(0);
-      var groupedVarNodes = from node in subtrees.OfType<VariableTreeNode>()
+      var groupedVarNodes = from node in subtrees.OfType<VariableTreeNodeBase>()
                             let lag = (node is LaggedVariableTreeNode) ? ((LaggedVariableTreeNode)node).Lag : 0
                             group node by node.VariableName + lag into g
                             select g;
-      var unchangedSubtrees = subtrees.Where(t => !(t is VariableTreeNode));
+      var unchangedSubtrees = subtrees.Where(t => !(t is VariableTreeNodeBase));
 
       foreach (var variableNodeGroup in groupedVarNodes) {

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

@@ -41 +41 @@
   [StorableClass]
   [Item("FactorVariable", "Represents a categorical variable (comparable to factors as in R).")]
-  public class FactorVariable : Symbol {
-    #region Properties
-    private List<string> variableNames;
-    [Storable]
-    public IEnumerable<string> VariableNames {
-      get { return variableNames; }
-      set {
-        if (value == null) throw new ArgumentNullException();
-        variableNames.Clear();
-        variableNames.AddRange(value);
-        OnChanged(EventArgs.Empty);
-      }
-    }
-
-    private List<string> allVariableNames;
-    [Storable]
-    public IEnumerable<string> AllVariableNames {
-      get { return allVariableNames; }
-      set {
-        if (value == null) throw new ArgumentNullException();
-        allVariableNames.Clear();
-        allVariableNames.AddRange(value);
-      }
-    }
+  public class FactorVariable : VariableBase {
 
     private Dictionary<string, List<string>> variableValues;
@@ -80 +57 @@
     }
 
-
-    public override bool Enabled {
-      get {
-        if (variableNames.Count == 0) return false;
-        return base.Enabled;
-      }
-      set {
-        if (variableNames.Count == 0) base.Enabled = false;
-        else base.Enabled = value;
-      }
-    }
-
-    private const int minimumArity = 0;
-    private const int maximumArity = 0;
-
-    public override int MinimumArity {
-      get { return minimumArity; }
-    }
-    public override int MaximumArity {
-      get { return maximumArity; }
-    }
-    #endregion
-
     [StorableConstructor]
     protected FactorVariable(bool deserializing)
       : base(deserializing) {
-      variableNames = new List<string>();
-      allVariableNames = new List<string>();
       variableValues = new Dictionary<string, List<string>>();
     }
     protected FactorVariable(FactorVariable original, Cloner cloner)
       : base(original, cloner) {
-      variableNames = new List<string>(original.variableNames);
-      allVariableNames = new List<string>(original.allVariableNames);
       variableValues =
         original.variableValues.ToDictionary(kvp => kvp.Key, kvp => new List<string>(kvp.Value));
@@ -120 +70 @@
     public FactorVariable(string name, string description)
       : base(name, description) {
-      variableNames = new List<string>();
-      allVariableNames = new List<string>();
       variableValues = new Dictionary<string, List<string>>();
     }
 
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
-      if (allVariableNames == null || (allVariableNames.Count == 0 && variableNames.Count > 0)) {
-        allVariableNames = variableNames;
-      }
-    }
     public override ISymbolicExpressionTreeNode CreateTreeNode() {
       return new FactorVariableTreeNode(this);

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

@@ -27 +27 @@
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
   [StorableClass]
-  public class FactorVariableTreeNode : SymbolicExpressionTreeTerminalNode {
+  public class FactorVariableTreeNode : VariableTreeNodeBase {
     public new FactorVariable Symbol {
       get { return (FactorVariable)base.Symbol; }
-    }
-    [Storable]
-    private string variableName;
-    public string VariableName {
-      get { return variableName; }
-      set { variableName = value; }
     }
 
@@ -49 +43 @@
     protected FactorVariableTreeNode(FactorVariableTreeNode original, Cloner cloner)
       : base(original, cloner) {
-      variableName = original.variableName;
       variableValue = original.variableValue;
     }
@@ -61 +54 @@
     public override void ResetLocalParameters(IRandom random) {
       base.ResetLocalParameters(random);
-      variableName = Symbol.VariableNames.SampleRandom(random);
       variableValue = Symbol.GetVariableValues(VariableName).SampleRandom(random);
     }
 
     public override void ShakeLocalParameters(IRandom random, double shakingFactor) {
-      base.ShakeLocalParameters(random, shakingFactor);
+      // 50% additive & 50% multiplicative
+      if (random.NextDouble() < 0.5) {
+        double x = NormalDistributedRandom.NextDouble(random, Symbol.WeightManipulatorMu, Symbol.WeightManipulatorSigma);
+        Weight = Weight + x * shakingFactor;
+      } else {
+        double x = NormalDistributedRandom.NextDouble(random, 1.0, Symbol.MultiplicativeWeightManipulatorSigma);
+        Weight = Weight * x;
+      }
       if (random.NextDouble() < 0.2) {
-        variableName = Symbol.VariableNames.SampleRandom(random);
+        VariableName = Symbol.VariableNames.SampleRandom(random);
       }
       variableValue = Symbol.GetVariableValues(VariableName).SampleRandom(random);
@@ -78 +77 @@
 
     public override string ToString() {
-      return variableName + " = " + variableValue;
+      return base.ToString() + " = " + variableValue;
     }
   }

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

@@ -27 +27 @@
   [StorableClass]
   [Item("LaggedVariable", "Represents a variable value with a time offset.")]
-  public class LaggedVariable : Variable {
+  public class LaggedVariable : VariableBase {
     [Storable]
     private int minLag;

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

@@ -26 +26 @@
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
   [StorableClass]
-  public sealed class LaggedVariableTreeNode : VariableTreeNode, ILaggedTreeNode {
+  public sealed class LaggedVariableTreeNode : VariableTreeNodeBase, ILaggedTreeNode {
     public new LaggedVariable Symbol {
       get { return (LaggedVariable)base.Symbol; }

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

@@ -29 +29 @@
   [StorableClass]
   [Item("Variable", "Represents a variable value.")]
-  public class Variable : Symbol {
-    #region Properties
-    [Storable]
-    private double weightMu;
-    public double WeightMu {
-      get { return weightMu; }
-      set {
-        if (value != weightMu) {
-          weightMu = value;
-          OnChanged(EventArgs.Empty);
-        }
-      }
-    }
-    [Storable]
-    private double weightSigma;
-    public double WeightSigma {
-      get { return weightSigma; }
-      set {
-        if (weightSigma < 0.0) throw new ArgumentException("Negative sigma is not allowed.");
-        if (value != weightSigma) {
-          weightSigma = value;
-          OnChanged(EventArgs.Empty);
-        }
-      }
-    }
-    [Storable]
-    private double weightManipulatorMu;
-    public double WeightManipulatorMu {
-      get { return weightManipulatorMu; }
-      set {
-        if (value != weightManipulatorMu) {
-          weightManipulatorMu = value;
-          OnChanged(EventArgs.Empty);
-        }
-      }
-    }
-    [Storable]
-    private double weightManipulatorSigma;
-    public double WeightManipulatorSigma {
-      get { return weightManipulatorSigma; }
-      set {
-        if (weightManipulatorSigma < 0.0) throw new ArgumentException("Negative sigma is not allowed.");
-        if (value != weightManipulatorSigma) {
-          weightManipulatorSigma = value;
-          OnChanged(EventArgs.Empty);
-        }
-      }
-    }
-    [Storable(DefaultValue = 0.0)]
-    private double multiplicativeWeightManipulatorSigma;
-    public double MultiplicativeWeightManipulatorSigma {
-      get { return multiplicativeWeightManipulatorSigma; }
-      set {
-        if (multiplicativeWeightManipulatorSigma < 0.0) throw new ArgumentException("Negative sigma is not allowed.");
-        if (value != multiplicativeWeightManipulatorSigma) {
-          multiplicativeWeightManipulatorSigma = value;
-          OnChanged(EventArgs.Empty);
-        }
-      }
-    }
-    private List<string> variableNames;
-    [Storable]
-    public IEnumerable<string> VariableNames {
-      get { return variableNames; }
-      set {
-        if (value == null) throw new ArgumentNullException();
-        variableNames.Clear();
-        variableNames.AddRange(value);
-        OnChanged(EventArgs.Empty);
-      }
-    }
-
-    private List<string> allVariableNames;
-    [Storable]
-    public IEnumerable<string> AllVariableNames {
-      get { return allVariableNames; }
-      set {
-        if (value == null) throw new ArgumentNullException();
-        allVariableNames.Clear();
-        allVariableNames.AddRange(value);
-      }
-    }
-
-    public override bool Enabled {
-      get {
-        if (variableNames.Count == 0) return false;
-        return base.Enabled;
-      }
-      set {
-        if (variableNames.Count == 0) base.Enabled = false;
-        else base.Enabled = value;
-      }
-    }
-
-    private const int minimumArity = 0;
-    private const int maximumArity = 0;
-
-    public override int MinimumArity {
-      get { return minimumArity; }
-    }
-    public override int MaximumArity {
-      get { return maximumArity; }
-    }
-    #endregion
-
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
-      if (allVariableNames == null || (allVariableNames.Count == 0 && variableNames.Count > 0)) {
-        allVariableNames = variableNames;
-      }
-    }
+  public class Variable : VariableBase {
 
     [StorableConstructor]
     protected Variable(bool deserializing)
       : base(deserializing) {
-      variableNames = new List<string>();
-      allVariableNames = new List<string>();
     }
     protected Variable(Variable original, Cloner cloner)
       : base(original, cloner) {
-      weightMu = original.weightMu;
-      weightSigma = original.weightSigma;
-      variableNames = new List<string>(original.variableNames);
-      allVariableNames = new List<string>(original.allVariableNames);
-      weightManipulatorMu = original.weightManipulatorMu;
-      weightManipulatorSigma = original.weightManipulatorSigma;
-      multiplicativeWeightManipulatorSigma = original.multiplicativeWeightManipulatorSigma;
     }
-    public Variable() : this("Variable", "Represents a variable value.") { }
-    public Variable(string name, string description)
-      : base(name, description) {
-      weightMu = 1.0;
-      weightSigma = 1.0;
-      weightManipulatorMu = 0.0;
-      weightManipulatorSigma = 0.05;
-      multiplicativeWeightManipulatorSigma = 0.03;
-      variableNames = new List<string>();
-      allVariableNames = new List<string>();
-    }
+    public Variable() : base("Variable", "Represents a variable value.") { }
 
     public override ISymbolicExpressionTreeNode CreateTreeNode() {

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

@@ -21 +21 @@
 
 using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Random;
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
   [StorableClass]
-  public class VariableTreeNode : SymbolicExpressionTreeTerminalNode {
+  public class VariableTreeNode : VariableTreeNodeBase {
     public new Variable Symbol {
       get { return (Variable)base.Symbol; }
     }
-    [Storable]
-    private double weight;
-    public double Weight {
-      get { return weight; }
-      set { weight = value; }
-    }
-    [Storable]
-    private string variableName;
-    public string VariableName {
-      get { return variableName; }
-      set { variableName = value; }
-    }
-
     [StorableConstructor]
     protected VariableTreeNode(bool deserializing) : base(deserializing) { }
     protected VariableTreeNode(VariableTreeNode original, Cloner cloner)
       : base(original, cloner) {
-      weight = original.weight;
-      variableName = original.variableName;
     }
     protected VariableTreeNode() { }
     public VariableTreeNode(Variable variableSymbol) : base(variableSymbol) { }
 
-    public override bool HasLocalParameters {
-      get { return true; }
-    }
-
-    public override void ResetLocalParameters(IRandom random) {
-      base.ResetLocalParameters(random);
-      weight = NormalDistributedRandom.NextDouble(random, Symbol.WeightMu, Symbol.WeightSigma);
-
-#pragma warning disable 612, 618
-      variableName = Symbol.VariableNames.SelectRandom(random);
-#pragma warning restore 612, 618
-    }
-
-    public override void ShakeLocalParameters(IRandom random, double shakingFactor) {
-      base.ShakeLocalParameters(random, shakingFactor);
-      // 50% additive & 50% multiplicative
-      if (random.NextDouble() < 0) {
-        double x = NormalDistributedRandom.NextDouble(random, Symbol.WeightManipulatorMu, Symbol.WeightManipulatorSigma);
-        weight = weight + x * shakingFactor;
-      } else {
-        double x = NormalDistributedRandom.NextDouble(random, 1.0, Symbol.MultiplicativeWeightManipulatorSigma);
-        weight = weight * x;
-      }
-#pragma warning disable 612, 618
-      variableName = Symbol.VariableNames.SelectRandom(random);
-#pragma warning restore 612, 618
-    }
-
     public override IDeepCloneable Clone(Cloner cloner) {
       return new VariableTreeNode(this, cloner);
     }
-
-    public override string ToString() {
-      if (weight.IsAlmost(1.0)) return variableName;
-      else return weight.ToString("E4") + " " + variableName;
-    }
   }
 }