Changeset 2627

Timestamp:

01/14/10 19:42:10 (14 years ago)

Author:

gkronber

Message:

Added test cases for network transformation and fixed bugs in network transformation operator. #833

Location:

trunk/sources

Files:

• HeuristicLab.GP.StructureIdentification.Networks/3.2/FunctionLibraryInjector.cs (modified) (2 diffs)
• HeuristicLab.GP.StructureIdentification.Networks/3.2/NetworkToFunctionTransformer.cs (modified) (7 diffs)
• HeuristicLab.GP.Tests/NetworkToFunctionTransformerTest.cs (modified) (4 diffs)
• HeuristicLab.GP.Tests/SymbolicExpressionImporter.cs (modified) (1 diff)
• HeuristicLab/Files.txt (modified) (1 diff)

trunk/sources/HeuristicLab.GP.StructureIdentification.Networks/3.2/FunctionLibraryInjector.cs

@@ -142 +142 @@
       SetAllowedSubOperators(openDivision, f1Functions);
       SetAllowedSubOperators(openMul, f1Functions);
+      SetAllowedSubOperators(openSub, f1Functions);
 
       if (includeDifferential)
@@ -153 +154 @@
       openPar.SetConstraints(minTimeOffset, maxTimeOffset);
 
+
       return functionLibrary;
     }

trunk/sources/HeuristicLab.GP.StructureIdentification.Networks/3.2/NetworkToFunctionTransformer.cs

@@ -68 +68 @@
       // create a new sub-scope for each target variable with the transformed expression
       foreach (var targetVariable in targetVariables) {
-        yield return TransformExpression(boundExpression, targetVariable);
+        yield return TransformExpression(boundExpression, targetVariable, targetVariables.Except(new string[] { targetVariable }));
       }
     }
@@ -80 +80 @@
     /// <returns></returns>
     private static IFunctionTree ApplyMetaFunctions(IFunctionTree tree) {
-      IFunctionTree root = ApplyCycles(tree);
-      List<IFunctionTree> subTrees = new List<IFunctionTree>(root.SubTrees);
-      while (root.SubTrees.Count > 0) root.RemoveSubTree(0);
-
-      foreach (IFunctionTree subTree in subTrees) {
-        root.AddSubTree(ApplyFlips(subTree));
-      }
-      return root;
+      return ApplyFlips(ApplyCycles(tree));
     }
 
@@ -95 +88 @@
       } else if (tree.Function is Flip) {
         if (tree.SubTrees[0].Function is OpenParameter) return tree.SubTrees[0];
-        else return ApplyFlips(InvertChain(tree.SubTrees[0]));
+        else return InvertChain(ApplyFlips(tree.SubTrees[0]));
       } else {
-        IFunctionTree tmp = ApplyFlips(tree.SubTrees[0]);
-        tree.RemoveSubTree(0); tree.InsertSubTree(0, tmp);
+        List<IFunctionTree> subTrees = new List<IFunctionTree>(tree.SubTrees);
+        while (tree.SubTrees.Count > 0) tree.RemoveSubTree(0);
+        foreach (var subTree in subTrees) {
+          tree.AddSubTree(ApplyFlips(subTree));
+        }
         return tree;
       }
@@ -191 +187 @@
     }
 
