コード例 #1
0
        public void ChangeNodeTypeManipulationDistributionsTest()
        {
            SymbolicExpressionTreeStringFormatter formatter = new SymbolicExpressionTreeStringFormatter();
            var trees        = new List <ISymbolicExpressionTree>();
            var grammar      = Grammars.CreateArithmeticAndAdfGrammar();
            var random       = new MersenneTwister(31415);
            int failedEvents = 0;

            for (int i = 0; i < POPULATION_SIZE; i++)
            {
                var    tree         = ProbabilisticTreeCreator.Create(random, grammar, MAX_TREE_LENGTH, MAX_TREE_DEPTH);
                string originalTree = formatter.Format(tree);
                ChangeNodeTypeManipulation.ChangeNodeType(random, tree);
                string manipulatedTree = formatter.Format(tree);
                if (originalTree == manipulatedTree)
                {
                    failedEvents++;
                }
                Util.IsValid(tree);
                trees.Add(tree);
            }
            Console.WriteLine("ChangeNodeTypeManipulation: " + Environment.NewLine +
                              "Failed events: " + failedEvents * 100.0 / POPULATION_SIZE + " %" + Environment.NewLine +
                              Util.GetSizeDistributionString(trees, 105, 5) + Environment.NewLine +
                              Util.GetFunctionDistributionString(trees) + Environment.NewLine +
                              Util.GetNumberOfSubtreesDistributionString(trees) + Environment.NewLine +
                              Util.GetTerminalDistributionString(trees) + Environment.NewLine
                              );
            Assert.IsTrue(failedEvents * 100.0 / POPULATION_SIZE < 5.0); // only max 5% failed mutations are allowed
        }
コード例 #2
0
        public void ArgumentCreaterDistributionsTest()
        {
            var trees     = new List <ISymbolicExpressionTree>();
            var grammar   = Grammars.CreateArithmeticAndAdfGrammar();
            var random    = new MersenneTwister(31415);
            int failedOps = 0;

            for (int i = 0; i < POPULATION_SIZE; i++)
            {
                ISymbolicExpressionTree tree;
                do
                {
                    tree = ProbabilisticTreeCreator.Create(random, grammar, MAX_TREE_LENGTH, MAX_TREE_DEPTH);
                    SubroutineCreater.CreateSubroutine(random, tree, MAX_TREE_LENGTH, MAX_TREE_DEPTH, 3, 3);
                } while (!TreeHasAdfWithParameter(tree, 3));
                var success = ArgumentCreater.CreateNewArgument(random, tree, 60000, 100, 3, 3);
                if (!success)
                {
                    failedOps++;
                }
                Util.IsValid(tree);
                trees.Add(tree);
            }
            // difficult to make sure that create argument operations succeed because trees are macro-expanded can potentially become very big
            // => just test if only a small proportion fails
            Assert.IsTrue(failedOps < POPULATION_SIZE * 0.05); // only 5% may fail
            Console.WriteLine("ArgumentCreator: " + Environment.NewLine +
                              "Failed operations: " + failedOps * 100.0 / POPULATION_SIZE + " %" + Environment.NewLine +
                              Util.GetSizeDistributionString(trees, 200, 20) + Environment.NewLine +
                              Util.GetFunctionDistributionString(trees) + Environment.NewLine +
                              Util.GetNumberOfSubtreesDistributionString(trees) + Environment.NewLine +
                              Util.GetTerminalDistributionString(trees) + Environment.NewLine
                              );
        }
