示例#1
0
        public void CanCrossover()
        {
            var listLeft = new List <IGenoTypeNode>
            {
                new SquareRoot(),
                new Multiplication(),
                new Plus(),
                new Minus(),
                new FeatureTerminal("a"),
                new FeatureTerminal("b"),
                new FeatureTerminal("c"),
                new FeatureTerminal("d")
            };

            var listRight = new List <IGenoTypeNode>
            {
                new Sinus(),
                new Multiplication(),
                new Division(),
                new Minus(),
                new FeatureTerminal("a1"),
                new FeatureTerminal("b1"),
                new FeatureTerminal("c1"),
                new FeatureTerminal("d1")
            };

            var possibleFunctions = new List <IGenoTypeNode>
            {
                new SquareRoot(),
                new Multiplication(),
                new Plus(),
                new Minus()
            };

            var possibleTerminals = new List <IGenoTypeNode>
            {
                new FeatureTerminal("a"),
                new FeatureTerminal("b"),
                new FeatureTerminal("c"),
                new FeatureTerminal("d")
            };

            var eaGeneExpressionParameters =
                new EaGeneExpressionParameters(4, possibleFunctions, possibleTerminals)
            {
                CrossoverProbability = 1.0
            };

            IGenoType left = new GeneExpression.GenoType {
                GenoTypeNodes = listLeft
            };
            IGenoType right = new GeneExpression.GenoType {
                GenoTypeNodes = listRight
            };
            var randomGenerator        = new UniformRandomGenerator();
            var genotypeCrossoverator1 = new GenoTypeCrossoveratorBasic1(randomGenerator, eaGeneExpressionParameters);

            var phenoTypeTreeLeft1  = new GeneExpression.PhenoTypeTree(left.GenoTypeNodes);
            var phenoTypeTreeRight1 = new GeneExpression.PhenoTypeTree(right.GenoTypeNodes);

            genotypeCrossoverator1.PerformCrossover(ref left, ref right);

            var phenoTypeTreeLeft2  = new GeneExpression.PhenoTypeTree(left.GenoTypeNodes);
            var phenoTypeTreeRight2 = new GeneExpression.PhenoTypeTree(right.GenoTypeNodes);

            Assert.NotEqual(phenoTypeTreeLeft1, phenoTypeTreeLeft2);
            Assert.NotEqual(phenoTypeTreeRight1, phenoTypeTreeRight2);
        }
示例#2
0
        static void Main()
        {
            var randomGenerator            = new UniformRandomGenerator();
            var dataSet                    = GetDataSet();
            var target                     = GetTarget();
            var eaGeneExpressionParameters = GetEaGeneExpressionParameters(dataSet);
            var parameterTerminalFactory   = new ParameterTerminalFactory(eaGeneExpressionParameters, randomGenerator);
            var genoTypeFactory            = new GenoTypeFactory(eaGeneExpressionParameters, randomGenerator, parameterTerminalFactory);
            var mutator                    = new GenoTypeMutatorBasic1(randomGenerator, eaGeneExpressionParameters, genoTypeFactory);
            var crossOverator              = new GenoTypeCrossoveratorBasic1(randomGenerator, eaGeneExpressionParameters);

            var populationP            = GetFirstPopulation(eaGeneExpressionParameters, parameterTerminalFactory, genoTypeFactory);
            var listOfObjectiveValuesP = new List <IObjectiveValues>();

            for (var c = 0; c < populationP.Count; c++)
            {
                var objectiveValues = GetObjectiveValues(target, dataSet, populationP[c]);
                listOfObjectiveValuesP.Add(objectiveValues);
            }
            listOfObjectiveValuesP = Nsga2TournamentSelector.PerformSelection(eaGeneExpressionParameters.TournamentSize, listOfObjectiveValuesP, randomGenerator);

            var tempPopulation = new List <Individual>();

            foreach (var objectiveValues in listOfObjectiveValuesP)
            {
                var indy = populationP.FirstOrDefault(x => x.Guid == objectiveValues.IndividualGuid);
                tempPopulation.Add((Individual)indy.Clone());
            }
            populationP = tempPopulation;

            for (var generation = 0; generation < eaGeneExpressionParameters.NumberOfGeneration; generation++)
            {
                var populationQ = new List <Individual>();
                foreach (var individual in populationP)
                {
                    populationQ.Add((Individual)individual.Clone());
                }

                populationQ = PerformCrossOver(populationQ, randomGenerator, crossOverator);

                foreach (var individual in populationQ)
                {
                    mutator.PerformMutation(ref individual.GenoType);
                }

                var combinedPopulation            = new List <Individual>();
                var combinedlistOfObjectiveValues = new List <IObjectiveValues>();
                foreach (var individual in populationP)
                {
                    var clone = (Individual)individual.Clone();
                    combinedPopulation.Add(clone);
                    var objectiveValues = GetObjectiveValues(target, dataSet, clone);
                    combinedlistOfObjectiveValues.Add(objectiveValues);
                }
                foreach (var individual in populationQ)
                {
                    var clone = (Individual)individual.Clone();
                    combinedPopulation.Add(clone);
                    var objectiveValues = GetObjectiveValues(target, dataSet, clone);
                    combinedlistOfObjectiveValues.Add(objectiveValues);
                }

                combinedlistOfObjectiveValues = Nsga2Ranker.Rank(combinedlistOfObjectiveValues);
                combinedlistOfObjectiveValues = Nsga2Crowder.CalculateCrowdingDistances(combinedlistOfObjectiveValues);

                combinedlistOfObjectiveValues = combinedlistOfObjectiveValues.OrderBy(i => i.Rank).ThenByDescending(i => i.CrowdingDistance).ToList();

                tempPopulation = new List <Individual>();
                var     counter          = 0;
                var     smallestMse      = decimal.MaxValue;
                decimal largestMse       = 0;
                var     smallestPosition = -1;
                foreach (var objectiveValues in combinedlistOfObjectiveValues)
                {
                    var indy = combinedPopulation.FirstOrDefault(x => x.Guid == objectiveValues.IndividualGuid);
                    tempPopulation.Add((Individual)indy.Clone());

                    var ovs = GetObjectiveValues(target, dataSet, combinedPopulation.FirstOrDefault(x => x.Guid == objectiveValues.IndividualGuid));
                    if (ovs.Values[0] < smallestMse)
                    {
                        smallestMse      = ovs.Values[0];
                        smallestPosition = counter;
                    }

                    if (ovs.Values[0] > largestMse)
                    {
                        largestMse = ovs.Values[0];
                    }

                    counter++;
                    if (counter == eaGeneExpressionParameters.PopulationSize)
                    {
                        break;
                    }
                }
                populationP = tempPopulation;

                Console.WriteLine(generation + " " + smallestMse + " " + largestMse);
                Console.WriteLine(new PhenoTypeTree(populationP[smallestPosition].GenoType.GenoTypeNodes));
            }
        }