public List <ProblemPerformanceSingleObjective> RunAssessment(
int numberOfRestarts,
int reportingFrequency,
Action <Population> reporters,
Action <int> iterationReporter,
int timeOutEvaluations = 0,
TimeSpan?timeOutDuration = null,
int numberOfNewIndividualsPerGeneration = 1)
{
var results = new List <ProblemPerformanceSingleObjective>();
for (var i = 1; i <= numberOfRestarts; i++)
{
var optimiserRunner = new OptimiserRunnerBasic(builder, evaluator, convergenceCheckers, reporters);
optimiserRunner.Run(
reportingFrequency: reportingFrequency,
timeOutEvaluations: timeOutEvaluations,
timeOutDuration: timeOutDuration,
newIndividualsPerGeneration: numberOfNewIndividualsPerGeneration);
results.Add(
new ProblemPerformanceSingleObjective(
builder.CreateOptimiser().ToString(),
evaluator,
optimiserRunner));
iterationReporter(i);
}
return(results);
}
public OptimiserRunnerBasicTests()
{
builder = new ObjectCreators.OptimiserBuilderMock();
runner = new OptimiserRunnerBasic(
builder,
new ObjectCreators.EvaluatorMock(),
p => p.AbsoluteDecisionVectorConvergence(1),
p => { });
}
public void Run_EvaluatorThrowsError_ErrorWrappedAndThrown()
{
var errorRunner = new OptimiserRunnerBasic(
builder,
new ObjectCreators.EvaluatorWithErrorMock(),
p => p.AbsoluteDecisionVectorConvergence(1),
p => { });
Assert.Throws <InvalidOperationException>(() => errorRunner.Run());
}
public void Run_IndividualIsIllegal_AssignsPenaltyValue()
{
var illegalRunner = new OptimiserRunnerBasic(
builder,
new ObjectCreators.EvaluatorWithErrorMock(false),
p => p.AbsoluteDecisionVectorConvergence(1),
p => { });
illegalRunner.Run();
Assert.True(illegalRunner.AllEvaluated.All(i => i.Fitness == ObjectCreators.OptimiserBuilderMock.PenaltyValue));
}
static void Main(string[] args)
{
OptimiserBuilder builder;
if (RunSingleObjective)
{
var problem = Options.GetSingleObjectiveContinuousProblem(SingleObjectiveProblemToUse,
Number_Of_Dimensions);
switch (OptimiserToUse)
{
case Options.OptimisersAvailable.NelderMead:
builder = NelderMeadBuilder.GetBuilder(
problem.GetGlobalOptimum().GetDecisionSpace(),
Nelder_Mead_Simplex_Creation_Step_Size);
break;
case Options.OptimisersAvailable.EvolutionaryAlgorithm:
builder = EvolutionaryAlgorithmBuilderContinuousSO.GetBuilder(
problem.GetGlobalOptimum().GetDecisionSpace(),
AvailableOperators.ParentSelector.Tournament,
AvailableOperators.RecombinationOperator.Sbx,
AvailableOperators.MutationOperators.AddRandomNumber,
AvailableOperators.ReinsertionOperators.ReplaceRandom,
150);
break;
default:
throw new ArgumentOutOfRangeException();
}
var runner = new ProblemPerformanceAssessor <double>(builder, problem,
p => p.AbsoluteDecisionVectorConvergence(Convergence_Tolerance));
var results = runner.RunAssessment(
Number_Of_Restarts,
1000,
r => Console.Write("."),
i =>
{
Console.WriteLine();
Console.WriteLine($"Optimisation {i}/{Number_Of_Restarts} complete.");
Console.WriteLine();
},
timeOutEvaluations: Math.Max(5000, (int)Math.Pow(Number_Of_Dimensions, 3.0) * 20),
numberOfNewIndividualsPerGeneration: OptimiserToUse == Options.OptimisersAvailable.NelderMead ? 1 : Number_Of_New_Individuals_Per_Generation);
printSingleObjectiveResults(results);
}
else
{
var problem = Options.GetMultipleObjectiveContinuousProblem(MultipleObjectiveProblemToUse);
builder = EvolutionaryAlgorithmBuilderContinuousMO.GetBuilder(
problem.GetOptimalParetoFront(1).First().GetDecisionSpace());
var optimiserRunner = new OptimiserRunnerBasic(builder, problem,
pop => false, r => Console.Write("."));
optimiserRunner.Run(
reportingFrequency: 1000,
timeOutEvaluations: 10000,
timeOutDuration: null,
newIndividualsPerGeneration: Number_Of_New_Individuals_Per_Generation);
new FastNonDominatedSort().PerformSort(optimiserRunner.FinalPopulation, new[] { true, true });
var finalFrontier = optimiserRunner.FinalPopulation.ParetoFront(1);
var comparison = problem.GetOptimalParetoFront(finalFrontier.Length);
}
}
