public Solution[] Seed(Solution[] solutions)
{
//Console.WriteLine($"Solution obj coeffs len input = {solutions[0].ObjectCoefficients.Length}");
var numberOfPoints = _positivePoints.Length;
foreach (var solution in solutions)
{
//Console.ReadKey();
//Console.WriteLine("Solution");
//Console.WriteLine(new StringBuilder().AppendArray(solution.ObjectCoefficients).ToString());
var newObjectCoefficients = new List <double>(solution.ObjectCoefficients.Length);
var constraints = _constraintsBuilder.BuildConstraints(solution);
foreach (var constraint in constraints)
{
//Console.WriteLine("Constraint");
var bestFitnessScore = 0.0;
var bestLimitingValue = 0.0;
for (var i = 0; i < numberOfPoints; i++)
{
var leftSideValue = constraint.GetLeftSideValue(_positivePoints[i]);
constraint.LimitingValue = leftSideValue;
var singleConstraintAsSolution = new Solution(constraint.Terms.Length + 1)
{
ObjectCoefficients = constraint.GetAllCoefficients()
};
var newFitnessScore = _evaluator.Evaluate(singleConstraintAsSolution);
if (newFitnessScore > bestFitnessScore)
{
bestFitnessScore = newFitnessScore;
bestLimitingValue = leftSideValue;
}
}
constraint.LimitingValue = bestLimitingValue;
newObjectCoefficients.AddRange(constraint.GetAllCoefficients());
}
solution.ObjectCoefficients = newObjectCoefficients.ToArray();
//Console.WriteLine(new StringBuilder().AppendArray(solution.ObjectCoefficients).ToString());
}
//Console.WriteLine($"Solution obj coeffs len output = {solutions[0].ObjectCoefficients.Length}");
//Console.WriteLine("#####################");
//Console.WriteLine("Seeding finished!");
return(solutions);
}
public override double Evaluate(Solution solution)
{
var numberOfPositivePointsSatisfyingConstraints = 0;
var numberOfNegativePointsSatisfyingConstraints = 0;
var numberOfPositivePoints = _positivePoints.Length;
var numberOfNegativePoints = _negativePoints.Length;
var constraints = _constraintsBuilder.BuildConstraints(solution);
//TODO
//var mean = constraints.Sum(c => c.GetTermsCoefficients().Min(tc => Math.Abs(tc)));
//var modifier = mean > 1 ? 1.0 / mean : 1;
for (var i = 0; i < numberOfPositivePoints; i++)
{
if (constraints.IsSatisfyingConstraints(_positivePoints[i]))
{
numberOfPositivePointsSatisfyingConstraints++;
}
}
for (var i = 0; i < numberOfNegativePoints; i++)
{
if (constraints.IsSatisfyingConstraints(_negativePoints[i]))
{
numberOfNegativePointsSatisfyingConstraints++;
}
}
//Console.Write($"Positive satisfying = {numberOfPositivePointsSatisfyingConstraints} ### ");
//Console.Write($"Negative satisfying = {numberOfNegativePointsSatisfyingConstraints}\n");
//Thread.Sleep(100);
//TODO
return((double)numberOfPositivePointsSatisfyingConstraints / (_positivePoints.Length + numberOfNegativePointsSatisfyingConstraints));
//return ((double)numberOfPositivePointsSatisfyingConstraints / (_positivePoints.Length + numberOfNegativePointsSatisfyingConstraints)) * modifier;
}
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);
}