Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
01/22/10 16:06:48 (15 years ago)
Author:
gkronber
Message:

Added weights for open parameters. #833 (Genetic Programming based search for equations (modeling with multiple target variables))

Location:
trunk/sources/HeuristicLab.GP.StructureIdentification.Networks/3.2
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/sources/HeuristicLab.GP.StructureIdentification.Networks/3.2/NetworkToFunctionTransformer.cs

    r2635 r2674  
    3030using HeuristicLab.DataAnalysis;
    3131using System.Diagnostics;
     32using HeuristicLab.Common;
    3233
    3334namespace HeuristicLab.GP.StructureIdentification.Networks {
     
    9394      } else if (tree.Function is Flip) {
    9495        var partiallyAppliedBranch = ApplyFlips(tree.SubTrees[0]);
    95         if (partiallyAppliedBranch.Function is OpenParameter) return partiallyAppliedBranch;
    96         else return InvertChain(partiallyAppliedBranch);
     96        if (partiallyAppliedBranch.Function is OpenParameter) {
     97          var openParFunTree = (OpenParameterFunctionTree)partiallyAppliedBranch;
     98          openParFunTree.Weight = 1.0 / openParFunTree.Weight;
     99          return partiallyAppliedBranch;
     100        } else return InvertChain(partiallyAppliedBranch);
    97101      } else {
    98102        List<IFunctionTree> subTrees = new List<IFunctionTree>(tree.SubTrees);
     
    116120      // get a list of function trees from bottom to top
    117121      List<IFunctionTree> reversedChain = new List<IFunctionTree>(currentChain.Reverse<IFunctionTree>().Skip(1));
    118       IFunctionTree openParam = currentChain.Last();
     122      OpenParameterFunctionTree openParam = (OpenParameterFunctionTree)currentChain.Last();
    119123
    120124      // build new tree by inverting every function in the reversed chain and keeping f0 branches untouched.
     
    136140        }
    137141      }
     142      // invert factor of openParam
     143      openParam.Weight = 1.0 / openParam.Weight;
    138144      // append open param at the end
    139145      invParent.InsertSubTree(0, openParam);
     
    195201
    196202
    197     private static IFunctionTree AppendLeft(IFunctionTree tree, IFunctionTree node) {
    198       IFunctionTree originalTree = tree;
    199       while (!IsBottomLeft(tree)) tree = tree.SubTrees[0];
    200       tree.InsertSubTree(0, node);
    201       return originalTree;
    202     }
     203    //private static IFunctionTree AppendLeft(IFunctionTree tree, IFunctionTree node) {
     204    //  IFunctionTree originalTree = tree;
     205    //  while (!IsBottomLeft(tree)) tree = tree.SubTrees[0];
     206    //  tree.InsertSubTree(0, node);
     207    //  return originalTree;
     208    //}
    203209
    204210    private static bool IsBottomLeft(IFunctionTree tree) {
     
    265271            combinator.AddSubTree(subTrees[i]);
    266272        }
    267         if (subTrees[targetIndex].Function is Variable) return combinator;
     273        if (subTrees[targetIndex].Function is Variable) return MakeMultiplication(combinator, 1.0 / GetTargetVariableWeight(subTrees[targetIndex]));
    268274        else {
    269275          IFunctionTree bottomLeft;
    270276          IFunctionTree targetChain = InvertF0Chain(subTrees[targetIndex], out bottomLeft);
    271277          bottomLeft.InsertSubTree(0, combinator);
    272           return targetChain;
    273         }
    274       }
     278          return MakeMultiplication(targetChain, 1.0 / GetTargetVariableWeight(subTrees[targetIndex]));
     279        }
     280      }
     281    }
     282
     283    private static IFunctionTree MakeMultiplication(IFunctionTree tree, double p) {
     284      if (p.IsAlmost(1.0)) return tree;
     285      var mul = (new Multiplication()).GetTreeNode();
     286      var constP = (ConstantFunctionTree)(new Constant()).GetTreeNode();
     287      constP.Value = p;
     288      mul.AddSubTree(tree);
     289      mul.AddSubTree(constP);
     290      return mul;
     291    }
     292
     293    private static double GetTargetVariableWeight(IFunctionTree tree) {
     294      while (tree.SubTrees.Count > 0) {
     295        tree = tree.SubTrees[0];
     296      }
     297      return ((VariableFunctionTree)tree).Weight;
    275298    }
    276299
     
    377400        varTreeNode.VariableName = targetVariables.Current;
    378401        varTreeNode.SampleOffset = ((OpenParameterFunctionTree)tree).SampleOffset;
    379         varTreeNode.Weight = 1.0;
     402        varTreeNode.Weight = ((OpenParameterFunctionTree)tree).Weight;
    380403        return varTreeNode;
    381404        //} else if (matchingFunction is Power) {
  • trunk/sources/HeuristicLab.GP.StructureIdentification.Networks/3.2/Symbols/OpenParameterFunctionTree.cs

    r2616 r2674  
    3030    public string VariableName { get; set; }
    3131    public int SampleOffset { get; set; }
     32    public double Weight { get; set; }
    3233
    3334    public OpenParameterFunctionTree(OpenParameter openParameter)
    3435      : base(openParameter) {
     36      this.Weight = 1.0;
    3537    }
    3638
     
    3941      VariableName = original.VariableName;
    4042      SampleOffset = original.SampleOffset;
     43      Weight = original.Weight;
    4144    }
    4245
     
    5154      scope.AddSubScope(myVariableScope);
    5255      myVariableScope.AddVariable(CreateSampleOffsetVariable());
     56      myVariableScope.AddVariable(CreateWeightVariable());
    5357      return new AtomicOperation(Function.Manipulator, myVariableScope);
    5458    }
     
    5862      scope.AddSubScope(myVariableScope);
    5963      myVariableScope.AddVariable(CreateSampleOffsetVariable());
     64      myVariableScope.AddVariable(CreateWeightVariable());
    6065      return new AtomicOperation(Function.Initializer, myVariableScope);
    6166    }
     
    7277    public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<System.Guid, IStorable> persistedObjects) {
    7378      XmlNode node = document.CreateElement(name);
     79      XmlAttribute weightAttr = document.CreateAttribute("Weight");
     80      weightAttr.Value = XmlConvert.ToString(Weight);
    7481      XmlAttribute variableAttr = document.CreateAttribute("Variable");
    7582      variableAttr.Value = VariableName;
    7683      XmlAttribute sampleOffsetAttr = document.CreateAttribute("SampleOffset");
    7784      sampleOffsetAttr.Value = XmlConvert.ToString(SampleOffset);
     85      node.Attributes.Append(weightAttr);
    7886      node.Attributes.Append(sampleOffsetAttr);
    7987      node.Attributes.Append(variableAttr);
     
    8391    public override void Populate(XmlNode node, IDictionary<System.Guid, IStorable> restoredObjects) {
    8492      base.Populate(node, restoredObjects);
     93      Weight = XmlConvert.ToDouble(node.Attributes["Weight"].Value);
    8594      SampleOffset = XmlConvert.ToInt32(node.Attributes["SampleOffset"].Value);
    8695      VariableName = node.Attributes["Variable"].Value;
     
    103112      return variable;
    104113    }
     114
     115    private IVariable CreateWeightVariable() {
     116      DoubleData data = new DoubleData(Weight);
     117      data.Changed += (sender, args) => Weight = data.Data;
     118      var variable = new HeuristicLab.Core.Variable(Variable.WEIGHT, data);
     119      variable.ValueChanged += (sender, args) => Weight = ((DoubleData)variable.Value).Data;
     120      return variable;
     121    }
    105122  }
    106123}
Note: See TracChangeset for help on using the changeset viewer.