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