/// <summary>
/// Construct with the provided IGenomeDecoder, IPhenomeEvaluator and ParalleOptions.
/// Phenome caching is enabled by default.
/// The number of parallel threads defaults to Environment.ProcessorCount.
/// </summary>
public ParallelGenomeListEvaluator(IGenomeDecoder <TGenome, TPhenome> genomeDecoder,
IPhenomeEvaluator <TPhenome> phenomeEvaluator,
ParallelOptions options)
//: this(genomeDecoder, phenomeEvaluator, options, true)
: this(genomeDecoder, phenomeEvaluator, options, false)
{
}
/// <summary>
/// Construct with the provided IGenomeDecoder and IPhenomeEvaluator.
/// Phenome caching is enabled by default.
/// </summary>
public SerialGenomeListEvaluator(IGenomeDecoder <TGenome, TPhenome> genomeDecoder, IPhenomeEvaluator <TPhenome> phenomeEvaluator)
{
_genomeDecoder = genomeDecoder;
_phenomeEvaluator = phenomeEvaluator;
_enablePhenomeCaching = true;
_evaluationMethod = Evaluate_Caching;
}
/// <summary>
/// Construct with the provided genome decoder and phenome evaluator.
/// </summary>
/// <param name="genomeDecoder">Genome decoder.</param>
/// <param name="phenomeEvaluationScheme">Phenome evaluation scheme.</param>
/// <param name="degreeOfParallelism">The desired degree of parallelism.</param>
public ParallelGenomeListEvaluatorStateless(
IGenomeDecoder <TGenome, TPhenome> genomeDecoder,
IPhenomeEvaluationScheme <TPhenome> phenomeEvaluationScheme,
int degreeOfParallelism)
{
// This class can only accept an evaluation scheme that uses a stateless evaluator.
if (phenomeEvaluationScheme.EvaluatorsHaveState)
{
throw new ArgumentException(nameof(phenomeEvaluationScheme));
}
// Reject degreeOfParallelism values less than 2. -1 should have been resolved to an actual number by the time
// this constructor is invoked, and 1 is nonsensical for a parallel evaluator.
if (degreeOfParallelism < 2)
{
throw new ArgumentException(nameof(degreeOfParallelism));
}
_genomeDecoder = genomeDecoder;
_phenomeEvaluationScheme = phenomeEvaluationScheme;
_phenomeEvaluator = phenomeEvaluationScheme.CreateEvaluator();
_parallelOptions = new ParallelOptions {
MaxDegreeOfParallelism = degreeOfParallelism
};
}
/// <summary>
/// Construct with the provided <see cref="IGenomeDecoder"/> and <see cref="IPhenomeEvaluator"/>.
/// Phenome caching is enabled by default.
/// </summary>
public SerialGenomeListEvaluator(
IGenomeDecoder <TGenome, TPhenome> genomeDecoder,
IPhenomeEvaluator <TPhenome> phenomeEvaluator)
{
_genomeDecoder = genomeDecoder;
_phenomeEvaluator = phenomeEvaluator;
}
/// <summary>
/// Construct with the provided IGenomeDecoder and IPhenomeEvaluator.
/// </summary>
public UnityParallelListEvaluator(IGenomeDecoder <TGenome, TPhenome> genomeDecoder,
IPhenomeEvaluator <TPhenome> phenomeEvaluator,
NEATController neController)
{
_genomeDecoder = genomeDecoder;
_phenomeEvaluator = phenomeEvaluator;
this.neController = neController;
}
/// <summary>
/// Construct with the provided IGenomeDecoder and IPhenomeEvaluator.
/// </summary>
public CoroutinedListEvaluator(IGenomeDecoder <TGenome, TPhenome> genomeDecoder,
IPhenomeEvaluator <TPhenome> phenomeEvaluator,
NeatSupervisor neatSupervisor)
{
_genomeDecoder = genomeDecoder;
_phenomeEvaluator = phenomeEvaluator;
_neatSupervisor = neatSupervisor;
}
/// <summary>
/// Constructor taking a genomedecoder and phenomeEvaluator.
/// </summary>
public UnityParallelListEvaluatorOrganism(IGenomeDecoder <TGenome, TPhenome> genomeDecoder,
IPhenomeEvaluator <TPhenome> phenomeEvaluator,
NEATControllerOrg controller)
{
_genomeDecoder = genomeDecoder;
_phenomeEvaluator = phenomeEvaluator;
this.controller = controller;
}
/// <summary>
/// Construct with the provided IGenomeDecoder and IPhenomeEvaluator.
/// </summary>
public UnityParallelListEvaluator(IGenomeDecoder <TGenome, TPhenome> genomeDecoder,
IPhenomeEvaluator <TPhenome> phenomeEvaluator,
Optimizer opt)
{
_genomeDecoder = genomeDecoder;
_phenomeEvaluator = phenomeEvaluator;
_optimizer = opt;
}
/// <summary>
/// Construct with the provided IGenomeDecoder and IPhenomeEvaluator.
/// </summary>
public UnityAstroidEvaluator(IGenomeDecoder <TGenome, TPhenome> genomeDecoder,
IPhenomeEvaluator <TPhenome> phenomeEvaluator,
Optimizer opt)
{
_genomeDecoder = genomeDecoder;
_phenomeEvaluator = phenomeEvaluator;
_optimizer = opt;
}
/// <summary>
/// Construct with the provided IGenomeDecoder, IPhenomeEvaluator and ParalleOptions.
/// Phenome caching is enabled by default.
/// The number of parallel threads defaults to Environment.ProcessorCount.
/// </summary>
public CacheFirstParallelGenomeListEvaluator(IGenomeDecoder <TGenome, TPhenome> genomeDecoder,
IPhenomeEvaluator <TPhenome> phenomeEvaluator,
ParallelOptions options)
{
_genomeDecoder = genomeDecoder;
_phenomeEvaluator = phenomeEvaluator;
_parallelOptions = options;
}
public BraidListEvaluator(IGenomeDecoder <TGenome, TPhenome> genomeDecoder,
IPhenomeEvaluator <TPhenome> phenomeEvaluator,
Optimizer opt)
{
m_genomeDecoder = genomeDecoder;
m_phenomeEvaluator = phenomeEvaluator;
m_optimizer = opt;
}
/// <summary>
/// Construct with the provided IGenomeDecoder and IPhenomeEvaluator.
/// </summary>
public UnityMultiLayerEvaluator(IGenomeDecoder <TGenome, TPhenome> genomeDecoder,
IPhenomeEvaluator <TPhenome> phenomeEvaluator,
Optimizer opt, AgarEvaluator agar)
{
_genomeDecoder = genomeDecoder;
_phenomeEvaluator = phenomeEvaluator;
_optimizer = opt;
_agar = agar;
}
/// <summary>
/// Construct with the provided <see cref="IGenomeDecoder{TGenome,TPhenome}"/> and <see cref="IPhenomeEvaluator{TPhenome}"/>.
/// Phenome caching is enabled by default.
/// </summary>
public SerialGenomeListEvaluator(
IGenomeDecoder <TGenome, TPhenome> genomeDecoder,
IPhenomeEvaluationScheme <TPhenome> phenomeEvaluationScheme)
{
_genomeDecoder = genomeDecoder;
_phenomeEvaluationScheme = phenomeEvaluationScheme;
// Note. SerialGenomeListEvaluator will only evaluate on one thread therefore only ever requires a single evaluator.
_phenomeEvaluator = phenomeEvaluationScheme.CreateEvaluator();
}
/// <summary>
/// Construct with the provided IGenomeDecoder, IPhenomeEvaluator and enablePhenomeCaching flag.
/// </summary>
public SerialGenomeListEvaluator(IGenomeDecoder <TGenome, TPhenome> genomeDecoder, IPhenomeEvaluator <TPhenome> phenomeEvaluator, bool enablePhenomeCaching)
{
_genomeDecoder = genomeDecoder;
_phenomeEvaluator = phenomeEvaluator;
_enablePhenomeCaching = enablePhenomeCaching;
if (_enablePhenomeCaching)
{
_evaluationMethod = Evaluate_Caching;
}
else
{
_evaluationMethod = Evaluate_NonCaching;
}
}
/// <summary>
/// Construct with the provided IGenomeDecoder, IPhenomeEvaluator and ParallelOptions.
/// </summary>
public ParallelGenomeListEvaluatorStateless(
IGenomeDecoder <TGenome, TPhenome> genomeDecoder,
IPhenomeEvaluationScheme <TPhenome> phenomeEvaluatorScheme,
ParallelOptions parallelOptions)
{
// This class can only accept an evaluation scheme that uses a stateless evaluator.
if (phenomeEvaluatorScheme.EvaluatorsHaveState)
{
throw new ArgumentException(nameof(phenomeEvaluatorScheme));
}
_genomeDecoder = genomeDecoder;
_phenomeEvaluationScheme = phenomeEvaluatorScheme;
_phenomeEvaluator = phenomeEvaluatorScheme.CreateEvaluator();
_parallelOptions = parallelOptions;
}
/// <summary>
/// Construct with the provided IGenomeDecoder, IPhenomeEvaluator, ParalleOptions and enablePhenomeCaching flag.
/// </summary>
public ParallelGenomeListEvaluator(IGenomeDecoder <TGenome, TPhenome> genomeDecoder, IPhenomeEvaluator <TPhenome> phenomeEvaluator, ParallelOptions options, bool enablePhenomeCaching)
{
_genomeDecoder = genomeDecoder;
_phenomeEvaluator = phenomeEvaluator;
_parallelOptions = options;
_enablePhenomeCaching = enablePhenomeCaching;
// Determine the appropriate evaluation method.
if (_enablePhenomeCaching)
{
_evalMethod = Evaluate_Caching;
}
else
{
_evalMethod = Evaluate_NonCaching;
}
}
public NeuromonExperiment(ExperimentSettings experimentSettings, NeatEvolutionAlgorithmParameters evolutionAlgorithmParameters, IPhenomeEvaluator<IBlackBox> neuromonPhenomeEvaluator, NeatGenomeParameters genomeParameters)
{
Name = experimentSettings.ExperimentName;
Description = experimentSettings.Description;
InputCount = experimentSettings.InputCount;
OutputCount = experimentSettings.OutputCount;
DefaultPopulationSize = experimentSettings.PopulationSize;
_neuromonPhenomeEvaluator = neuromonPhenomeEvaluator;
_complexityRegulationStrategy = experimentSettings.ComplexityRegulationStrategy;
_complexityThreshold = experimentSettings.ComplexityThreshold;
// Removed from .xml configuration. TODO: Possibly make configurable via json config
_networkActivationScheme = NetworkActivationScheme.CreateCyclicFixedTimestepsScheme(1);
NeatEvolutionAlgorithmParameters = evolutionAlgorithmParameters;
NeatGenomeParameters = genomeParameters;
}
/// <summary>
/// Construct with the provided IGenomeDecoder, IPhenomeEvaluator, enablePhenomeCaching flag
/// and thread count.
/// </summary>
/// <param name="genomeDecoder"></param>
/// <param name="phenomeEvaluator"></param>
/// <param name="enablePhenomeCaching"></param>
/// <param name="threadCount"></param>
public ParallelGenomeListEvaluator(IGenomeDecoder <TGenome, TPhenome> genomeDecoder,
IPhenomeEvaluator <TPhenome> phenomeEvaluator,
bool enablePhenomeCaching,
int threadCount)
{
_genomeDecoder = genomeDecoder;
_phenomeEvaluator = phenomeEvaluator;
_enablePhenomeCaching = enablePhenomeCaching;
// Determine the appropriate worker-thread method.
Action <object> workerThreadmethod;
if (_enablePhenomeCaching)
{
workerThreadmethod = WorkerThreadMethod_Caching;
}
else
{
workerThreadmethod = WorkerThreadMethod_NonCaching;
}
_infoArr = new WorkerThreadInfo[threadCount];
_completedWorkEventArr = new ManualResetEvent[threadCount];
_threadArr = new Thread[threadCount];
for (int i = 0; i < threadCount; i++)
{
// Create thread and its own info object.
WorkerThreadInfo info = new WorkerThreadInfo();
Thread thread = new Thread(new ParameterizedThreadStart(workerThreadmethod));
thread.IsBackground = true;
thread.Priority = ThreadPriority.BelowNormal;
// Store the thread and it's info object in arrays.
// Also store references to all of the created _completedWorkEvent objects in an array,
// this allows to wait for all of them together (WaitHandle.WaitAny/All).
_threadArr[i] = thread;
_infoArr[i] = info;
_completedWorkEventArr[i] = info._completedWorkEvent;
// Start the thread and pass the info object to this invocation of the thread method.
thread.Start(info);
}
}
/// <summary>
/// Releases an evaluator back into the pool.
/// </summary>
/// <param name="evaluator">The evaluator to release.</param>
public void ReleaseEvaluator(IPhenomeEvaluator <TPhenome> evaluator)
{
bool lockTaken = false;
try
{
// Wait for the sync lock.
_spinLock.Enter(ref lockTaken);
// Put the evaluator into the pool.
_evaluatorStack.Push(evaluator);
}
finally
{
// Release the sync lock.
if (lockTaken)
{
_spinLock.Exit(false);
}
}
}
/// <summary>
/// Construct with the provided IGenomeDecoder and IPhenomeEvaluator.
/// Phenome caching is enabled by default.
/// The number of parallel threads defaults to Environment.ProcessorCount.
/// </summary>
public ParallelGenomeListEvaluator(IGenomeDecoder <TGenome, TPhenome> genomeDecoder,
IPhenomeEvaluator <TPhenome> phenomeEvaluator)
: this(genomeDecoder, phenomeEvaluator, new ParallelOptions(), true)
{
}
/// <summary>
/// Construct with the provided IGenomeDecoder and IPhenomeEvaluator.
/// Phenome caching is enabled by default.
/// </summary>
public SerialGenomeListEvaluator(IGenomeDecoder <TGenome, TPhenome> genomeDecoder,
IPhenomeEvaluator <TPhenome> phenomeEvaluator)
: this(genomeDecoder, phenomeEvaluator, true)
{
}
/// <summary>
/// This is my implementation that takes in a base args class instead of xml
/// </summary>
/// <remarks>
/// Initialize must be called after the constructor. After that, NeatEvolutionAlgorithmParameters and NeatGenomeParameters will be
/// instantiated, and can be tweaked
///
/// Once all the properties are set the way you want, call CreateEvolutionAlgorithm():
///
/// _experiment = new ExperimentBase_NEAT() // or something that derives from this base
/// _experiment.Initialize(args, evaluator);
///
/// _experiment.NeatGenomeParameters.??? = ???
/// _experiment.NeatEvolutionAlgorithmParameters.??? = ???
///
/// _ea = _experiment.CreateEvolutionAlgorithm();
/// </remarks>
public void Initialize(string name, ExperimentInitArgs args, IPhenomeEvaluator <IBlackBox> phenomeEvaluator)
{
_phenomeEvaluator = phenomeEvaluator;
Initialize_private(name, args);
}
public SineExperiment(bool evaluateParents, IPhenomeEvaluator<IBlackBox> phenomeEvaluator)
{
EvaluateParents = evaluateParents;
PhenomeEvaluator = phenomeEvaluator;
}
private void GetPhenomeEvaluator()
{
_PhenomeEvaluator = PhenomeEvaluator();
}
public SimpleGenomeListEvaluator(IGenomeDecoder <TGenome, TPhenome> genomeDecoder, IPhenomeEvaluator <TPhenome> phenomeEvaluator)
{
this.genomeDecoder = genomeDecoder;
this.phenomeEvaluator = phenomeEvaluator;
}
/// <summary>
/// Construct with the provided IGenomeDecoder and IPhenomeEvaluator.
/// Phenome caching is enabled by default.
/// The number of parallel threads defaults to Environment.ProcessorCount.
/// </summary>
/// <param name="genomeDecoder"></param>
/// <param name="phenomeEvaluator"></param>
public ParallelGenomeListEvaluator(IGenomeDecoder <TGenome, TPhenome> genomeDecoder,
IPhenomeEvaluator <TPhenome> phenomeEvaluator)
: this(genomeDecoder, phenomeEvaluator, true, Environment.ProcessorCount)
{
}
/// <summary>
/// Construct with the provided IGenomeDecoder, IPhenomeEvaluator and enablePhenomeCaching flag.
/// The number of parallel threads defaults to Environment.ProcessorCount.
/// </summary>
/// <param name="genomeDecoder"></param>
/// <param name="phenomeEvaluator"></param>
/// <param name="enablePhenomeCaching"></param>
public ParallelGenomeListEvaluator(IGenomeDecoder <TGenome, TPhenome> genomeDecoder,
IPhenomeEvaluator <TPhenome> phenomeEvaluator,
bool enablePhenomeCaching)
: this(genomeDecoder, phenomeEvaluator, enablePhenomeCaching, Environment.ProcessorCount)
{
}