コード例 #3
0
        public void SubroutineDeleterDistributionsTest()
        {
            var trees   = new List <ISymbolicExpressionTree>();
            var grammar = Grammars.CreateArithmeticAndAdfGrammar();
            var random  = new MersenneTwister(31415);

            for (int i = 0; i < POPULATION_SIZE; i++)
            {
                ISymbolicExpressionTree tree = null;
                do
                {
                    tree = ProbabilisticTreeCreator.Create(random, grammar, MAX_TREE_LENGTH, MAX_TREE_DEPTH);
                    SubroutineCreater.CreateSubroutine(random, tree, MAX_TREE_LENGTH, MAX_TREE_DEPTH, 3, 3);
                    SubroutineCreater.CreateSubroutine(random, tree, MAX_TREE_LENGTH, MAX_TREE_DEPTH, 3, 3);
                } while (!HasAtLeastOneAdf(tree));
                var success = SubroutineDeleter.DeleteSubroutine(random, tree, 3, 3);
                Assert.IsTrue(success);
                Util.IsValid(tree);
                trees.Add(tree);
            }
            Console.WriteLine("SubroutineDeleter: " + Environment.NewLine +
                              Util.GetSizeDistributionString(trees, 105, 5) + Environment.NewLine +
                              Util.GetFunctionDistributionString(trees) + Environment.NewLine +
                              Util.GetNumberOfSubtreesDistributionString(trees) + Environment.NewLine +
                              Util.GetTerminalDistributionString(trees) + Environment.NewLine
                              );
        }
コード例 #4
0
        public void ReplaceBranchManipulationDistributionsTest()
        {
            SymbolicExpressionTreeStringFormatter formatter = new SymbolicExpressionTreeStringFormatter();
            var trees   = new List <ISymbolicExpressionTree>();
            var grammar = Grammars.CreateArithmeticAndAdfGrammar();
            var random  = new MersenneTwister(31415);

            for (int i = 0; i < POPULATION_SIZE; i++)
            {
                var tree = ProbabilisticTreeCreator.Create(random, grammar, MAX_TREE_LENGTH, MAX_TREE_DEPTH);
                SubroutineCreater.CreateSubroutine(random, tree, MAX_TREE_LENGTH, MAX_TREE_DEPTH, 3, 3);
                string originalTree = formatter.Format(tree);
                ReplaceBranchManipulation.ReplaceRandomBranch(random, tree, MAX_TREE_LENGTH, MAX_TREE_DEPTH);
                string manipulatedTree = formatter.Format(tree);
                Assert.IsFalse(originalTree == manipulatedTree);
                Util.IsValid(tree);
                trees.Add(tree);
            }
            Console.WriteLine("ReplaceBranchManipulation: " + Environment.NewLine +
                              Util.GetSizeDistributionString(trees, 105, 5) + Environment.NewLine +
                              Util.GetFunctionDistributionString(trees) + Environment.NewLine +
                              Util.GetNumberOfSubtreesDistributionString(trees) + Environment.NewLine +
                              Util.GetTerminalDistributionString(trees) + Environment.NewLine
                              );
        }
コード例 #5
0
        public void ProbabilisticTreeCreatorSpecificTreeSizesTest()
        {
            var grammar = Grammars.CreateSimpleArithmeticGrammar();
            var random  = new MersenneTwister(31415);

            for (int targetTreeSize = 3; targetTreeSize <= 100; targetTreeSize++)
            {
                var tree = ProbabilisticTreeCreator.CreateExpressionTree(random, grammar, targetTreeSize, ((int)Math.Log(targetTreeSize, 2)) + 2);
                Assert.AreEqual(targetTreeSize, tree.Length);
            }
        }