-  
+
 
     private static IFunctionTree AppendLeft(IFunctionTree tree, IFunctionTree node) {
@@ -201 +197 @@
 
     private static bool IsBottomLeft(IFunctionTree tree) {
-      if(tree.SubTrees.Count==0) return true;
-      else if(tree.SubTrees[0].Function is Variable) return true;
-      else if(tree.SubTrees[0].Function is Constant) return true;
+      if (tree.SubTrees.Count == 0) return true;
+      else if (tree.SubTrees[0].Function is Variable) return true;
+      else if (tree.SubTrees[0].Function is Constant) return true;
       else return false;
     }
 
     /// <summary>
-    /// recieves a function tree with an F2 root and branches containing only F0 functions and transforms it into a function-tree for the given target variable
+    /// recieves a function tree transforms it into a function-tree for the given target variable
     /// </summary>
     /// <param name="tree"></param>
     /// <param name="targetVariable"></param>
     /// <returns></returns>
-    private static IFunctionTree TransformExpression(IFunctionTree tree, string targetVariable) {
+    private static IFunctionTree TransformExpression(IFunctionTree tree, string targetVariable, IEnumerable<string> parameters) {
+      if (tree.Function is Addition || tree.Function is Subtraction ||
+          tree.Function is Multiplication || tree.Function is Division ||
+          tree.Function is Exponential || tree.Function is Logarithm) {
+        var occuringVariables = from x in FunctionTreeIterator.IteratePrefix(tree)
+                                where x is VariableFunctionTree
+                                let name = ((VariableFunctionTree)x).VariableName
+                                select name;
+        var openParameters = (new string[] { targetVariable }).Concat(parameters);
+        var missingVariables = openParameters.Except(occuringVariables);
+        if (missingVariables.Count() > 0) {
+          VariableFunctionTree varTree = (VariableFunctionTree)(new Variable()).GetTreeNode();
+          varTree.VariableName = missingVariables.First();
+          varTree.SampleOffset = 0;
+          varTree.Weight = 1.0;
+          tree = (IFunctionTree)tree.Clone();
+          tree.InsertSubTree(0, varTree);
+        }
+      }
       int targetIndex = -1;
-      IFunctionTree combinator;
+      IFunctionTree combinator = null;
       List<IFunctionTree> subTrees = new List<IFunctionTree>(tree.SubTrees);
-      //while (tree.SubTrees.Count > 0) tree.RemoveSubTree(0);
       if (HasTargetVariable(subTrees[0], targetVariable)) {
         targetIndex = 0;
-        combinator = FunctionFromCombinator(tree);
+        combinator = FunctionFromCombinator(tree).GetTreeNode();
       } else {
         for (int i = 1; i < subTrees.Count; i++) {
           if (HasTargetVariable(subTrees[i], targetVariable)) {
             targetIndex = i;
+            combinator = GetInvertedFunction(FunctionFromCombinator(tree)).GetTreeNode();
             break;
           }
         }
-        combinator = FunctionFromCombinator(InvertCombinator(tree));
-      }
-      // not found
-      if (targetIndex == -1) throw new InvalidOperationException();
-
-      for (int i = 0; i < subTrees.Count; i++) {
-        if (i != targetIndex)
-          combinator.AddSubTree(subTrees[i]);
-      }
-      if (subTrees[targetIndex].Function is Variable) return combinator;
-      else {
-        IFunctionTree targetChain = InvertF0Chain(subTrees[targetIndex]);
-        AppendLeft(targetChain, combinator);
-        return targetChain;
+      }
+      if (targetIndex == -1) {
+        // target variable was not found
+        return tree;
+      } else {
+        // target variable was found
+        for (int i = 0; i < subTrees.Count; i++) {
+          if (i != targetIndex)
+            combinator.AddSubTree(subTrees[i]);
+        }
+        if (subTrees[targetIndex].Function is Variable || subTrees[targetIndex].Function is Constant) return combinator;
+        else {
+          IFunctionTree targetChain = InvertF0Chain(subTrees[targetIndex]);
+          AppendLeft(targetChain, combinator);
+          return targetChain;
+        }
       }
     }
@@ -273 +289 @@
     }
 
-  
-    private static IFunctionTree InvertCombinator(IFunctionTree tree) {
-      if (tree.Function is OpenAddition) {
-        return (new OpenSubtraction()).GetTreeNode();
-      } else if (tree.Function is OpenSubtraction) {
-        return (new OpenAddition()).GetTreeNode();
-      } else if (tree.Function is OpenMultiplication) {
-        return (new OpenDivision()).GetTreeNode();
-      } else if (tree.Function is OpenDivision) {
-        return (new OpenMultiplication()).GetTreeNode();
-      } else throw new InvalidOperationException();
-    }
-
-    private static IFunctionTree FunctionFromCombinator(IFunctionTree tree) {
-      if (tree.Function is OpenAddition) {
-        return (new Addition()).GetTreeNode();
-      } else if (tree.Function is OpenSubtraction) {
-        return (new Subtraction()).GetTreeNode();
-      } else if (tree.Function is OpenMultiplication) {
-        return (new Multiplication()).GetTreeNode();
-      } else if (tree.Function is OpenDivision) {
-        return (new Division()).GetTreeNode();
-      } else throw new InvalidOperationException();
+
+
+    //private static IFunctionTree InvertCombinator(IFunctionTree tree) {
+    //  if (tree.Function is OpenAddition) {
+    //    return (new OpenSubtraction()).GetTreeNode();
+    //  } else if (tree.Function is OpenSubtraction) {
+    //    return (new OpenAddition()).GetTreeNode();
+    //  } else if (tree.Function is OpenMultiplication) {
+    //    return (new OpenDivision()).GetTreeNode();
+    //  } else if (tree.Function is OpenDivision) {
+    //    return (new OpenMultiplication()).GetTreeNode();
+    //  } else throw new InvalidOperationException();
+    //}
+
+    private static Dictionary<Type, IFunction> combinatorFunction = new Dictionary<Type, IFunction>() {
+      { typeof(OpenAddition), new Addition()},
+      { typeof(OpenSubtraction), new Subtraction()},
+      { typeof(OpenDivision), new Division()},
+      { typeof(OpenMultiplication), new Multiplication()},
+      { typeof(Addition), new Addition()},
+      { typeof(Subtraction), new Subtraction()},
+      { typeof(Division), new Division()},
+      { typeof(Multiplication), new Multiplication()},
+      { typeof(Logarithm), new Logarithm()},
+      { typeof(Exponential), new Exponential()},
+    };
+    private static IFunction FunctionFromCombinator(IFunctionTree tree) {
+      return combinatorFunction[tree.Function.GetType()];
     }
 
@@ -318 +339 @@
       {typeof(DivisionF1), new Division()},
       {typeof(OpenExp), new Exponential()},
-      {typeof(OpenLog), new OpenLog()},
+      {typeof(OpenLog), new Logarithm()},
       //{typeof(OpenSqr), new Power()},
       //{typeof(OpenSqrt), new Sqrt()},

trunk/sources/HeuristicLab.GP.Tests/NetworkToFunctionTransformerTest.cs

@@ -6 +6 @@
 using System.Linq;
 using System.Collections.Generic;
+using HeuristicLab.Random;
+using HeuristicLab.DataAnalysis;
 
 namespace HeuristicLab.GP.Test {
@@ -197 +199 @@
       }
       {
-        IFunctionTree tree = importer.Import(@"(cycle (open-+
-                                                         (flip (f1-+ 
-                                                           (flip (f1-- 
-                                                             (flip (f1-/ 
-                                                               (open-param - 0) 4.0)) 3.0)) 2.0))
-                                                         (open-param - 0) 
-                                                         (open-param - 0)))");
+        IFunctionTree tree = importer.Import(@"(open-+
+                                                 (flip (f1-+ 
+                                                   (flip (f1-- 
+                                                     (flip (f1-/ 
+                                                       (open-param - 0) 4.0)) 3.0)) 2.0))
+                                                 (open-param - 0) 
+                                                 (open-param - 0)))");
         // -3*4-2 x
         IEnumerable<IFunctionTree> actualTrees = NetworkToFunctionTransformer_Accessor.Transform(tree, new List<string>() { "a", "b", "c" });
 
-        IFunctionTree t0 = importer.Import("(+ (/ (- (+ (variable 1.0 b 0) (variable 1.0 c 0)) 3.0) 4.0) 2.0)");
+        IFunctionTree t0 = importer.Import("(+ (/ (+ (+ (variable 1.0 b 0) (variable 1.0 c 0)) 3.0) 4.0) 2.0)");
         IFunctionTree t1 = importer.Import("(- (- (* (- (variable 1.0 a 0) 2.0) 4.0) 3.0) (variable 1.0 c 0))");
         IFunctionTree t2 = importer.Import("(- (- (* (- (variable 1.0 a 0) 2.0) 4.0) 3.0) (variable 1.0 b 0))");
@@ -216 +218 @@
       });
       }
