public AntTrail(BoolMatrix world, SymbolicExpressionTree expression, IntValue maxTimeSteps) : this() { this.world = world; this.expression = expression; this.maxTimeSteps = maxTimeSteps; Initialize(); }
public static ISymbolicExpressionTree CreateExpressionTree(IRandom random, ISymbolicExpressionGrammar grammar, int targetLength, int maxTreeDepth) { SymbolicExpressionTree tree = new SymbolicExpressionTree(); var rootNode = (SymbolicExpressionTreeTopLevelNode)grammar.ProgramRootSymbol.CreateTreeNode(); if (rootNode.HasLocalParameters) { rootNode.ResetLocalParameters(random); } rootNode.SetGrammar(grammar.CreateExpressionTreeGrammar()); var startNode = (SymbolicExpressionTreeTopLevelNode)grammar.StartSymbol.CreateTreeNode(); if (startNode.HasLocalParameters) { startNode.ResetLocalParameters(random); } startNode.SetGrammar(grammar.CreateExpressionTreeGrammar()); rootNode.AddSubtree(startNode); bool success = TryCreateFullTreeFromSeed(random, startNode, targetLength - 2, maxTreeDepth - 1); if (!success) { throw new InvalidOperationException(string.Format("Could not create a tree with target length {0} and max depth {1}", targetLength, maxTreeDepth)); } tree.Root = rootNode; return(tree); }
/// <summary> /// Create a symbolic expression tree using 'RampedHalfAndHalf' strategy. /// Half the trees are created with the 'Grow' method, and the other half are created with the 'Full' method. /// </summary> /// <param name="random">Random generator</param> /// <param name="grammar">Available tree grammar</param> /// <param name="maxTreeLength">Maximum tree length (this parameter is ignored)</param> /// <param name="maxTreeDepth">Maximum tree depth</param> /// <returns></returns> public static ISymbolicExpressionTree Create(IRandom random, ISymbolicExpressionGrammar grammar, int maxTreeLength, int maxTreeDepth) { var tree = new SymbolicExpressionTree(); var rootNode = (SymbolicExpressionTreeTopLevelNode)grammar.ProgramRootSymbol.CreateTreeNode(); if (rootNode.HasLocalParameters) { rootNode.ResetLocalParameters(random); } rootNode.SetGrammar(grammar.CreateExpressionTreeGrammar()); var startNode = (SymbolicExpressionTreeTopLevelNode)grammar.StartSymbol.CreateTreeNode(); if (startNode.HasLocalParameters) { startNode.ResetLocalParameters(random); } startNode.SetGrammar(grammar.CreateExpressionTreeGrammar()); rootNode.AddSubtree(startNode); double p = random.NextDouble(); if (p < 0.5) { GrowTreeCreator.Create(random, startNode, maxTreeDepth - 2); } else { FullTreeCreator.Create(random, startNode, maxTreeDepth - 2); } tree.Root = rootNode; return(tree); }
protected override void ConvertSymbolicExpressionTree(SymbolicExpressionTree tree, string name, SolutionMessage.Builder builder) { string stringRep = formatter.Format(tree); stringRep.Replace(Environment.NewLine, ""); SolutionMessage.Types.StringVariable.Builder stringVariable = SolutionMessage.Types.StringVariable.CreateBuilder(); stringVariable.SetName(name).SetData(stringRep); builder.AddStringVars(stringVariable.Build()); }
protected override void ConvertSymbolicExpressionTree(SymbolicExpressionTree tree, string name, SolutionMessage.Builder builder) { using (MemoryStream memoryStream = new MemoryStream()) { Persistence.Default.Xml.XmlGenerator.Serialize(tree, memoryStream); byte[] byteRep = memoryStream.ToArray(); SolutionMessage.Types.RawVariable.Builder rawVariable = SolutionMessage.Types.RawVariable.CreateBuilder(); rawVariable.SetName(name).SetData(ByteString.CopyFrom(byteRep)); builder.AddRawVars(rawVariable.Build()); } }
public InteractiveSymbolicTimeSeriesPrognosisSolutionSimplifierView() : base() { InitializeComponent(); this.Caption = "Interactive Time-Series Prognosis Solution Simplifier"; constantNode = ((ConstantTreeNode)new Constant().CreateTreeNode()); ISymbolicExpressionTreeNode root = new ProgramRootSymbol().CreateTreeNode(); ISymbolicExpressionTreeNode start = new StartSymbol().CreateTreeNode(); root.AddSubtree(start); tempTree = new SymbolicExpressionTree(root); }
/// <summary> /// Maps a genotype (an integer vector) to a phenotype (a symbolic expression tree). /// Random approach. /// </summary> /// <param name="random">random number generator</param> /// <param name="bounds">only used for PIGEMapper (ignore here)</param> /// <param name="length">only used for PIGEMapper (ignore here)</param> /// <param name="grammar">grammar definition</param> /// <param name="genotype">integer vector, which should be mapped to a tree</param> /// <returns>phenotype (a symbolic expression tree)</returns> public override SymbolicExpressionTree Map(IRandom random, IntMatrix bounds, int length, ISymbolicExpressionGrammar grammar, IntegerVector genotype) { SymbolicExpressionTree tree = new SymbolicExpressionTree(); var rootNode = (SymbolicExpressionTreeTopLevelNode)grammar.ProgramRootSymbol.CreateTreeNode(); var startNode = (SymbolicExpressionTreeTopLevelNode)grammar.StartSymbol.CreateTreeNode(); rootNode.AddSubtree(startNode); tree.Root = rootNode; MapRandomIteratively(startNode, genotype, grammar, genotype.Length, random); return tree; }
public static ISymbolicExpressionTree Create(IRandom random, ISymbolicExpressionGrammar grammar, int maxTreeLength, int maxTreeDepth) { SymbolicExpressionTree tree = new SymbolicExpressionTree(); var rootNode = (SymbolicExpressionTreeTopLevelNode)grammar.ProgramRootSymbol.CreateTreeNode(); if (rootNode.HasLocalParameters) rootNode.ResetLocalParameters(random); rootNode.SetGrammar(grammar.CreateExpressionTreeGrammar()); var startNode = (SymbolicExpressionTreeTopLevelNode)grammar.StartSymbol.CreateTreeNode(); if (startNode.HasLocalParameters) startNode.ResetLocalParameters(random); startNode.SetGrammar(grammar.CreateExpressionTreeGrammar()); rootNode.AddSubtree(startNode); PTC2(random, startNode, maxTreeLength, maxTreeDepth); tree.Root = rootNode; return tree; }
protected static double CalculateReplacementValue(ISymbolicExpressionTreeNode node, ISymbolicExpressionTree sourceTree, ISymbolicDataAnalysisExpressionTreeInterpreter interpreter, IDataset dataset, IEnumerable<int> rows) { //optimization: constant nodes return always the same value ConstantTreeNode constantNode = node as ConstantTreeNode; if (constantNode != null) return constantNode.Value; var rootSymbol = new ProgramRootSymbol().CreateTreeNode(); var startSymbol = new StartSymbol().CreateTreeNode(); rootSymbol.AddSubtree(startSymbol); startSymbol.AddSubtree((ISymbolicExpressionTreeNode)node.Clone()); var tempTree = new SymbolicExpressionTree(rootSymbol); // clone ADFs of source tree for (int i = 1; i < sourceTree.Root.SubtreeCount; i++) { tempTree.Root.AddSubtree((ISymbolicExpressionTreeNode)sourceTree.Root.GetSubtree(i).Clone()); } return interpreter.GetSymbolicExpressionTreeValues(tempTree, dataset, rows).Median(); }
public static ISymbolicExpressionTree CreateExpressionTree(IRandom random, ISymbolicExpressionGrammar grammar, int targetLength, int maxTreeDepth) { SymbolicExpressionTree tree = new SymbolicExpressionTree(); var rootNode = (SymbolicExpressionTreeTopLevelNode)grammar.ProgramRootSymbol.CreateTreeNode(); if (rootNode.HasLocalParameters) rootNode.ResetLocalParameters(random); rootNode.SetGrammar(grammar.CreateExpressionTreeGrammar()); var startNode = (SymbolicExpressionTreeTopLevelNode)grammar.StartSymbol.CreateTreeNode(); if (startNode.HasLocalParameters) startNode.ResetLocalParameters(random); startNode.SetGrammar(grammar.CreateExpressionTreeGrammar()); rootNode.AddSubtree(startNode); bool success = TryCreateFullTreeFromSeed(random, startNode, targetLength - 2, maxTreeDepth - 1); if (!success) throw new InvalidOperationException(string.Format("Could not create a tree with target length {0} and max depth {1}", targetLength, maxTreeDepth)); tree.Root = rootNode; return tree; }
/// <summary> /// Create a symbolic expression tree using 'RampedHalfAndHalf' strategy. /// Half the trees are created with the 'Grow' method, and the other half are created with the 'Full' method. /// </summary> /// <param name="random">Random generator</param> /// <param name="grammar">Available tree grammar</param> /// <param name="maxTreeLength">Maximum tree length (this parameter is ignored)</param> /// <param name="maxTreeDepth">Maximum tree depth</param> /// <returns></returns> public static ISymbolicExpressionTree Create(IRandom random, ISymbolicExpressionGrammar grammar, int maxTreeLength, int maxTreeDepth) { var tree = new SymbolicExpressionTree(); var rootNode = (SymbolicExpressionTreeTopLevelNode)grammar.ProgramRootSymbol.CreateTreeNode(); if (rootNode.HasLocalParameters) rootNode.ResetLocalParameters(random); rootNode.SetGrammar(grammar.CreateExpressionTreeGrammar()); var startNode = (SymbolicExpressionTreeTopLevelNode)grammar.StartSymbol.CreateTreeNode(); if (startNode.HasLocalParameters) startNode.ResetLocalParameters(random); startNode.SetGrammar(grammar.CreateExpressionTreeGrammar()); rootNode.AddSubtree(startNode); double p = random.NextDouble(); if (p < 0.5) GrowTreeCreator.Create(random, startNode, maxTreeDepth - 2); else FullTreeCreator.Create(random, startNode, maxTreeDepth - 2); tree.Root = rootNode; return tree; }
public void ProbabilisticTreeCreatorSpecificTreeSizesTest() { var trees = new List<ISymbolicExpressionTree>(); var grammar = Grammars.CreateSimpleArithmeticGrammar(); var random = new MersenneTwister(31415); var treeGrammarType = SymbolicExpressionTreeGrammar_Accessor.ShadowedType.ReferencedType; for (int targetTreeSize = 1; targetTreeSize <= 100; targetTreeSize++) { var tree = new SymbolicExpressionTree(); var rootNode = (SymbolicExpressionTreeTopLevelNode)grammar.ProgramRootSymbol.CreateTreeNode(); rootNode.SetGrammar((ISymbolicExpressionTreeGrammar)Activator.CreateInstance(treeGrammarType, grammar)); if (rootNode.HasLocalParameters) rootNode.ResetLocalParameters(random); var startNode = (SymbolicExpressionTreeTopLevelNode)grammar.StartSymbol.CreateTreeNode(); startNode.SetGrammar((ISymbolicExpressionTreeGrammar)Activator.CreateInstance(treeGrammarType, grammar)); if (startNode.HasLocalParameters) startNode.ResetLocalParameters(random); rootNode.AddSubtree(startNode); ProbabilisticTreeCreator_Accessor.TryCreateFullTreeFromSeed(random, startNode, targetTreeSize, ((int)Math.Log(targetTreeSize, 2)) + 1); tree.Root = rootNode; //mkommend: commented due to performance issues on the builder // Assert.AreEqual(targetTreeSize + 2, tree.Length); //the root and start node must be additionally added } }
public static ISymbolicExpressionTree Create(IRandom random, ISymbolicExpressionGrammar grammar, int maxTreeLength, int maxTreeDepth) { SymbolicExpressionTree tree = new SymbolicExpressionTree(); var rootNode = (SymbolicExpressionTreeTopLevelNode)grammar.ProgramRootSymbol.CreateTreeNode(); if (rootNode.HasLocalParameters) { rootNode.ResetLocalParameters(random); } rootNode.SetGrammar(grammar.CreateExpressionTreeGrammar()); var startNode = (SymbolicExpressionTreeTopLevelNode)grammar.StartSymbol.CreateTreeNode(); if (startNode.HasLocalParameters) { startNode.ResetLocalParameters(random); } startNode.SetGrammar(grammar.CreateExpressionTreeGrammar()); rootNode.AddSubtree(startNode); PTC2(random, startNode, maxTreeLength, maxTreeDepth); tree.Root = rootNode; return(tree); }
private AntTrail(AntTrail original, Cloner cloner) : base(original, cloner) { expression = cloner.Clone(original.expression); world = cloner.Clone(original.world); maxTimeSteps = cloner.Clone(original.maxTimeSteps); Initialize(); }
private static ISymbolicRegressionSolution CreateSymbolicSolution(List<IRegressionModel> models, double nu, IRegressionProblemData problemData) { var symbModels = models.OfType<ISymbolicRegressionModel>(); var lowerLimit = symbModels.Min(m => m.LowerEstimationLimit); var upperLimit = symbModels.Max(m => m.UpperEstimationLimit); var interpreter = new SymbolicDataAnalysisExpressionTreeLinearInterpreter(); var progRootNode = new ProgramRootSymbol().CreateTreeNode(); var startNode = new StartSymbol().CreateTreeNode(); var addNode = new Addition().CreateTreeNode(); var mulNode = new Multiplication().CreateTreeNode(); var scaleNode = (ConstantTreeNode)new Constant().CreateTreeNode(); // all models are scaled using the same nu scaleNode.Value = nu; foreach (var m in symbModels) { var relevantPart = m.SymbolicExpressionTree.Root.GetSubtree(0).GetSubtree(0); // skip root and start addNode.AddSubtree((ISymbolicExpressionTreeNode)relevantPart.Clone()); } mulNode.AddSubtree(addNode); mulNode.AddSubtree(scaleNode); startNode.AddSubtree(mulNode); progRootNode.AddSubtree(startNode); var t = new SymbolicExpressionTree(progRootNode); var combinedModel = new SymbolicRegressionModel(problemData.TargetVariable, t, interpreter, lowerLimit, upperLimit); var sol = new SymbolicRegressionSolution(combinedModel, problemData); return sol; }
/// <summary> /// Maps a genotype (an integer vector) to a phenotype (a symbolic expression tree). /// PIGE approach. /// </summary> /// <param name="random">random number generator</param> /// <param name="bounds">integer number range for genomes (codons) of the nont vector</param> /// <param name="length">length of the nont vector to create</param> /// <param name="grammar">grammar definition</param> /// <param name="genotype">integer vector, which should be mapped to a tree</param> /// <returns>phenotype (a symbolic expression tree)</returns> public override ISymbolicExpressionTree Map(IRandom random, IntMatrix bounds, int length, ISymbolicExpressionGrammar grammar, IntegerVector genotype) { SymbolicExpressionTree tree = new SymbolicExpressionTree(); var rootNode = (SymbolicExpressionTreeTopLevelNode)grammar.ProgramRootSymbol.CreateTreeNode(); var startNode = (SymbolicExpressionTreeTopLevelNode)grammar.StartSymbol.CreateTreeNode(); rootNode.AddSubtree(startNode); tree.Root = rootNode; // Map can be called simultaniously on multiple threads lock (nontVectorLocker) { if (NontVector == null) { NontVector = GetNontVector(random, bounds, length); } } MapPIGEIteratively(startNode, genotype, grammar, genotype.Length, random); return tree; }
protected SymbolicExpressionTree(SymbolicExpressionTree original, Cloner cloner) : base(original, cloner) { root = cloner.Clone(original.Root); }
protected SymbolicExpressionTree(SymbolicExpressionTree original, Cloner cloner) : base(original, cloner) { root = cloner.Clone(original.Root); }
protected abstract void ConvertSymbolicExpressionTree(SymbolicExpressionTree tree, string name, SolutionMessage.Builder builder);