Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
08/05/16 17:34:16 (8 years ago)
Author:
gkronber
Message:

#2650:

  • added weight for FactorVariable (necessary for LR)
  • introduced VariableBase and VariableTreeNodeBase and IVariableSymbol
  • support for factors in LR
  • extended variable impacts in solution view
  • fixed ERC view for regression
  • support for FactorVariable in simplifier
  • improved support for FactorVariable in constants optimizer
  • multiple related changes and small fixes
Location:
branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4
Files:
1 added
10 edited

Legend:

Unmodified
Added
Removed

  • branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisVariableFrequencyAnalyzer.cs

    r14232 r14238  
    167167      if (aggregateLaggedVariables) {
    168168        tree.Root.ForEachNodePrefix(node => {
    169           if (node.Symbol is Variable) {
    170             var varNode = node as VariableTreeNode;
    171             IncReferenceCount(references, varNode.VariableName);
    172           } else if (node.Symbol is VariableCondition) {
    173             var varCondNode = node as VariableConditionTreeNode;
    174             IncReferenceCount(references, varCondNode.VariableName);
    175           } else if (node.Symbol is FactorVariable) {
     169          if (node is IVariableTreeNode) {
    176170            var factorNode = node as FactorVariableTreeNode;
    177             if (aggregateFactorVariables) {
    178               IncReferenceCount(references, factorNode.VariableName);
     171            if (factorNode != null && !aggregateFactorVariables) {
     172              IncReferenceCount(references, factorNode.VariableName + "=" + factorNode.VariableValue);
    179173            } else {
    180               IncReferenceCount(references, factorNode.ToString());
     174              var varNode = node as IVariableTreeNode;
     175              IncReferenceCount(references, varNode.VariableName);
    181176            }
    182177          }
    … …  
    189184
    190185    private static void GetVariableReferences(Dictionary<string, int> references, ISymbolicExpressionTreeNode node, int currentLag, bool aggregateFactorVariables) {
    191       if (node.Symbol is LaggedVariable) {
    192         var laggedVarNode = node as LaggedVariableTreeNode;
    193         IncReferenceCount(references, laggedVarNode.VariableName, currentLag + laggedVarNode.Lag);
    194       } else if (node.Symbol is Variable) {
    195         var varNode = node as VariableTreeNode;
    196         IncReferenceCount(references, varNode.VariableName, currentLag);
    197       } else if (node.Symbol is FactorVariable) {
    198         var factorNode = node as FactorVariableTreeNode;
    199         if (aggregateFactorVariables) {
    200           IncReferenceCount(references, factorNode.VariableName, currentLag);
     186      if (node is IVariableTreeNode) {
     187        var laggedVarTreeNode = node as LaggedVariableTreeNode;
     188        var factorVarTreeNode = node as FactorVariableTreeNode;
     189        var varConditionTreeNode = node as VariableConditionTreeNode;
     190        if (laggedVarTreeNode != null) {
     191          IncReferenceCount(references, laggedVarTreeNode.VariableName, currentLag + laggedVarTreeNode.Lag);
     192        } else if (factorVarTreeNode != null) {
     193          if (aggregateFactorVariables) {
     194            IncReferenceCount(references, factorVarTreeNode.VariableName, currentLag);
     195          } else {
     196            IncReferenceCount(references, factorVarTreeNode.VariableName + "=" + factorVarTreeNode.VariableValue, currentLag);
     197          }
     198        } else if (varConditionTreeNode != null) {
     199          IncReferenceCount(references, varConditionTreeNode.VariableName, currentLag);
     200          GetVariableReferences(references, node.GetSubtree(0), currentLag, aggregateFactorVariables);
     201          GetVariableReferences(references, node.GetSubtree(1), currentLag, aggregateFactorVariables);
    201202        } else {
    202           IncReferenceCount(references, factorNode.ToString(), currentLag);
    203         }
    204       } else if (node.Symbol is VariableCondition) {
    205         var varCondNode = node as VariableConditionTreeNode;
    206         IncReferenceCount(references, varCondNode.VariableName, currentLag);
    207         GetVariableReferences(references, node.GetSubtree(0), currentLag, aggregateFactorVariables);
    208         GetVariableReferences(references, node.GetSubtree(1), currentLag, aggregateFactorVariables);
     203          var varNode = node as IVariableTreeNode;
     204          IncReferenceCount(references, varNode.VariableName, currentLag);
     205        }
    209206      } else if (node.Symbol is Integral) {
    210207        var laggedNode = node as LaggedTreeNode;

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

    r14237 r14238  
    140140    <Compile Include="Importer\Token.cs" />
    141141    <Compile Include="Interfaces\IModelBacktransformator.cs" />
     142    <Compile Include="Interfaces\IVariableSymbol.cs" />
    142143    <Compile Include="Interpreter\SymbolicDataAnalysisExpressionCompiledTreeInterpreter.cs" />
    143144    <Compile Include="SymbolicDataAnalysisExpressionTreeSimplificationOperator.cs" />

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

    r14237 r14238  
    182182      return node.Symbol is Variable;
    183183    }
    184 
     184    private bool IsVariableBase(ISymbolicExpressionTreeNode node) {
     185      return node.Symbol is VariableBase;
     186    }
    185187    private bool IsConstant(ISymbolicExpressionTreeNode node) {
    186188      return node.Symbol is Constant;
    … …  
    203205    /// <returns></returns>
    204206    public ISymbolicExpressionTreeNode GetSimplifiedTree(ISymbolicExpressionTreeNode original) {
    205       if (IsConstant(original) || IsVariable(original)) {
     207      if (IsConstant(original) || IsVariableBase(original)) {
    206208        return (ISymbolicExpressionTreeNode)original.Clone();
    207209      } else if (IsAddition(original)) {
    … …  
    718720      } if (IsConstant(a) && !((ConstantTreeNode)a).Value.IsAlmost(1.0)) {
    719721        return MakeFraction(MakeConstant(1.0), MakeProduct(b, Invert(a)));
    720       } else if (IsVariable(a) && IsConstant(b)) {
     722      } else if (IsVariableBase(a) && IsConstant(b)) {
    721723        // merge constant values into variable weights
    722724        var constB = ((ConstantTreeNode)b).Value;
    723         ((VariableTreeNode)a).Weight /= constB;
     725        ((VariableTreeNodeBase)a).Weight /= constB;
    724726        return a;
    725       } else if (IsVariable(a) && IsVariable(b) && AreSameVariable(a, b)) {
     727      } else if (IsVariableBase(a) && IsVariableBase(b) && AreSameVariable(a, b)) {
    726728        // cancel variables
    727729        var aVar = a as VariableTreeNode;
    … …  
    835837      var groupedVarNodes = from node in subtrees.OfType<VariableTreeNodeBase>()
    836838                            let lag = (node is LaggedVariableTreeNode) ? ((LaggedVariableTreeNode)node).Lag : 0
    837                             group node by node.VariableName + lag into g
     839                            let cat = (node is FactorVariableTreeNode) ? ((FactorVariableTreeNode)node).VariableValue : string.Empty
     840                            group node by node.VariableName + cat + lag into g
    838841                            select g;
    839842      var unchangedSubtrees = subtrees.Where(t => !(t is VariableTreeNodeBase));
    … …  
    861864        // $ * 1.0 => $
    862865        return a;
    863       } else if (IsConstant(b) && IsVariable(a)) {
     866      } else if (IsConstant(b) && IsVariableBase(a)) {
    864867        // multiply constants into variables weights
    865         ((VariableTreeNode)a).Weight *= ((ConstantTreeNode)b).Value;
     868        ((VariableTreeNodeBase)a).Weight *= ((ConstantTreeNode)b).Value;
    866869        return a;
    867870      } else if (IsConstant(b) && IsAddition(a)) {
    … …  
    944947        return aVar.VariableName == bVar.VariableName;
    945948      }
     949      var aFactor = a as FactorVariableTreeNode;
     950      var bFactor = b as FactorVariableTreeNode;
     951      if (aFactor != null && bFactor != null) {
     952        return aFactor.VariableName == bFactor.VariableName &&
     953          aFactor.VariableValue == bFactor.VariableValue;
     954      }
     955
    946956      return false;
    947957    }
    … …  
    951961      var subtrees = new List<ISymbolicExpressionTreeNode>(prod.Subtrees);
    952962      while (prod.Subtrees.Any()) prod.RemoveSubtree(0);
    953       var groupedVarNodes = from node in subtrees.OfType<VariableTreeNode>()
     963      var groupedVarNodes = from node in subtrees.OfType<VariableTreeNodeBase>()
    954964                            let lag = (node is LaggedVariableTreeNode) ? ((LaggedVariableTreeNode)node).Lag : 0
    955965                            group node by node.VariableName + lag into g
    956966                            orderby g.Count()
    957967                            select g;
    958       var constantProduct = (from node in subtrees.OfType<VariableTreeNode>()
     968      var constantProduct = (from node in subtrees.OfType<VariableTreeNodeBase>()
    959969                             select node.Weight)
    960970                            .Concat(from node in subtrees.OfType<ConstantTreeNode>()
    … …  
    964974
    965975      var unchangedSubtrees = from tree in subtrees
    966                               where !(tree is VariableTreeNode)
     976                              where !(tree is VariableTreeNodeBase)
    967977                              where !(tree is ConstantTreeNode)
    968978                              select tree;
    … …  
    10001010      if (IsConstant(x)) {
    10011011        ((ConstantTreeNode)x).Value *= -1;
    1002       } else if (IsVariable(x)) {
    1003         var variableTree = (VariableTreeNode)x;
     1012      } else if (IsVariableBase(x)) {
     1013        var variableTree = (VariableTreeNodeBase)x;
    10041014        variableTree.Weight *= -1.0;
    10051015      } else if (IsAddition(x)) {

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

    r14185 r14238  
    6363        var variables =
    6464          SymbolicExpressionTree.IterateNodesPrefix()
    65             .OfType<VariableTreeNode>()
     65            .OfType<IVariableTreeNode>()
    6666            .Select(x => x.VariableName)
    6767            .Distinct();
    68         var variableConditions = SymbolicExpressionTree.IterateNodesPrefix()
    69           .OfType<VariableConditionTreeNode>().Select(x => x.VariableName).Distinct();
    7068
    71         return variables.Union(variableConditions).OrderBy(x => x);
     69        return variables.OrderBy(x => x);
    7270      }
    7371    }

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

    r14232 r14238  
    213213      grammar.MaximumFunctionArguments = MaximumFunctionArguments.Value;
    214214      grammar.MaximumFunctionDefinitions = MaximumFunctionDefinitions.Value;
    215       foreach (var varSymbol in grammar.Symbols.OfType<HeuristicLab.Problems.DataAnalysis.Symbolic.Variable>()) {
     215      foreach (var varSymbol in grammar.Symbols.OfType<HeuristicLab.Problems.DataAnalysis.Symbolic.VariableBase>()) {
    216216        if (!varSymbol.Fixed) {
    217217          varSymbol.AllVariableNames = problemData.InputVariables.Select(x => x.Value).Where(x => ds.VariableHasType<double>(x));
    … …  
    225225          factorSymbol.VariableValues = factorSymbol.VariableNames
    226226            .ToDictionary(varName => varName, varName => ds.GetStringValues(varName).Distinct().ToList());
    227         }
    228       }
    229       foreach (var varSymbol in grammar.Symbols.OfType<HeuristicLab.Problems.DataAnalysis.Symbolic.VariableCondition>()) {
    230         if (!varSymbol.Fixed) {
    231           varSymbol.AllVariableNames = problemData.InputVariables.Select(x => x.Value).Where(x => ds.VariableHasType<double>(x));
    232           varSymbol.VariableNames = problemData.AllowedInputVariables;
    233227        }
    234228      }

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

    r14237 r14238  
    3939    }
    4040    public Variable() : base("Variable", "Represents a variable value.") { }
     41    public Variable(string name, string description) : base(name, description) { }
    4142
    4243    public override ISymbolicExpressionTreeNode CreateTreeNode() {

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

    r14237 r14238  
    2727namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
    2828  [StorableClass]
    29   public abstract class VariableBase : Symbol {
     29  public abstract class VariableBase : Symbol, IVariableSymbol {
    3030    #region Properties
    3131    [Storable]

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

    r14185 r14238  
    3030  [StorableClass]
    3131  [Item("Variable Condition", "Represents a condition that tests a given variable against a specified threshold.")]
    32   public sealed class VariableCondition : Symbol {
     32  public sealed class VariableCondition : Symbol, IVariableSymbol {
    3333    #region properties
    3434    [Storable]

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

    r14185 r14238  
    2929namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
    3030  [StorableClass]
    31   public sealed class VariableConditionTreeNode : SymbolicExpressionTreeNode {
     31  public sealed class VariableConditionTreeNode : SymbolicExpressionTreeNode, IVariableTreeNode {
    3232    #region properties
    3333    public new VariableCondition Symbol {

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

    r14237 r14238  
    2727namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
    2828  [StorableClass]
    29   public abstract class VariableTreeNodeBase : SymbolicExpressionTreeTerminalNode {
     29  public abstract class VariableTreeNodeBase : SymbolicExpressionTreeTerminalNode, IVariableTreeNode {
    3030    public new VariableBase Symbol {
    3131      get { return (VariableBase)base.Symbol; }
Note: See TracChangeset for help on using the changeset viewer.