private ICandidateFactory <MpiSysConfig> CreatePopulationInitialiser(
IClonableObjectiveEvaluator <MpiSysConfig> objectiveEvaluator,
MpiSysConfig templateParameterSet,
MpiSysConfig[] seedsPopulation,
string initialisationOption = "")
{
Log.Debug("Root: creating population initialiser");
var options = initialisationOption.Split(':');
var seeds = new List <MpiSysConfig> {
templateParameterSet
};
if (seedsPopulation != null)
{
seeds.AddRange(seedsPopulation);
}
var rng = new BasicRngFactory(SceParameterDefinition.RandomizationSeed);
ICandidateFactory <MpiSysConfig> result = CreatePopulationInitialiser(
templateParameterSet,
rng,
objectiveEvaluator,
options);
if (result is BestOfSampling <MpiSysConfig> )
{
return(result);
}
else
{
return(new SeededSamplingFactory <MpiSysConfig>(result, seeds));
}
}
private ShuffledComplexEvolution <MpiSysConfig> CreateShuffledComplexEvolution(
IClonableObjectiveEvaluator <MpiSysConfig> objectiveEvaluator,
IDictionary <string, string> dict,
ICandidateFactory <MpiSysConfig> populationInitializer,
ILoggerMh logger)
{
Log.Debug("Root: creating SCE optimiser");
ShuffledComplexEvolution <MpiSysConfig> optimEngine = new ShuffledComplexEvolution <MpiSysConfig>(
objectiveEvaluator,
populationInitializer,
CreateTerminationCriterion(),
SceParameterDefinition.Parameters.P,
SceParameterDefinition.Parameters.M,
SceParameterDefinition.Parameters.Q,
SceParameterDefinition.Parameters.Alpha,
SceParameterDefinition.Parameters.Beta,
SceParameterDefinition.Parameters.NumShuffle,
new BasicRngFactory(SceParameterDefinition.RandomizationSeed + 1000),
new DefaultFitnessAssignment(),
dict,
trapezoidalPdfParam: SceParameterDefinition.Parameters.TrapezoidalDensityParameter,
options: sceOptions,
pmin: SceParameterDefinition.Parameters.Pmin)
{
Logger = logger
};
return(optimEngine);
}
private static ShuffledComplexEvolution <T> internalCreateSceOptimizer <T>(IClonableObjectiveEvaluator <T> evaluator, T template, ITerminationCondition <T> terminationCondition, SceParameters SceParams)
where T : ICloneableSystemConfiguration, IHyperCube <double>
{
var populationInitializer = new UniformRandomSamplingFactory <T>(new CSIRO.Metaheuristics.RandomNumberGenerators.BasicRngFactory(0), template);
var sce = new ShuffledComplexEvolution <T>(evaluator, populationInitializer,
terminationCondition: terminationCondition, sceParameters: SceParams);
return(sce);
}
public UniformRandomSampling(IClonableObjectiveEvaluator <T> evaluator,
ICandidateFactory <T> populationInializer,
int numShuffle, IDictionary <string, string> tags = null)
{
this.evaluator = evaluator;
this.populationInitializer = populationInializer;
this.numShuffle = numShuffle;
this.logTags = tags;
}
public UniformRandomSampling(IClonableObjectiveEvaluator <T> evaluator,
IRandomNumberGeneratorFactory rng,
T template,
int numShuffle, IDictionary <string, string> tags = null)
{
this.evaluator = evaluator;
this.populationInitializer = new UniformRandomSamplingFactory <T>(rng, template);
this.numShuffle = numShuffle;
this.logTags = tags;
}
/// <summary>
/// Executes the shuffled complex evolution for nesting within the rosenbrock optimiser.
/// </summary>
/// <param name="objectiveEvaluator"> The compound obj calculator. </param>
/// <param name="dict"> The dict. </param>
/// <param name="populationInitializer"> The population initializer. </param>
/// <param name="logger"> The logger. </param>
/// <returns> </returns>
private MpiSysConfig ExecuteShuffledComplexForRosen(
IClonableObjectiveEvaluator <MpiSysConfig> objectiveEvaluator,
IDictionary <string, string> dict,
ICandidateFactory <MpiSysConfig> populationInitializer,
ILoggerMh logger)
{
Log.Debug("Root: Executing SCE optimiser");
var optimEngine = CreateShuffledComplexEvolution(objectiveEvaluator, dict, populationInitializer, logger);
return(BestParameterSet(optimEngine.Evolve(), new DefaultFitnessAssignment()));
}
private IEvolutionEngine <MpiSysConfig> CreateSceRosenEngine(
IClonableObjectiveEvaluator <MpiSysConfig> objectiveEvaluator,
IDictionary <string, string> dict,
ICandidateFactory <MpiSysConfig> populationInitializer,
ILoggerMh logger)
{
Log.Debug("Root: Creating Rosenbrock + SCE optimiser");
Func <IOptimizationResults <MpiSysConfig> > rosenFunc = () => ExecuteRosenbrock(objectiveEvaluator, dict, populationInitializer, logger);
return(new ChainOptimizations <MpiSysConfig>("Sce+Rosen", rosenFunc));
}
public static IObjectiveEvaluator <T> TryClone <T>(IObjectiveEvaluator <T> evaluator) where T : ISystemConfiguration
{
if (evaluator == null)
{
throw new ArgumentNullException( );
}
IClonableObjectiveEvaluator <T> clonable = evaluator as IClonableObjectiveEvaluator <T>;
if (clonable == null)
{
throw new NotSupportedException(evaluator.GetType( ).Name + " does not implement IClonableObjectiveEvaluator");
}
return(clonable.Clone( ));
}
private static ICandidateFactory <MpiSysConfig> CreatePopulationInitialiser(
MpiSysConfig templateParameterSet,
BasicRngFactory rng,
IClonableObjectiveEvaluator <MpiSysConfig> objectiveEvaluator,
params string[] options)
{
switch (options[0].ToLower())
{
case "bestof":
int poolSize = int.Parse(options[1]);
int bestPoints = int.Parse(options[2]);
string[] subOptions = Subset(3, options);
if (poolSize < bestPoints)
{
Log.WarnFormat(
"Root: Best of Sampling pool size ({0}) is smaller than best points ({1}). Setting best points to match pool size.",
poolSize,
bestPoints);
bestPoints = poolSize;
}
Log.DebugFormat("Root: creating BestOfSampling. Pool size: {0}, best points: {1}", poolSize, bestPoints);
return
(new BestOfSampling <MpiSysConfig>(
CreatePopulationInitialiser(templateParameterSet, rng, objectiveEvaluator, subOptions),
poolSize,
bestPoints,
objectiveEvaluator,
new DefaultFitnessAssignment()));
case "lhc":
Log.Debug("Root: creating Latin Hypercube Sampling");
return(new LatinHypercubeSampling <MpiSysConfig>(rng, templateParameterSet));
case "weibull":
Log.Debug("Root: creating weibull distribution");
return(new SeededSamplingFactory <MpiSysConfig>(
new WeibullGen <MpiSysConfig>(rng, templateParameterSet),
new List <MpiSysConfig> {
templateParameterSet
}));
case "":
case "urs":
default:
Log.Debug("Root: creating URS");
return(new UniformRandomSamplingFactory <MpiSysConfig>(rng, templateParameterSet));
}
}
private IEvolutionEngine <MpiSysConfig> CreateEngine(
IClonableObjectiveEvaluator <MpiSysConfig> objectiveEvaluator,
MpiSysConfig templateParameterSet,
MpiSysConfig[] seedsPopulation,
ILoggerMh logger,
string calibName,
string initialisationOption)
{
Log.Debug("Root: creating optimisation engine");
var dict = string.IsNullOrEmpty(calibName) ? CreateTimeStampCalibName() : CreateTag(calibName);
var populationInitializer = CreatePopulationInitialiser(objectiveEvaluator, templateParameterSet, seedsPopulation, initialisationOption);
return(CreateEngine(objectiveEvaluator, dict, populationInitializer, logger));
}
private IEvolutionEngine <MpiSysConfig> CreateEngine(
IClonableObjectiveEvaluator <MpiSysConfig> objectiveEvaluator,
IDictionary <string, string> dict,
ICandidateFactory <MpiSysConfig> populationInitializer,
ILoggerMh logger)
{
switch (OptimisationMethod)
{
default:
case OptimisationMethods.Sce:
return(CreateShuffledComplexEvolution(objectiveEvaluator, dict, populationInitializer, logger));
case OptimisationMethods.RosenSce:
return(CreateSceRosenEngine(objectiveEvaluator, dict, populationInitializer, logger));
}
}
static IObjectiveScores[] EvaluateScoresSerial <T>(T[] population, Func <bool> isCancelled,
IClonableObjectiveEvaluator <T> evaluator) where T : ISystemConfiguration
{
IObjectiveScores[] result = new IObjectiveScores[population.Length];
for (int j = 0; j < population.Length; j++)
{
if (!isCancelled())
{
result [j] = evaluator.EvaluateScore(population [j]);
}
else
{
result [j] = null;
}
}
return(result);
}
private IOptimizationResults <MpiSysConfig> ExecuteRosenbrock(
IClonableObjectiveEvaluator <MpiSysConfig> objectiveEvaluator,
IDictionary <string, string> dict,
ICandidateFactory <MpiSysConfig> populationInitializer,
ILoggerMh logger)
{
Log.Debug("Root: Executing Rosenbrock optimiser");
var engine = new RosenbrockOptimizer <MpiSysConfig, double>(
objectiveEvaluator,
ExecuteShuffledComplexForRosen(objectiveEvaluator, dict, populationInitializer, logger),
new RosenbrockOptimizer <MpiSysConfig, double> .RosenbrockOptimizerIterationTermination(RosenbrockIterations),
logTags: dict)
{
Logger = logger, AlgebraProvider = new TimeAlgebraProvider()
};
return(engine.Evolve());
}
public static IObjectiveScores[] EvaluateScores <T>(IClonableObjectiveEvaluator <T> evaluator, T[] population, Func <bool> isCancelled, ParallelOptions parallelOptions = null) where T : ISystemConfiguration
{
if (population.Length == 0)
{
return(new IObjectiveScores[0]);
}
if (parallelOptions == null)
{
parallelOptions = new ParallelOptions()
{
MaxDegreeOfParallelism = -1
}
}
;
var procCount = System.Environment.ProcessorCount;
IObjectiveScores[] result;
if (evaluator.SupportsThreadSafeCloning)
{
// There is presumably no point cloning
// the system more times than the max level of parallelism
int nParallel = procCount;
if (parallelOptions.MaxDegreeOfParallelism > 0)
{
nParallel = Math.Min(nParallel, parallelOptions.MaxDegreeOfParallelism);
}
T[][] subPop = MetaheuristicsHelper.MakeBins(population, nParallel);
var taskPkgs = new List <Tuple <T[], IClonableObjectiveEvaluator <T> > >();
taskPkgs.Add(Tuple.Create(subPop[0], evaluator));
for (int i = 1; i < subPop.Length; i++)
{
taskPkgs.Add(Tuple.Create(subPop[i], evaluator.Clone()));
}
// Need to use Parallel.ForEach rather than Parallel.For to work around a Parallel.For
// oddity in Mono 3.12.1. Need an identity to iterate over...
var ramp = new int[subPop.Length];
// Map of index of subpopulations to indices in the variable result:
//var offsets = new int[subPop.Length];
var resultBins = new IObjectiveScores[ramp.Length][];
for (int i = 1; i < ramp.Length; i++)
{
ramp[i] = i;
}
Parallel.ForEach(ramp, parallelOptions,
(i => {
resultBins[i] = EvaluateScoresSerial(taskPkgs[i], isCancelled);
})
);
result = Gather(resultBins);
}
else
{
result = new IObjectiveScores[population.Length];
for (int i = 0; i < population.Length; i++)
{
if (!isCancelled())
{
result [i] = evaluator.EvaluateScore(population [i]);
}
else
{
result [i] = null;
}
}
}
return(result);
}
private static ShuffledComplexEvolution <ICloneableSystemConfiguration> createSce(IClonableObjectiveEvaluator <ICloneableSystemConfiguration> evaluator)
{
var rng = new BasicRngFactory(0);
var engine = new ShuffledComplexEvolution <ICloneableSystemConfiguration>(
evaluator,
new UniformRandomSamplingFactory <IHyperCube <double> >(rng.CreateFactory(), new UnivariateReal(0)),
new ShuffledComplexEvolution <ICloneableSystemConfiguration> .MaxShuffleTerminationCondition(),
5, 20, 10, 3, 20, 7,
rng,
new ZitlerThieleFitnessAssignment());
return(engine);
}
public CombinedSCEwithRosenbrock(ShuffledComplexEvolution <T> shuffledComplexEvolution, IClonableObjectiveEvaluator <T> evaluator,
ITerminationCondition <T> rosenTerminationCondition, object AlgabraProvider)
{
this.evaluator = evaluator;
this.shuffledCE = shuffledComplexEvolution;
this.rosenTerminationCondition = rosenTerminationCondition;
this.rosenAlgabraProvider = AlgabraProvider;
}