コード例 #6
0
        public void SubtreeCrossoverDistributionsTest()
        {
            int    generations = 5;
            var    trees       = new List <ISymbolicExpressionTree>();
            var    grammar     = Grammars.CreateArithmeticAndAdfGrammar();
            var    random      = new MersenneTwister(31415);
            double msPerCrossoverEvent;

            for (int i = 0; i < POPULATION_SIZE; i++)
            {
                trees.Add(ProbabilisticTreeCreator.Create(random, grammar, 100, 10));
                for (int j = random.Next(3); j < 3; j++)
                {
                    SubroutineCreater.CreateSubroutine(random, trees[i], 100, 10, 3, 3);
                }
            }
            var children = new List <ISymbolicExpressionTree>(trees);

            Stopwatch stopwatch = new Stopwatch();

            stopwatch.Start();
            for (int gCount = 0; gCount < generations; gCount++)
            {
                for (int i = 0; i < POPULATION_SIZE; i++)
                {
                    var par0 = (ISymbolicExpressionTree)trees.SampleRandom(random).Clone();
                    var par1 = (ISymbolicExpressionTree)trees.SampleRandom(random).Clone();
                    children[i] = SubtreeCrossover.Cross(random, par0, par1, 0.9, 100, 10);
                }
                trees = children;
            }
            stopwatch.Stop();
            foreach (var tree in trees)
            {
                Util.IsValid(tree);
            }

            msPerCrossoverEvent = stopwatch.ElapsedMilliseconds / (double)POPULATION_SIZE / (double)generations;

            Console.WriteLine("SubtreeCrossover: " + Environment.NewLine +
                              msPerCrossoverEvent + " ms per crossover event (~" + Math.Round(1000.0 / (msPerCrossoverEvent)) + "crossovers / s)" + Environment.NewLine +
                              Util.GetSizeDistributionString(trees, 105, 5) + Environment.NewLine +
                              Util.GetFunctionDistributionString(trees) + Environment.NewLine +
                              Util.GetNumberOfSubtreesDistributionString(trees) + Environment.NewLine +
                              Util.GetTerminalDistributionString(trees) + Environment.NewLine
                              );

            //mkommend: commented due to performance issues on the builder
            //Assert.IsTrue(Math.Round(1000.0 / (msPerCrossoverEvent)) > 2000); // must achieve more than 2000 x-overs/s
        }
コード例 #7
0
ファイル: Util.cs プロジェクト: stuarthillary/HeuristicLab
 public static ISymbolicExpressionTree[] CreateRandomTrees(MersenneTwister twister, Dataset dataset, ISymbolicExpressionGrammar grammar,
                                                           int popSize, int minSize, int maxSize,
                                                           int maxFunctionDefinitions, int maxFunctionArguments)
 {
     foreach (Variable variableSymbol in grammar.Symbols.OfType <Variable>())
     {
         variableSymbol.VariableNames = dataset.VariableNames.Skip(1);
     }
     ISymbolicExpressionTree[] randomTrees = new ISymbolicExpressionTree[popSize];
     for (int i = 0; i < randomTrees.Length; i++)
     {
         randomTrees[i] = ProbabilisticTreeCreator.Create(twister, grammar, maxSize, 10);
     }
     return(randomTrees);
 }
コード例 #8
0
        protected static ISymbolicExpressionTreeNode GenerateAndInsertNewSubtree(IRandom random, ISymbolicExpressionTreeNode parent, List <ISymbol> allowedSymbols, int childIndex, int maxLength, int maxDepth)
        {
            var weights = allowedSymbols.Select(s => s.InitialFrequency).ToList();

#pragma warning disable 612, 618
            var seedSymbol = allowedSymbols.SelectRandom(weights, random);
#pragma warning restore 612, 618

            // replace the old node with the new node
            var seedNode = seedSymbol.CreateTreeNode();
            if (seedNode.HasLocalParameters)
            {
                seedNode.ResetLocalParameters(random);
            }
            parent.RemoveSubtree(childIndex);
            parent.InsertSubtree(childIndex, seedNode);
            ProbabilisticTreeCreator.PTC2(random, seedNode, maxLength, maxDepth);
            return(seedNode);
        }
