/// <summary>
/// Initializes a new instance of the <see cref="GenerationEvaluationActor{TTargetAlgorithm, TInstance, TResult}"/> class.
/// </summary>
/// <param name="targetAlgorithmFactory">The <see cref="ITargetAlgorithmFactory{TTargetAlgorithm,TInstance,TResult}"/>.</param>
/// <param name="runEvaluator">The <see cref="IRunEvaluator{TInstance,TResult}"/>.</param>
/// <param name="configuration">The configuration.</param>
/// <param name="resultStorageActor">The <see cref="IActorRef"/> to the result storage actor.</param>
/// <param name="parameterTree">The parameter tree.</param>
/// <param name="customGrayBoxMethods">The <see cref="ICustomGrayBoxMethods{TResult}"/>.</param>
public GenerationEvaluationActor(
ITargetAlgorithmFactory <TTargetAlgorithm, TInstance, TResult> targetAlgorithmFactory,
IRunEvaluator <TInstance, TResult> runEvaluator,
AlgorithmTunerConfiguration configuration,
IActorRef resultStorageActor,
ParameterTree parameterTree,
ICustomGrayBoxMethods <TResult> customGrayBoxMethods)
{
this._targetAlgorithmFactory = targetAlgorithmFactory ?? throw new ArgumentNullException(nameof(targetAlgorithmFactory));
this._runEvaluator = runEvaluator ?? throw new ArgumentNullException(nameof(runEvaluator));
this._configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
this._resultStorageActor = resultStorageActor ?? throw new ArgumentNullException(nameof(resultStorageActor));
this._parameterTree = parameterTree ?? throw new ArgumentNullException(nameof(parameterTree));
// No need to check for null. Might be null by purpose.
this._customGrayBoxMethods = customGrayBoxMethods;
// If Akka.Cluster gets used, watch for disconnecting cluster members to make evaluation rollbacks possible.
if (Context.System.HasExtension <Cluster>())
{
Cluster.Get(Context.System).Subscribe(this.Self, typeof(ClusterEvent.UnreachableMember));
}
this.Become(this.WaitingForWorkers);
this.Self.Tell(new CheckWorkers());
}
/// <summary>
/// Initializes a new instance of the <see cref="SortingGenerationEvaluationStrategy{TInstance,TResult}"/> class.
/// </summary>
/// <param name="runEvaluator">The <see cref="IRunEvaluator{TInstance,TResult}"/> for sorting genomes.</param>
/// <param name="genomes">The genomes for evaluation. Do not need to be distinct.</param>
/// <param name="instances">The instances for evaluation.</param>
/// <param name="generation">The generation number.</param>
/// <param name="useGrayBoxInGeneration">Boolean indicating whether to use gray box tuning in current generation.</param>
public SortingGenerationEvaluationStrategy(
IRunEvaluator <TInstance, TResult> runEvaluator,
IEnumerable <ImmutableGenome> genomes,
IEnumerable <TInstance> instances,
int generation,
bool useGrayBoxInGeneration)
{
this._runEvaluator = runEvaluator ?? throw new ArgumentNullException(nameof(runEvaluator));
if (genomes == null)
{
throw new ArgumentNullException(nameof(genomes));
}
this._genomes = genomes.ToList();
if (instances == null)
{
throw new ArgumentNullException(nameof(instances));
}
this._generation = generation;
this._useGrayBoxInGeneration = useGrayBoxInGeneration;
this._genomeToGenomeStats = this._genomes.Distinct(ImmutableGenome.GenomeComparer).ToDictionary(
g => g,
g => new GenomeStats <TInstance, TResult>(g, Enumerable.Empty <TInstance>(), instances),
ImmutableGenome.GenomeComparer);
}
/// <summary>
/// Initializes a new instance of the <see cref="MiniTournamentActor{TTargetAlgorithm, TInstance, TResult}" /> class.
/// </summary>
/// <param name="targetAlgorithmFactory">Produces configured target algorithms to run with the genomes.</param>
/// <param name="runEvaluator">Object for evaluating target algorithm runs.</param>
/// <param name="configuration">Algorithm tuner configuration parameters.</param>
/// <param name="resultStorageActor">
/// Actor which is responsible for storing all evaluation results that have
/// been observed so far.
/// </param>
/// <param name="parameterTree">Specifies parameters and their relationships.</param>
/// <param name="tournamentSelector">Actor which provides this actor with evaluation tasks.</param>
public MiniTournamentActor(
ITargetAlgorithmFactory <TTargetAlgorithm, TInstance, TResult> targetAlgorithmFactory,
IRunEvaluator <TResult> runEvaluator,
AlgorithmTunerConfiguration configuration,
IActorRef resultStorageActor,
ParameterTree parameterTree,
IActorRef tournamentSelector)
: base(runEvaluator)
{
if (tournamentSelector == null)
{
throw new ArgumentNullException(nameof(tournamentSelector));
}
this._targetAlgorithmFactory =
targetAlgorithmFactory ?? throw new ArgumentNullException(nameof(targetAlgorithmFactory));
this._configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
this._resultStorageActor =
resultStorageActor ?? throw new ArgumentNullException(nameof(resultStorageActor));
this._parameterTree = parameterTree ?? throw new ArgumentNullException(nameof(parameterTree));
// Start in waiting for instances state.
this.WaitForInstances();
// Finally, find out if there is something to do already.
tournamentSelector.Tell(new InstancesRequest());
}
/// <summary>
/// Initializes a new instance of the <see cref="MiniTournamentManager{I, R}"/> class.
/// </summary>
/// <param name="participants">The tournament's participants. Do not need to be distinct.</param>
/// <param name="instances">The tournament's instances.</param>
/// <param name="miniTournamentId">The mini tournament id.</param>
/// <param name="generationId">The generation id.</param>
/// <param name="runEvaluator">The <see cref="IRunEvaluator{TInstance,TResult}"/>.</param>
/// <param name="enableRacing">Boolean indicating whether racing is enabled.</param>
/// <param name="desiredNumberOfWinners">The desired number of winners.</param>
public MiniTournamentManager(
IReadOnlyList <ImmutableGenome> participants,
IEnumerable <TInstance> instances,
int miniTournamentId,
int generationId,
IRunEvaluator <TInstance, TResult> runEvaluator,
bool enableRacing,
int desiredNumberOfWinners)
{
this.Participants = participants ?? throw new ArgumentNullException(nameof(participants));
if (instances == null)
{
throw new ArgumentNullException(nameof(instances));
}
this.MiniTournamentId = miniTournamentId;
this._generationId = generationId;
this._runEvaluator = runEvaluator ?? throw new ArgumentNullException(nameof(runEvaluator));
this._enableRacing = enableRacing;
this._desiredNumberOfWinners = desiredNumberOfWinners;
this._genomeToGenomeTournamentKey =
this.Participants.Distinct(ImmutableGenome.GenomeComparer).ToDictionary(
genome => genome,
genome => new GenomeTournamentKey(genome, this.MiniTournamentId),
ImmutableGenome.GenomeComparer);
this._genomeToGenomeStats = this._genomeToGenomeTournamentKey.Keys.ToDictionary(
genome => genome,
genome => new GenomeStats <TInstance, TResult>(genome, Enumerable.Empty <TInstance>(), instances),
ImmutableGenome.GenomeComparer)
.ToImmutableDictionary(ImmutableGenome.GenomeComparer);
}
/// <summary>
/// Validates the parameters:
/// * Null checks for every one of them.
/// * Checks that the number of training instances provided is sufficient considering the given configuration.
/// * Checks that configuration about whether to use run time tuning
/// and the usage of the run time tuning result interface fit together
/// * Checks that the parameter tree contains parameters.
/// * Checks that those parameters' identifiers are unique.
/// </summary>
/// <param name="targetAlgorithmFactory">
/// Produces configured instances of the target algorithm to tune.
/// </param>
/// <param name="runEvaluator">
/// Object for evaluating target algorithm runs.
/// </param>
/// <param name="trainingInstances">
/// The set of instances used for tuning.
/// </param>
/// <param name="parameterTree">
/// The parameter tree.
/// </param>
/// <param name="configuration">
/// Algorithm tuner configuration parameters.
/// </param>
/// <param name="genomeBuilder">
/// The genome builder.
/// </param>
private static void ValidateParameters(
ITargetAlgorithmFactory <TTargetAlgorithm, TInstance, TResult> targetAlgorithmFactory,
IRunEvaluator <TResult> runEvaluator,
IEnumerable <TInstance> trainingInstances,
ParameterTree parameterTree,
AlgorithmTunerConfiguration configuration,
GenomeBuilder genomeBuilder)
{
// Check argument for nulls.
if (targetAlgorithmFactory == null)
{
throw new ArgumentNullException(nameof(targetAlgorithmFactory), "You must specify a target algorithm factory.");
}
if (runEvaluator == null)
{
throw new ArgumentNullException(nameof(runEvaluator), "You must specify a run evaluator.");
}
if (trainingInstances == null)
{
throw new ArgumentNullException(nameof(trainingInstances), "You must specify a list of training instances.");
}
if (parameterTree == null)
{
throw new ArgumentNullException(nameof(parameterTree), "You must specify a parameter tree.");
}
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration), "You must specify an algorithm tuner configuration.");
}
if (genomeBuilder == null)
{
throw new ArgumentNullException(nameof(genomeBuilder), "You must specify a genome builder.");
}
// Check enough training instances have been provided.
var numInstances = trainingInstances.Count();
if (numInstances < configuration.EndNumInstances)
{
throw new ArgumentException(
$"In the end, {configuration.EndNumInstances} training instances should be used, but only {numInstances} have been provided.",
nameof(trainingInstances));
}
// Check that the parameter tree is valid.
if (!parameterTree.ContainsParameters())
{
throw new ArgumentException("Specified parameter tree without parameters.", nameof(parameterTree));
}
if (!parameterTree.IdentifiersAreUnique())
{
throw new ArgumentException("Specified parameter tree contained duplicate identifiers.", nameof(parameterTree));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="GenomeSorter{TInstance,TResult}"/> class.
/// </summary>
/// <param name="runEvaluator">Object for evaluating target algorithm runs.</param>
public GenomeSorter(IRunEvaluator <TResult> runEvaluator)
: base(runEvaluator)
{
this.WaitingForEvaluators();
// Directly check if we have enough evaluators to switch to ready state.
this.Self.Tell(new CheckWorkers());
}
/// <summary>
/// Initializes a new instance of the <see cref="AlgorithmTuner{TTargetAlgorithm,TInstance,TResult}"/> class.
/// </summary>
/// <param name="targetAlgorithmFactory">
/// The target algorithm factory.
/// </param>
/// <param name="runEvaluator">
/// The run evaluator.
/// </param>
/// <param name="trainingInstances">
/// The training instances.
/// </param>
/// <param name="parameterTree">
/// The parameter tree.
/// </param>
/// <param name="configuration">
/// The configuration.
/// </param>
/// <param name="genomeBuilder">
/// The genome builder.
/// </param>
public AlgorithmTuner(
ITargetAlgorithmFactory <TTargetAlgorithm, TInstance, TResult> targetAlgorithmFactory,
IRunEvaluator <TResult> runEvaluator,
IEnumerable <TInstance> trainingInstances,
ParameterTree parameterTree,
AlgorithmTunerConfiguration configuration,
GenomeBuilder genomeBuilder)
: base(targetAlgorithmFactory, runEvaluator, trainingInstances, parameterTree, configuration, genomeBuilder)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="TournamentSelector{TTargetAlgorithm, TInstance, TResult}" /> class.
/// </summary>
/// <param name="targetAlgorithmFactory">Produces configured target algorithms to run with the genomes.</param>
/// <param name="runEvaluator">Object for evaluating target algorithm runs.</param>
/// <param name="configuration">Algorithm tuner configuration parameters.</param>
/// <param name="resultStorageActor">
/// Actor which is responsible for storing all evaluation results that have
/// been observed so far.
/// </param>
/// <param name="parameterTree">Specifies parameters and their relationships.</param>
public TournamentSelector(
ITargetAlgorithmFactory <TTargetAlgorithm, TInstance, TResult> targetAlgorithmFactory,
IRunEvaluator <TResult> runEvaluator,
AlgorithmTunerConfiguration configuration,
IActorRef resultStorageActor,
ParameterTree parameterTree)
{
// Verify parameters.
if (targetAlgorithmFactory == null)
{
throw new ArgumentNullException("targetAlgorithmFactory");
}
if (runEvaluator == null)
{
throw new ArgumentNullException("runEvaluator");
}
if (configuration == null)
{
throw new ArgumentNullException("configuration");
}
if (resultStorageActor == null)
{
throw new ArgumentNullException("resultStorageActor");
}
if (parameterTree == null)
{
throw new ArgumentNullException("parameterTree");
}
// Use them to set fields.
this._targetAlgorithmFactory = targetAlgorithmFactory;
this._runEvaluator = runEvaluator;
this._configuration = configuration;
this._resultStorageActor = resultStorageActor;
this._parameterTree = parameterTree;
this._selectionProgress = new TournamentSelectionProgress <TInstance, TResult>(this._configuration);
// If Akka.Cluster gets used, watch for disconnecting cluster members
// to make tournament rollbacks possible.
if (Context.System.HasExtension <Cluster>())
{
Cluster.Get(Context.System).Subscribe(this.Self, typeof(ClusterEvent.UnreachableMember));
}
// Start in waiting for workers state.
this.WaitingForWorkers();
// And directly check if we have enough workers to switch to ready state.
this.Self.Tell(new CheckWorkers());
}
/// <summary>
/// Initializes a new instance of the <see cref="MiniTournamentManagerTest"/> class.
/// </summary>
public MiniTournamentManagerTest()
{
this._instances = Enumerable.Range(0, 5).Select(i => new TestInstance($"{i}")).ToList();
this._participants = this.CreateGenomesDescendingByAge(8, 0).ToList();
this._globalQueue = new SimplePriorityQueue <GenomeTournamentKey, double>();
this._runEvaluator = new KeepSuggestedOrder <TestInstance, ContinuousResult>();
this._defaultManager = new MiniTournamentManager <TestInstance, ContinuousResult>(
this._participants,
this._instances,
42,
0,
this._runEvaluator,
false,
1);
}
/// <summary>
/// Creates a <see cref="TournamentSelector{TTargetAlgorithm, TInstance, TResult}"/>.
/// </summary>
/// <typeparam name="TTargetAlgorithm">Algorithm to execute.</typeparam>
/// <typeparam name="TInstance">Type of instances the algorithm takes.</typeparam>
/// <typeparam name="TResult">Type of result the algorithm returns.</typeparam>
/// <param name="system">The <see cref="ActorSystem"/> to add the actor to.</param>
/// <param name="targetAlgorithmFactory">Specifies how to create an algorithm instance.</param>
/// <param name="runEvaluator">Specifies how runs should be compared.</param>
/// <returns>The created <see cref="TournamentSelector{TTargetAlgorithm, TInstance, TResult}"/>.</returns>
private IActorRef CreateTournamentSelector <TTargetAlgorithm, TInstance, TResult>(
ActorSystem system,
ITargetAlgorithmFactory <TTargetAlgorithm, TInstance, TResult> targetAlgorithmFactory,
IRunEvaluator <TResult> runEvaluator)
where TTargetAlgorithm : ITargetAlgorithm <TInstance, TResult> where TInstance : InstanceBase where TResult : ResultBase <TResult>, new()
{
return(system.ActorOf(
Props.Create(
() => new TournamentSelector <TTargetAlgorithm, TInstance, TResult>(
targetAlgorithmFactory,
runEvaluator,
this._configuration,
this._resultStorageActor,
this._parameterTree)),
AkkaNames.TournamentSelector));
}
/// <summary>
/// Initializes a new instance of the <see cref="AlgorithmTuner{TTargetAlgorithm,TInstance,TResult}"/> class.
/// </summary>
/// <param name="targetAlgorithmFactory">
/// The target algorithm factory.
/// </param>
/// <param name="runEvaluator">
/// The run evaluator.
/// </param>
/// <param name="trainingInstances">
/// The training instances.
/// </param>
/// <param name="parameterTree">
/// The parameter tree.
/// </param>
/// <param name="configuration">
/// The configuration.
/// </param>
/// <param name="customGrayBoxMethods">The <see cref="ICustomGrayBoxMethods{TResult}"/>, if any. Default is null.</param>
public AlgorithmTuner(
ITargetAlgorithmFactory <TTargetAlgorithm, TInstance, TResult> targetAlgorithmFactory,
IRunEvaluator <TInstance, TResult> runEvaluator,
IEnumerable <TInstance> trainingInstances,
ParameterTree parameterTree,
AlgorithmTunerConfiguration configuration,
ICustomGrayBoxMethods <TResult> customGrayBoxMethods = null)
: this(
targetAlgorithmFactory,
runEvaluator,
trainingInstances,
parameterTree,
configuration,
new GenomeBuilder(parameterTree, configuration),
customGrayBoxMethods)
{
}
/// <summary>
/// Creates all required messages to send the results of a <see cref="SelectCommand{TInstance}"/>.
/// </summary>
/// <param name="runEvaluator">Object for evaluating target algorithm runs.</param>
/// <returns>The created messages.</returns>
public object CreateSelectionResultMessage(IRunEvaluator <TResult> runEvaluator)
{
// Sort all tournament winners to get global winners.
// assumption: all mini tournaments of a specific generation were held on the same subset of instances.
var tournamentWinnerResults = this._miniTournamentResults
.SelectMany(msg => msg.WinnerResults)
.ToDictionary(keyValuePair => keyValuePair.Key, keyValuePair => keyValuePair.Value as IEnumerable <TResult>);
var orderedTournamentWinners = runEvaluator.Sort(tournamentWinnerResults).ToList();
var generationBest = orderedTournamentWinners.First();
return(new SelectionResultMessage <TResult>(
orderedTournamentWinners.ToImmutableList(),
this.GenomeToTournamentResults,
generationBest,
tournamentWinnerResults[generationBest]));
}
/// <summary>
/// Creates the different <see cref="IPopulationUpdateStrategy{TInstance,TResult}"/>s that may be used to
/// update the population.
/// </summary>
/// <param name="targetAlgorithmFactory">
/// Produces configured instances of the target algorithm to tune.
/// </param>
/// <param name="runEvaluator">
/// Object for evaluating target algorithm runs.
/// </param>
/// <returns>The created <see cref="IPopulationUpdateStrategy{TInstance,TResult}"/>s.</returns>
private IEnumerable <IPopulationUpdateStrategy <TInstance, TResult> > CreatePopulationUpdateStrategies(
ITargetAlgorithmFactory <TTargetAlgorithm, TInstance, TResult> targetAlgorithmFactory,
IRunEvaluator <TResult> runEvaluator)
{
var tournamentSelector = this._targetAlgorithmRunActors.ActorOf(
Props.Create(
() => new TournamentSelector <TTargetAlgorithm, TInstance, TResult>(
targetAlgorithmFactory,
runEvaluator,
this._configuration,
this._targetRunResultStorage,
this._parameterTree)),
AkkaNames.TournamentSelector);
yield return(new GgaStrategy <TInstance, TResult>(
this._configuration,
this._parameterTree,
this._genomeBuilder,
tournamentSelector,
this.GeneticEngineering));
if (this._configuration.ContinuousOptimizationMethod == ContinuousOptimizationMethod.Jade)
{
yield return(new DifferentialEvolutionStrategy <TInstance, TResult>(
this._configuration,
this._parameterTree,
this._genomeBuilder,
this._genomeSorter,
this._targetRunResultStorage));
}
if (this._configuration.ContinuousOptimizationMethod == ContinuousOptimizationMethod.CmaEs)
{
yield return(CovarianceMatrixAdaptationInformationFlowSwitch.CreateCovarianceMatrixAdaptationStrategy <TInstance, TResult>(
this._configuration,
this._parameterTree,
this._genomeBuilder,
this._genomeSorter,
this._targetRunResultStorage));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AlgorithmTuner{TTargetAlgorithm,TInstance,TResult,TModelLearner,TPredictorModel,TSamplingStrategy}"/> class.
/// </summary>
/// <param name="targetAlgorithmFactory">
/// Produces configured instances of the algorithm to tune.
/// </param>
/// <param name="runEvaluator">
/// Object for evaluating target algorithm runs.
/// </param>
/// <param name="trainingInstances">
/// The set of instances used for tuning.
/// </param>
/// <param name="parameterTree">
/// Provides the tunable parameters.
/// </param>
/// <param name="configuration">
/// Algorithm tuner configuration parameters.
/// </param>
/// <param name="genomeBuilder">
/// Responsible for creation, modification and crossover of genomes.
/// Needs to be compatible with the given parameter tree and configuration.
/// This parameter can be left out if an ordinary <see cref="GenomeBuilder"/> should be used.
/// </param>
public AlgorithmTuner(
ITargetAlgorithmFactory <TTargetAlgorithm, TInstance, TResult> targetAlgorithmFactory,
IRunEvaluator <TResult> runEvaluator,
IEnumerable <TInstance> trainingInstances,
ParameterTree parameterTree,
AlgorithmTunerConfiguration configuration,
GenomeBuilder genomeBuilder)
{
ValidateParameters(targetAlgorithmFactory, runEvaluator, trainingInstances, parameterTree, configuration, genomeBuilder);
LoggingHelper.WriteLine(
VerbosityLevel.Info,
$"Tuning target algorithm with {parameterTree.GetParameters().Count()} parameters.");
this._configuration = configuration;
this._runEvaluator = runEvaluator;
this.GeneticEngineering = new GeneticEngineering <TModelLearner, TPredictorModel, TSamplingStrategy>(parameterTree, this._configuration);
this.IncumbentQuality = new List <double>();
this._trainingInstances = trainingInstances.ToList();
this._instanceSelector = new InstanceSelector <TInstance>(this._trainingInstances, configuration);
this._parameterTree = parameterTree;
this._genomeBuilder = genomeBuilder;
this._targetAlgorithmRunActors = ActorSystem.Create(AkkaNames.ActorSystemName, configuration.AkkaConfiguration);
this._targetRunResultStorage = this._targetAlgorithmRunActors.ActorOf(
Props.Create(() => new ResultStorageActor <TInstance, TResult>()),
AkkaNames.ResultStorageActor);
this._genomeSorter = this._targetAlgorithmRunActors.ActorOf(
Props.Create(() => new GenomeSorter <TInstance, TResult>(runEvaluator)),
AkkaNames.GenomeSorter);
this._logWriter = new LogWriter <TInstance, TResult>(parameterTree, configuration);
this._populationUpdateStrategyManager = new PopulationUpdateStrategyManager <TInstance, TResult>(
this.CreatePopulationUpdateStrategies(targetAlgorithmFactory, runEvaluator).ToList(),
configuration);
}
/// <summary>
/// Initializes a new instance of the <see cref="GrayBoxSimulation{TTargetAlgorithm, TInstance, TResult}" /> class.
/// </summary>
/// <param name="configuration">The <see cref="AlgorithmTunerConfiguration"/>.</param>
/// <param name="targetAlgorithmFactory">The <see cref="ITargetAlgorithmFactory{TTargetAlgorithm, TInstance, TResult}"/>.</param>
/// <param name="customGrayBoxMethods">The <see cref="ICustomGrayBoxMethods{TResult}"/>.</param>
/// <param name="runEvaluator">The <see cref="IRunEvaluator{TInstance, TResult}"/>.</param>
/// <param name="parameterTree">The <see cref="ParameterTree"/>.</param>
public GrayBoxSimulation(
AlgorithmTunerConfiguration configuration,
ITargetAlgorithmFactory <TTargetAlgorithm, TInstance, TResult> targetAlgorithmFactory,
ICustomGrayBoxMethods <TResult> customGrayBoxMethods,
IRunEvaluator <TInstance, TResult> runEvaluator,
ParameterTree parameterTree)
{
ProcessUtils.SetDefaultCultureInfo(CultureInfo.InvariantCulture);
this._configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
this._customGrayBoxMethods = customGrayBoxMethods ?? throw new ArgumentNullException(nameof(customGrayBoxMethods));
this._runEvaluator = runEvaluator ?? throw new ArgumentNullException(nameof(runEvaluator));
this._targetAlgorithmFactory = targetAlgorithmFactory ?? throw new ArgumentNullException(nameof(targetAlgorithmFactory));
this._parameterTree = parameterTree ?? throw new ArgumentNullException(nameof(parameterTree));
this._logFileDirectory = new DirectoryInfo(Path.Combine(this._configuration.DataRecordDirectoryPath, "GrayBoxSimulationLogFiles"));
Directory.CreateDirectory(this._logFileDirectory.FullName);
LoggingHelper.Configure(
Path.Combine(this._logFileDirectory.FullName, $"consoleOutput_GrayBoxSimulation_{ProcessUtils.GetCurrentProcessId()}.log"));
LoggingHelper.ChangeConsoleLoggingLevel(configuration.Verbosity);
LoggingHelper.WriteLine(VerbosityLevel.Info, "Reading in and preprocessing data for gray box simulation.");
if (!GrayBoxUtils.TryToReadDataRecordsFromDirectory(
targetAlgorithmFactory,
configuration.DataRecordDirectoryPath,
0,
configuration.Generations - 1,
out this._allDataRecords))
{
throw new ArgumentException($"Cannot read data records from {configuration.DataRecordDirectoryPath}!");
}
this.ReadGenerationCompositionFiles();
this.CreatePredictionDictionaryAndDataDictionary();
}
/// <summary>
/// Initializes a new instance of the <see cref="GenomeEvaluationDelegatorBase{TInstance, TResult}"/> class.
/// </summary>
/// <param name="runEvaluator">Object for evaluating target algorithm runs.</param>
protected GenomeEvaluationDelegatorBase(IRunEvaluator <TResult> runEvaluator)
{
this._runEvaluator = runEvaluator ?? throw new ArgumentNullException(nameof(runEvaluator));
}
/// <summary>
/// Sets the <see cref="IRunEvaluator{TestResult}"/> to provide to the
/// <see cref="TournamentSelector{NoOperation, TestInstance, EmptyResult}"/> constructor. Default is an
/// evaluator that doesn't reorder the genomes at all.
/// </summary>
/// <param name="runEvaluator">The run evaluator to provide to the min tournament actor constructor.
/// </param>
/// <returns>The <see cref="TournamentSelectorPropsBuilder"/> in its new state.</returns>
public TournamentSelectorPropsBuilder SetRunEvaluator(IRunEvaluator <TestResult> runEvaluator)
{
this._runEvaluator = runEvaluator;
return(this);
}
/// <summary>
/// Initializes a new instance of the <see cref="MiniTournamentGenerationEvaluationStrategy{TInstance,TResult}"/> class.
/// </summary>
/// <param name="runEvaluator">The <see cref="IRunEvaluator{TInstance,TResult}"/> for sorting genomes.</param>
/// <param name="genomes">The genomes for evaluation. Do not need to be distinct.</param>
/// <param name="instances">The instances for evaluation.</param>
/// <param name="generation">The generation number.</param>
/// <param name="configuration">The algorithm tuner configuration.</param>
/// <param name="useGrayBoxInGeneration">Boolean indicating whether to use gray box tuning in current generation.</param>
/// <param name="useSingleTournamentWithSingleWinnerInGeneration">Boolean indicating whether to use only a single tournament with single winner in current generation.</param>
public MiniTournamentGenerationEvaluationStrategy(
IRunEvaluator <TInstance, TResult> runEvaluator,
IEnumerable <ImmutableGenome> genomes,
IEnumerable <TInstance> instances,
int generation,
AlgorithmTunerConfiguration configuration,
bool useGrayBoxInGeneration,
bool useSingleTournamentWithSingleWinnerInGeneration)
{
this._runEvaluator = runEvaluator ?? throw new ArgumentNullException(nameof(runEvaluator));
if (genomes == null)
{
throw new ArgumentNullException(nameof(genomes));
}
this._genomes = genomes.ToList();
if (instances == null)
{
throw new ArgumentNullException(nameof(instances));
}
this._generation = generation;
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
this._useGrayBoxInGeneration = useGrayBoxInGeneration;
if (useSingleTournamentWithSingleWinnerInGeneration)
{
this._tournamentManagers = new List <MiniTournamentManager <TInstance, TResult> >
{
new MiniTournamentManager <TInstance, TResult>(
this._genomes,
instances,
0,
this._generation,
this._runEvaluator,
configuration.EnableRacing,
1),
};
}
else
{
var counter = 0;
this._tournamentManagers
= Randomizer.Instance.SplitIntoRandomBalancedSubsets(this._genomes, configuration.MaximumMiniTournamentSize)
.Select(
participants =>
{
var participantList = participants.ToList();
return(new MiniTournamentManager <TInstance, TResult>(
participantList,
instances,
counter++,
this._generation,
this._runEvaluator,
configuration.EnableRacing,
MiniTournamentGenerationEvaluationStrategy <TInstance, TResult> .GetDesiredNumberOfWinners(
configuration,
participantList)));
}).ToList();
}
// The generation evaluation actor requeues all required evaluations.
this._priorityQueue = new SimplePriorityQueue <GenomeTournamentKey, double>();
}