-
+      {
+        // constant expression
+        IFunctionTree tree = importer.Import(@"(* (variable 1.0 d 0) (variable 1.0 d 0))");
+
+        IEnumerable<IFunctionTree> actualTrees = NetworkToFunctionTransformer_Accessor.Transform(tree, new List<string>() { "a", "b", "c" });
+
+        IFunctionTree t0 = importer.Import("(* (variable 1.0 d 0) (variable 1.0 d 0))");
+        IFunctionTree t1 = importer.Import("(* (variable 1.0 d 0) (variable 1.0 d 0))");
+        IFunctionTree t2 = importer.Import("(* (variable 1.0 d 0) (variable 1.0 d 0))");
+
+
+        CompareTrees(actualTrees, new List<IFunctionTree>() {
+        t0, t1, t2
+        });
+      }
+      {
+        // expression with one parameter
+        IFunctionTree tree = importer.Import(@"(f1-* (variable 1.0 a 0) (variable 1.0 d 0))");
+
+        IEnumerable<IFunctionTree> actualTrees = NetworkToFunctionTransformer_Accessor.Transform(tree, new List<string>() { "a", "b", "c" });
+
+        IFunctionTree t0 = importer.Import("(/ (variable 1.0 b 0) (variable 1.0 d 0))");
+        IFunctionTree t1 = importer.Import("(* (variable 1.0 a 0) (variable 1.0 d 0))");
+        IFunctionTree t2 = importer.Import("(* (variable 1.0 a 0) (variable 1.0 d 0))");
+
+
+        CompareTrees(actualTrees, new List<IFunctionTree>() {
+        t0, t1, t2
+        });
+      }
+      {
+        // expression with one parameter
+        IFunctionTree tree = importer.Import(@"(open-log (variable 1.0 a 0))");
+
+        IEnumerable<IFunctionTree> actualTrees = NetworkToFunctionTransformer_Accessor.Transform(tree, new List<string>() { "a", "b", "c" });
+
+        IFunctionTree t0 = importer.Import("(exp (variable 1.0 b 0))");
+        IFunctionTree t1 = importer.Import("(log (variable 1.0 a 0))");
+        IFunctionTree t2 = importer.Import("(log (variable 1.0 a 0))");
+
+
+        CompareTrees(actualTrees, new List<IFunctionTree>() {
+        t0, t1, t2
+        });
+      }
+      {
+        // expression with flip and one parameter
+        IFunctionTree tree = importer.Import(@"(flip (open-log (variable 1.0 a 0)))");
+
+        IEnumerable<IFunctionTree> actualTrees = NetworkToFunctionTransformer_Accessor.Transform(tree, new List<string>() { "a", "b", "c" });
+
+        IFunctionTree t0 = importer.Import("(log (variable 1.0 b 0))");
+        IFunctionTree t1 = importer.Import("(exp (variable 1.0 a 0))");
+        IFunctionTree t2 = importer.Import("(exp (variable 1.0 a 0))");
+
+
+        CompareTrees(actualTrees, new List<IFunctionTree>() {
+        t0, t1, t2
+        });
+      }
     }
 