コード例 #9
0
        public void ProbabilisticTreeCreaterDistributionsTest()
        {
            var randomTrees = new List <ISymbolicExpressionTree>();
            var grammar     = Grammars.CreateSimpleArithmeticGrammar();
            var random      = new MersenneTwister(31415);
            var stopwatch   = new Stopwatch();

            stopwatch.Start();
            for (int i = 0; i < POPULATION_SIZE; i++)
            {
                randomTrees.Add(ProbabilisticTreeCreator.Create(random, grammar, MAX_TREE_LENGTH, MAX_TREE_DEPTH));
            }
            stopwatch.Stop();

            int count = 0;
            int depth = 0;

            foreach (var tree in randomTrees)
            {
                Util.IsValid(tree);
                count += tree.Length;
                depth += tree.Depth;
            }
            double msPerRandomTreeCreation = stopwatch.ElapsedMilliseconds / (double)POPULATION_SIZE;

            Console.WriteLine("ProbabilisticTreeCreator: " + Environment.NewLine +
                              msPerRandomTreeCreation + " ms per random tree (~" + Math.Round(1000.0 / (msPerRandomTreeCreation)) + "random trees / s)" + Environment.NewLine +
                              Util.GetSizeDistributionString(randomTrees, 105, 5) + Environment.NewLine +
                              Util.GetFunctionDistributionString(randomTrees) + Environment.NewLine +
                              Util.GetNumberOfSubtreesDistributionString(randomTrees) + Environment.NewLine +
                              Util.GetTerminalDistributionString(randomTrees) + Environment.NewLine +
                              "Average tree depth: " + depth / POPULATION_SIZE + Environment.NewLine +
                              "Average tree length: " + count / POPULATION_SIZE + Environment.NewLine +
                              "Total nodes created: " + count + Environment.NewLine
                              );
            //mkommend: commented due to performance issues on the builder
            // Assert.IsTrue(Math.Round(1000.0 / (msPerRandomTreeCreation)) > 250); // must achieve more than 250 random trees / s
        }
