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);