@@ -245 +306 @@
       }
     }
+
+    [TestMethod()]
+    [DeploymentItem("HeuristicLab.GP.StructureIdentification.Networks-3.2.dll")]
+    public void TransformRandomTreesTest() {
+
+      MersenneTwister twister = new MersenneTwister();
+      Dataset ds = Util.CreateRandomDataset(twister, 1, 20);
+      IFunctionTree[] randomTrees = Util.CreateRandomTrees(twister, ds, FunctionLibraryInjector.Create(false, 0, 0), 1000, 1, 100);
+      foreach (var tree in randomTrees) {
+        IEnumerable<IFunctionTree> actualTrees = NetworkToFunctionTransformer_Accessor.Transform(tree, new List<string>() { "a", "b", "c" });
+        actualTrees.ToList();
+      }
+    }
   }
 }

trunk/sources/HeuristicLab.GP.Tests/SymbolicExpressionImporter.cs

@@ -62 +62 @@
         {"open-*", new HeuristicLab.GP.StructureIdentification.Networks.OpenMultiplication()},
         {"open-/", new HeuristicLab.GP.StructureIdentification.Networks.OpenDivision()},
-        {"open-log", new HeuristicLab.GP.StructureIdentification.Networks.OpenExp()},
-        {"open-exp", new HeuristicLab.GP.StructureIdentification.Networks.OpenLog()},
+        {"open-log", new HeuristicLab.GP.StructureIdentification.Networks.OpenLog()},
+        {"open-exp", new HeuristicLab.GP.StructureIdentification.Networks.OpenExp()},
         //{"open-sqr", new HeuristicLab.GP.StructureIdentification.Networks.OpenSqr()},
         //{"open-sqrt", new HeuristicLab.GP.StructureIdentification.Networks.OpenSqrt()},

trunk/sources/HeuristicLab/Files.txt

@@ -46 +46 @@
 HeuristicLab.GP.StructureIdentification.ConditionalEvaluation\3.3:HeuristicLab.GP.StructureIdentification.ConditionalEvaluation-3.3.dll 
 HeuristicLab.GP.StructureIdentification.TimeSeries\3.3:HeuristicLab.GP.StructureIdentification.TimeSeries-3.3.dll 
+HeuristicLab.GP.StructureIdentification.Networks\3.2:HeuristicLab.GP.StructureIdentification.Networks-3.2.dll 
 
 HeuristicLab.Grid\3.2:HeuristicLab.Grid-3.2.dll