コード例 #10
0
        public override void ReplaceBranch(IRandom random, ISymbolicExpressionTree symbolicExpressionTree, ICFGPythonProblemData problemData, ItemArray <PythonStatementSemantic> semantics, PythonProcess pythonProcess, double timeout, int maxTreeLength, int maxTreeDepth, int maximumSemanticTries)
        {
            if (semantics == null || semantics.Length == 0)
            {
                ReplaceBranchManipulation.ReplaceRandomBranch(random, symbolicExpressionTree, maxTreeLength, maxTreeDepth);
                SemanticallyEquivalentMutationParameter.ActualValue = new IntValue(NoSemantics);
                MutationTypeParameter.ActualValue = new IntValue(RandomMutation);
                return;
            }

            var allowedSymbols = new List <ISymbol>();
            ISymbolicExpressionTreeNode parent;
            int childIndex;
            int maxLength;
            int maxDepth;
            // repeat until a fitting parent and child are found (MAX_TRIES times)
            int tries = 0;
            ISymbolicExpressionTreeNode child;

            do
            {
#pragma warning disable 612, 618
                parent = symbolicExpressionTree.Root.IterateNodesPrefix().Skip(1).Where(n => n.SubtreeCount > 0).SelectRandom(random);
#pragma warning restore 612, 618

                childIndex = random.Next(parent.SubtreeCount);
                child      = parent.GetSubtree(childIndex);
                maxLength  = maxTreeLength - symbolicExpressionTree.Length + child.GetLength();
                maxDepth   = maxTreeDepth - symbolicExpressionTree.Root.GetBranchLevel(child);

                allowedSymbols.Clear();
                foreach (var symbol in parent.Grammar.GetAllowedChildSymbols(parent.Symbol, childIndex))
                {
                    // check basic properties that the new symbol must have
                    if ((symbol.Name != child.Symbol.Name || symbol.MinimumArity > 0) &&
                        symbol.InitialFrequency > 0 &&
                        parent.Grammar.GetMinimumExpressionDepth(symbol) <= maxDepth &&
                        parent.Grammar.GetMinimumExpressionLength(symbol) <= maxLength)
                    {
                        allowedSymbols.Add(symbol);
                    }
                }
                tries++;
            } while (tries < MAX_TRIES && allowedSymbols.Count == 0);

            NumberOfTriesParameter.ActualValue = new IntValue(tries); //normal tries. not semantic tries

            if (tries < MAX_TRIES)
            {
                var statementProductionNames = SemanticOperatorHelper.GetSemanticProductionNames(symbolicExpressionTree.Root.Grammar);
                var variables = problemData.Variables.GetVariableNames().ToList();

                #region calculate original json output
                ISymbolicExpressionTreeNode statement = SemanticOperatorHelper.GetStatementNode(child, statementProductionNames);
                string variableSettings = problemData.VariableSettings.Count == 0 ? String.Empty : String.Join(Environment.NewLine, problemData.VariableSettings.Select(x => x.Value));

                var statementPos0 = symbolicExpressionTree.IterateNodesPrefix().ToList().IndexOf(statement);
                if (String.IsNullOrEmpty(variableSettings))
                {
                    variableSettings = SemanticOperatorHelper.SemanticToPythonVariableSettings(semantics.First(x => x.TreeNodePrefixPos == statementPos0).Before, problemData.Variables.GetVariableTypes());
                }

                var jsonOriginal = SemanticOperatorHelper.EvaluateStatementNode(statement, pythonProcess, random, problemData, variables, variableSettings, timeout);
                #endregion

                var weights = allowedSymbols.Select(s => s.InitialFrequency).ToList();
#pragma warning disable 612, 618
                var seedSymbol = allowedSymbols.SelectRandom(weights, random);
#pragma warning restore 612, 618

                // replace the old node with the new node
                var seedNode = seedSymbol.CreateTreeNode();
                if (seedNode.HasLocalParameters)
                {
                    seedNode.ResetLocalParameters(random);
                }

                parent.RemoveSubtree(childIndex);
                parent.InsertSubtree(childIndex, seedNode);
                ProbabilisticTreeCreator.PTC2(random, seedNode, maxLength, maxDepth);

                JObject jsonReplaced;
                if (child == statement)
                {
                    // child is executable, so is the new child
                    jsonReplaced = SemanticOperatorHelper.EvaluateStatementNode(seedNode, pythonProcess, random, problemData, variables, variableSettings, timeout);
                }
                else
                {
                    jsonReplaced = SemanticOperatorHelper.EvaluateStatementNode(statement, pythonProcess, random, problemData, variables, variableSettings, timeout);
                }
                if (JToken.EqualityComparer.Equals(jsonOriginal, jsonReplaced))
                {
                    SemanticallyEquivalentMutationParameter.ActualValue = new IntValue(Equvivalent);
                }
                else
                {
                    SemanticallyEquivalentMutationParameter.ActualValue = new IntValue(Different);
                }

                MutationTypeParameter.ActualValue = new IntValue(RandomMutation);
            }
            else
            {
                SemanticallyEquivalentMutationParameter.ActualValue = new IntValue(NoMutation);
                MutationTypeParameter.ActualValue = new IntValue(NoMutation);
            }
        }
