static void Main(string[] args) { int mu = 10; int lambda = 70; int generations = 10; GenericComparer <Individual> comparer = new GenericComparer <Individual>(CompareFunctions.CompareRating); //create parent generation List <Individual> parents = new List <Individual>(); List <Individual> childs = null; for (int i = 0; i < mu / 2; i++) { parents.Add(new Individual(new[] { 2.0, 200.0 }, new[] { 2.0, 2.0 })); parents.Add(new Individual(new[] { 1.0, 2000.0 }, new[] { 2.0, 2.0 })); } //start evolving! for (int i = 0; i < generations; i++) { childs = EvolutionSteps.Recombine(ref parents, lambda, BasicEvolutionStrategyFunctions.IntermediateRecombination, BasicEvolutionStrategyFunctions.DiscreteRecombination); EvolutionSteps.Mutate(ref childs, 0.1f, 0.2f, BasicEvolutionStrategyFunctions.Mutate); EvolutionSteps.Evaluate(ref childs, BasicEvolutionStrategyFunctions.SimpleZeroRating); EvolutionSteps.Selection(ref childs, mu, comparer); parents = childs; } //show me foreach (Individual ind in childs) { Console.WriteLine(ind); } }
public MathModel SynthesizeModel(Point[] trainingPoints) { var means = trainingPoints.Means(); var standardDeviations = trainingPoints.StandardDeviations(means); if (Parameters.UseDataNormalization) { trainingPoints = _pointsNormalizer.ApplyProcessing(trainingPoints); NormalizedTrainingPoints = trainingPoints.DeepCopyByExpressionTree(); } var evolutionEnginesFactory = new EnginesFactory(); var evolutionEngine = evolutionEnginesFactory.Create(Parameters.EvolutionParameters); var positiveTrainingPoints = trainingPoints.Where(tp => tp.ClassificationType == ClassificationType.Positive).ToArray(); var negativeTrainingPoints = trainingPoints.Where(tp => tp.ClassificationType == ClassificationType.Negative).ToArray(); var evaluator = new Evaluator(positiveTrainingPoints, negativeTrainingPoints, _constraintsBuilder); //HACK TODO //var numberOfConstraintsCoefficients = Parameters.MaximumNumberOfConstraints * (Parameters.NumberOfDimensions + 1); //var constraintsCoefficients = new List<double>(numberOfConstraintsCoefficients); //var benchmarkConstraintsIndexer = 0; //for (var i = 0; i < Parameters.MaximumNumberOfConstraints; i++) //{ // if (benchmarkConstraintsIndexer >= Benchmark.Constraints.Length) // benchmarkConstraintsIndexer = 0; // constraintsCoefficients.AddRange(Benchmark.Constraints[benchmarkConstraintsIndexer].Terms.Select(t => t.Coefficient)); // constraintsCoefficients.Add(Benchmark.Constraints[benchmarkConstraintsIndexer++].LimitingValue); //} //PopulationGeneratorBase.ObjectCoefficients = constraintsCoefficients.ToArray(); // Solution bestSolution; if (Parameters.UseSeeding) { var singleConstraintModel = Parameters.TypeOfBenchmark == BenchmarkType.Balln && Parameters.AllowQuadraticTerms ? Benchmark.Constraints.Take(1).DeepCopyByExpressionTree().ToArray() : new[] { new LinearConstraint(Benchmark.Constraints.First().Terms.Where(t => t.Type == TermType.Linear).ToArray(), 0) }; var singleConstraintBuilder = new ConstraintsBuilder(singleConstraintModel); var singleConstraintEvaluator = new Evaluator(positiveTrainingPoints, negativeTrainingPoints, singleConstraintBuilder); var seedingProcessor = new SeedingProcessor(singleConstraintEvaluator, _constraintsBuilder, positiveTrainingPoints); bestSolution = evolutionEngine.RunEvolution(evaluator, seedingProcessor); } else { bestSolution = evolutionEngine.RunEvolution(evaluator); } CoreEvolutionSteps = evolutionEngine.EvolutionSteps; Statistics.EvolutionStatistics = evolutionEngine.Statistics; var synthesizedConstraints = _constraintsBuilder.BuildConstraints(bestSolution); if (Parameters.UseDataNormalization) { NormalizedSynthesizedConstraints = synthesizedConstraints.DeepCopyByExpressionTree(); _constaintsDenormalizer = new StandardScoreConstraintsDenormalizer(means, standardDeviations); synthesizedConstraints = _constaintsDenormalizer.ApplyProcessing(synthesizedConstraints); } if (Parameters.TrackEvolutionSteps) { var evolutionStepsAsSolutions = evolutionEngine.EvolutionStepsSimple.ToList(); foreach (var evolutionStepsAsSolution in evolutionStepsAsSolutions) { var evolutionStep = _constraintsBuilder.BuildConstraints(evolutionStepsAsSolution); if (Parameters.UseDataNormalization) { NormalizedEvolutionSteps.Add(evolutionStep.DeepCopyByExpressionTree()); evolutionStep = _constaintsDenormalizer.ApplyProcessing(evolutionStep); } EvolutionSteps.Add(evolutionStep); } } if (Parameters.UseRedundantConstraintsRemoving) { _stoper.Restart(); synthesizedConstraints = _redundantConstraintsRemover.ApplyProcessing(synthesizedConstraints); _stoper.Stop(); Statistics.RedundantConstraintsRemovingTime = _stoper.Elapsed; } MathModel = new MathModel(synthesizedConstraints, Benchmark); Statistics.NumberOfConstraints = synthesizedConstraints.Length; Statistics.MeanAngle = Parameters.TypeOfBenchmark != BenchmarkType.Balln ? _meanAngleCalculator.Calculate(synthesizedConstraints, Benchmark.Constraints) : double.NaN; return(MathModel); }