Пример #1
0
        private CodeTree <S, G, R> Combine(GenePool <S, G, R> genePool, CodeTree <S, G, R> source,
                                           CodeTree <S, G, R> remove, CodeTree <S, G, R> replace)
        {
            var copy = source;

            if (source == remove)
            {
                return(replace.Clone());
            }

            if (copy.Node.Kind != NodeKind.Terminal)
            {
                for (int i = 0; i <= copy.Children.GetUpperBound(0); i++)
                {
                    var child = Combine(genePool, copy.Children[i], remove, replace);

                    copy.Children[i] = child;

                    if (genePool.GetCanMutate())
                    {
                        copy.Children[i].Node = genePool.GetTerminal();
                    }
                }
            }

            return(copy);
        }
Пример #2
0
        public CodeTree(GenePool <S, G, R> genePool, Node node, int maxDepth)
        {
            Node = node;

            if (Node.Kind != NodeKind.Terminal)
            {
                Children = Enumerable.Range(1, Node.ChildCount).Select(
                    x => new CodeTree <S, G, R>(genePool, GetNode(genePool, maxDepth), maxDepth - 1)).ToArray();
            }
        }
Пример #3
0
 private Node GetNode(GenePool <S, G, R> genePool, int maxDepth)
 {
     if (maxDepth > 0)
     {
         return(genePool.GetFunctionOrTerminal());
     }
     else
     {
         return(genePool.GetTerminal());
     }
 }
Пример #4
0
        private void Crossover(GenePool <S, G, R> genePool,
                               CodeTree <S, G, R> parent1, CodeTree <S, G, R> parent2,
                               out CodeTree <S, G, R> child1, out CodeTree <S, G, R> child2)
        {
            var nodes1 = parent1.ToList();
            var nodes2 = parent2.ToList();

            int crossover1 = genePool.Next(0, nodes1.Count - 1);
            int crossover2 = genePool.Next(0, nodes2.Count - 1);

            child1 = Combine(genePool, parent1, nodes1[crossover1], nodes2[crossover2]);
            child2 = Combine(genePool, parent2, nodes2[crossover2], nodes1[crossover1]);
        }
Пример #5
0
        public static void Evolve(S settings, CancellationTokenSource cts,
                                  Action <EntitySet <S, G, R> > onResultSet,
                                  Action <AggregateException> onErrors, Action onSuccess)
        {
            try
            {
                Contract.Requires(settings != null, nameof(settings));

                settings.Validate();

                var genePool = new GenePool <S, G, R>(settings);

                EntitySet <S, G, R> entitySet = null;

                for (var cohortId = 0; cohortId < settings.MaxCohorts; cohortId++)
                {
                    entitySet = new EntitySet <S, G, R>(
                        settings, genePool, cohortId, entitySet);

                    var metGoals = entitySet.CompileAndRun(settings, cts);

                    onResultSet(entitySet);

                    if (metGoals)
                    {
                        break;
                    }
                }

                onSuccess();
            }
            catch (AggregateException errors)
            {
                onErrors(errors);
            }
            catch (Exception error)
            {
                onErrors(new AggregateException(error));
            }
        }
Пример #6
0
        internal EntitySet(S settings, GenePool <S, G, R> genePool, int cohortId,
                           IEnumerable <Entity <S, G, R> > entities)
        {
            Cohort = new Cohort(cohortId);

            if (entities == null)
            {
                for (int entityId = 0; entityId <= settings.Population - 1; entityId++)
                {
                    var codeTree = new CodeTree <S, G, R>(
                        genePool, genePool.GetFunction(), settings.MaxTreeDepth);

                    var knownAs = new KnownAs(Cohort, entityId);

                    Items.Add(new Entity <S, G, R>(knownAs, codeTree));
                }
            }
            else
            {
                Items.AddRange(entities.Take(settings.NumToKeep));

                for (int entityId = Count; entityId <= settings.Population - 2; entityId += 2)
                {
                    CodeTree <S, G, R> child1, child2, parent1, parent2;
                    int index1, index2;

                    SelectAndCloneParents(genePool, this, settings.NumToKeep,
                                          out index1, out parent1, out index2, out parent2);

                    Crossover(genePool, parent1, parent2, out child1, out child2);

                    Items.Add(new Entity <S, G, R>(new KnownAs(Cohort, entityId),
                                                   this[index1].KnownAs, this[index2].KnownAs, child1));

                    Items.Add(new Entity <S, G, R>(new KnownAs(Cohort, entityId + 1),
                                                   this[index1].KnownAs, this[index2].KnownAs, child2));
                }
            }
        }
Пример #7
0
        private void SelectAndCloneParents(GenePool <S, G, R> genePool,
                                           EntitySet <S, G, R> entitySet, int limit,
                                           out int index1, out CodeTree <S, G, R> parent1,
                                           out int index2, out CodeTree <S, G, R> parent2)
        {
            var totalFitness = 0.0;

            for (int i = 0; i < limit; i++)
            {
                totalFitness += entitySet[i].Report.Fitness;
            }

            index1 = -1;
            index2 = -1;

            while ((index1 == -1) | (index2 == -1))
            {
                for (int i = 0; i < limit; i++)
                {
                    var range = entitySet[i].Report.Fitness / totalFitness;

                    if (genePool.InRange(range))
                    {
                        if (index1 == -1)
                        {
                            index1 = i;
                        }
                        else
                        {
                            index2 = i;
                        }
                    }
                }
            }

            parent1 = entitySet[index1].CodeTree.DeepClone();
            parent2 = entitySet[index2].CodeTree.DeepClone();
        }