コード例 #11
0
        public void AllArchitectureAlteringOperatorsDistributionTest()
        {
            var trees    = new List <ISymbolicExpressionTree>();
            var newTrees = new List <ISymbolicExpressionTree>();
            var grammar  = Grammars.CreateArithmeticAndAdfGrammar();
            var random   = new MersenneTwister(31415);
            SymbolicExpressionTreeStringFormatter formatter = new SymbolicExpressionTreeStringFormatter();
            IntValue maxTreeSize   = new IntValue(MAX_TREE_LENGTH);
            IntValue maxTreeHeigth = new IntValue(MAX_TREE_DEPTH);
            IntValue maxDefuns     = new IntValue(3);
            IntValue maxArgs       = new IntValue(3);

            for (int i = 0; i < POPULATION_SIZE; i++)
            {
                var tree = ProbabilisticTreeCreator.Create(random, grammar, MAX_TREE_LENGTH, MAX_TREE_DEPTH);
                Util.IsValid(tree);
                trees.Add(tree);
            }
            Stopwatch stopwatch    = new Stopwatch();
            int       failedEvents = 0;

            for (int g = 0; g < N_ITERATIONS; g++)
            {
                for (int i = 0; i < POPULATION_SIZE; i++)
                {
                    if (random.NextDouble() < 0.5)
                    {
                        // manipulate
                        stopwatch.Start();
                        var  selectedTree = (ISymbolicExpressionTree)trees.SampleRandom(random).Clone();
                        var  oldTree      = (ISymbolicExpressionTree)selectedTree.Clone();
                        bool success      = false;
                        int  sw           = random.Next(6);
                        switch (sw)
                        {
                        case 0: success = ArgumentCreater.CreateNewArgument(random, selectedTree, MAX_TREE_LENGTH, MAX_TREE_DEPTH, 3, 3); break;

                        case 1: success = ArgumentDeleter.DeleteArgument(random, selectedTree, 3, 3); break;

                        case 2: success = ArgumentDuplicater.DuplicateArgument(random, selectedTree, 3, 3); break;

                        case 3: success = SubroutineCreater.CreateSubroutine(random, selectedTree, MAX_TREE_LENGTH, MAX_TREE_DEPTH, 3, 3); break;

                        case 4: success = SubroutineDuplicater.DuplicateSubroutine(random, selectedTree, 3, 3); break;

                        case 5: success = SubroutineDeleter.DeleteSubroutine(random, selectedTree, 3, 3); break;
                        }
                        stopwatch.Stop();
                        if (!success)
                        {
                            failedEvents++;
                        }
                        Util.IsValid(selectedTree);
                        newTrees.Add(selectedTree);
                    }
                    else
                    {
                        stopwatch.Start();
                        // crossover
                        SymbolicExpressionTree par0 = null;
                        SymbolicExpressionTree par1 = null;
                        do
                        {
                            par0 = (SymbolicExpressionTree)trees.SampleRandom(random).Clone();
                            par1 = (SymbolicExpressionTree)trees.SampleRandom(random).Clone();
                        } while (par0.Length > MAX_TREE_LENGTH || par1.Length > MAX_TREE_LENGTH);
                        var newTree = SubtreeCrossover.Cross(random, par0, par1, 0.9, MAX_TREE_LENGTH, MAX_TREE_DEPTH);
                        stopwatch.Stop();
                        Util.IsValid(newTree);
                        newTrees.Add(newTree);
                    }
                }
                trees = new List <ISymbolicExpressionTree>(newTrees);
                newTrees.Clear();
            }
            var msPerOperation = stopwatch.ElapsedMilliseconds / ((double)POPULATION_SIZE * (double)N_ITERATIONS);

            Console.WriteLine("AllArchitectureAlteringOperators: " + Environment.NewLine +
                              "Operations / s: ~" + Math.Round(1000.0 / (msPerOperation)) + "operations / s)" + Environment.NewLine +
                              "Failed events: " + failedEvents * 100.0 / (double)(POPULATION_SIZE * N_ITERATIONS / 2.0) + "%" + Environment.NewLine +
                              Util.GetSizeDistributionString(trees, 200, 5) + Environment.NewLine +
                              Util.GetFunctionDistributionString(trees) + Environment.NewLine +
                              Util.GetNumberOfSubtreesDistributionString(trees) + Environment.NewLine +
                              Util.GetTerminalDistributionString(trees) + Environment.NewLine
                              );

            Assert.IsTrue(failedEvents * 100.0 / (POPULATION_SIZE * N_ITERATIONS / 2.0) < 75.0); // 25% of architecture operations must succeed
            //mkommend: commented due to performance issues on the builder
            // Assert.IsTrue(Math.Round(1000.0 / (msPerOperation)) > 800); // must achieve more than 800 ops per second
        }