public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory <NeatGenome> genomeFactory, List <NeatGenome> genomeList)
{
IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0);
ISpeciationStrategy <NeatGenome> speciationStrategy = new KMeansClusteringStrategy <NeatGenome>(distanceMetric);
IComplexityRegulationStrategy complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold);
NeatEvolutionAlgorithm <NeatGenome> ea = new NeatEvolutionAlgorithm <NeatGenome>(_eaParams, speciationStrategy, complexityRegulationStrategy);
// Create black box evaluator
AgarEvaluator evaluator = new AgarEvaluator(_optimizer);
IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder();
IGenomeListEvaluator <NeatGenome> innerEvaluator = new UnitySingleGenomeEvaluator <NeatGenome, IBlackBox>(genomeDecoder, evaluator, _optimizer);
IGenomeListEvaluator <NeatGenome> selectiveEvaluator = new SelectiveGenomeListEvaluator <NeatGenome>(innerEvaluator,
SelectiveGenomeListEvaluator <NeatGenome> .CreatePredicate_OnceOnly());
//ea.Initialize(selectiveEvaluator, genomeFactory, genomeList);
ea.Initialize(selectiveEvaluator, genomeFactory, genomeList);
return(ea);
}
/// <summary>
/// Create and return a NeatEvolutionAlgorithm object ready for running the NEAT algorithm/search. Various sub-parts
/// of the algorithm are also constructed and connected up.
/// This overload accepts a pre-built genome population and their associated/parent genome factory.
/// </summary>
public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory <NeatGenome> genomeFactory, List <NeatGenome> genomeList)
{
// Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference.
IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0);
ISpeciationStrategy <NeatGenome> speciationStrategy = new KMeansClusteringStrategy <NeatGenome>(distanceMetric);
// Create complexity regulation strategy.
IComplexityRegulationStrategy complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold);
// Create the evolution algorithm.
NeatEvolutionAlgorithm <NeatGenome> ea = new NeatEvolutionAlgorithm <NeatGenome>(_eaParams, speciationStrategy, complexityRegulationStrategy);
// Create IBlackBox evaluator.
PCGNeatEvaluator evaluator = new PCGNeatEvaluator(this);
// Create genome decoder.
IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder();
// Create a genome list evaluator. This packages up the genome decoder with the genome evaluator.
IGenomeListEvaluator <NeatGenome> innerEvaluator = new SerialGenomeListEvaluator <NeatGenome, IBlackBox>(genomeDecoder, evaluator);
// Wrap the list evaluator in a 'selective' evaulator that will only evaluate new genomes. That is, we skip re-evaluating any genomes
// that were in the population in previous generations (elite genomes). This is determiend by examining each genome's evaluation info object.
/*IGenomeListEvaluator<NeatGenome> selectiveEvaluator = new SelectiveGenomeListEvaluator<NeatGenome>(
* innerEvaluator,
* SelectiveGenomeListEvaluator<NeatGenome>.CreatePredicate_OnceOnly());
*/
// Initialize the evolution algorithm.
ea.Initialize(innerEvaluator, genomeFactory, genomeList);
// Finished. Return the evolution algorithm
return(ea);
}
public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory <NeatGenome> genomeFactory, List <NeatGenome> genomeList)
{
IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0);
ISpeciationStrategy <NeatGenome> speciationStrategy = new KMeansClusteringStrategy <NeatGenome>(distanceMetric);
IComplexityRegulationStrategy complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold);
NeatEvolutionAlgorithm <NeatGenome> ea = new NeatEvolutionAlgorithm <NeatGenome>(_eaParams, speciationStrategy, complexityRegulationStrategy);
// Create black box evaluator
SimpleEvaluator evaluator = new SimpleEvaluator(_optimizer);
IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder();
IGenomeListEvaluator <NeatGenome> innerEvaluator = new UnityParallelListEvaluator <NeatGenome, IBlackBox>(genomeDecoder, evaluator, _optimizer);
IGenomeListEvaluator <NeatGenome> selectiveEvaluator = new SelectiveGenomeListEvaluator <NeatGenome>(innerEvaluator,
SelectiveGenomeListEvaluator <NeatGenome> .CreatePredicate_OnceOnly());
//ea.Initialize(selectiveEvaluator, genomeFactory, genomeList);
//ea.Initialize(innerEvaluator, genomeFactory, genomeList);//this can be used if the currentGeneration does not need to be updated at the start of the training
ea.Initialize(innerEvaluator, genomeFactory, genomeList, true);
return(ea);
}
private NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(IGenomeListEvaluator <NeatGenome> evaluator, List <NeatGenome> list)
{
IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0);
ISpeciationStrategy <NeatGenome> speciationStrategy = new KMeansClusteringStrategy <NeatGenome>(distanceMetric);
IComplexityRegulationStrategy complexityRegulationStrategy = new DefaultComplexityRegulationStrategy(ComplexityCeilingType.Absolute, _complexityThreshold);
NeatEvolutionAlgorithm <NeatGenome> neatEvolutionAlgorithm = new NeatEvolutionAlgorithm <NeatGenome>(_eaParams, speciationStrategy, complexityRegulationStrategy);
var genomeFactory = new NeatGenomeFactory(_inputCount.Value, _outputCount.Value, _neatGenomeParams);
neatEvolutionAlgorithm.Initialize(evaluator, genomeFactory, list);
return(neatEvolutionAlgorithm);
}
private void Start()
{
int populationSize = 100;
NetworkActivationScheme activationScheme = NetworkActivationScheme.CreateAcyclicScheme();
NeatGenomeParameters neatParams = new NeatGenomeParameters();
neatParams.ActivationFn = TanH.__DefaultInstance;
neatParams.FeedforwardOnly = activationScheme.AcyclicNetwork;
IGenomeDecoder <NeatGenome, IBlackBox> neatDecoder = new NeatGenomeDecoder(activationScheme);
IGenomeFactory <NeatGenome> neatFactory = new NeatGenomeFactory(3, 3, neatParams);
List <NeatGenome> genomeList = neatFactory.CreateGenomeList(populationSize, 0);
ArenaEvaluator evaluator = GetComponent <ArenaEvaluator>();
evaluator.Initialize(neatDecoder);
IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0);
// Evolution parameters
NeatEvolutionAlgorithmParameters neatEvolutionParams = new NeatEvolutionAlgorithmParameters();
neatEvolutionParams.SpecieCount = 10;
ISpeciationStrategy <NeatGenome> speciationStrategy = new KMeansClusteringStrategy <NeatGenome>(distanceMetric);
IComplexityRegulationStrategy complexityRegulationStrategy = new DefaultComplexityRegulationStrategy(ComplexityCeilingType.Absolute, 10);
NeatEvolutionAlgorithm <NeatGenome> ea = GetComponent <UnityEvolutionAlgorithm>();
ea.Construct(neatEvolutionParams, speciationStrategy, complexityRegulationStrategy, new NullGenomeListEvaluator <NeatGenome, IBlackBox>());
ea.Initialize(evaluator, neatFactory, genomeList);
ea.UpdateScheme = new UpdateScheme(1); // This needs to be set AFTER Initialize is called
ea.PausedEvent += (sender, e) =>
{
//ea.StartContinue();
};
ea.GenerationEvent += (sender, gen) =>
{
Debug.Log($"Generation {gen}");
Debug.Log($"Highest fitness: {ea.CurrentChampGenome.EvaluationInfo.Fitness}");
nnMesh.GenerateMesh(ea.CurrentChampGenome);
ea.RequestPause();
StartCoroutine(PauseRoutine(ea));
};
ea.StartContinue();
}
public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory <NeatGenome> genomeFactory, List <NeatGenome> genomeList)
{
IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0);
ISpeciationStrategy <NeatGenome> speciationStrategy = new KMeansClusteringStrategy <NeatGenome>(distanceMetric);
IComplexityRegulationStrategy complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold);
BraidNeatEvolutionAlgorithm <NeatGenome> ea = new BraidNeatEvolutionAlgorithm <NeatGenome>(_eaParams, speciationStrategy, complexityRegulationStrategy);
// Create black box evaluator
BraidEvaluator evaluator = new BraidEvaluator(m_optimizer);
IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder();
IGenomeListEvaluator <NeatGenome> innerEvaluator = new BraidListEvaluator <NeatGenome, IBlackBox>(genomeDecoder, evaluator, m_optimizer);
ea.Initialize(innerEvaluator, genomeFactory, genomeList);
return(ea);
}
public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory <NeatGenome> genomeFactory, List <NeatGenome> genomeList)
{
// Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference.
IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0);
ISpeciationStrategy <NeatGenome> speciationStrategy =
new KMeansClusteringStrategy <NeatGenome>(distanceMetric);
// Create complexity regulation strategy.
IComplexityRegulationStrategy complexityRegulationStrategy =
ExperimentUtils.CreateComplexityRegulationStrategy("absolute", 10);
// Create the evolution algorithm.
var ea = new NeatEvolutionAlgorithm <NeatGenome>(
NeatEvolutionAlgorithmParameters,
speciationStrategy,
complexityRegulationStrategy);
// Create IBlackBox evaluator.
// var evaluator = new RemoteXorEvaluator();
var evaluator = new RemoteBatchXorEvaluator();
//LocalXorEvaluator evaluator = new LocalXorEvaluator();
// Create genome decoder.
IGenomeDecoder <NeatGenome, FastCyclicNetwork> genomeDecoder = _decoder;
// Create a genome list evaluator. This packages up the genome decoder with the genome evaluator.
IGenomeListEvaluator <NeatGenome> innerEvaluator = new BatchGenomeListEvaluator <NeatGenome, FastCyclicNetwork>(genomeDecoder, evaluator);
// Wrap the list evaluator in a 'selective' evaulator that will only evaluate new genomes. That is, we skip re-evaluating any genomes
// that were in the population in previous generations (elite genomes). This is determined by examining each genome's evaluation info object.
IGenomeListEvaluator <NeatGenome> selectiveEvaluator = new SelectiveGenomeListEvaluator <NeatGenome>(
innerEvaluator,
SelectiveGenomeListEvaluator <NeatGenome> .CreatePredicate_OnceOnly());
// Initialize the evolution algorithm.
ea.Initialize(selectiveEvaluator, genomeFactory, genomeList);
// Finished. Return the evolution algorithm
return(ea);
}
public NeatEvolutionAlgorithm<NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory<NeatGenome> genomeFactory, List<NeatGenome> genomeList)
{
// Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference.
IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0);
ISpeciationStrategy<NeatGenome> speciationStrategy =
new KMeansClusteringStrategy<NeatGenome>(distanceMetric);
// Create complexity regulation strategy.
IComplexityRegulationStrategy complexityRegulationStrategy =
ExperimentUtils.CreateComplexityRegulationStrategy("absolute", 10);
// Create the evolution algorithm.
var ea = new NeatEvolutionAlgorithm<NeatGenome>(
NeatEvolutionAlgorithmParameters,
speciationStrategy,
complexityRegulationStrategy);
// Create IBlackBox evaluator.
var evaluator = new RemoteXorEvaluator();
// Create genome decoder.
IGenomeDecoder<NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder();
// Create a genome list evaluator. This packages up the genome decoder with the genome evaluator.
IGenomeListEvaluator<NeatGenome> innerEvaluator = new SerialGenomeListEvaluator<NeatGenome, IBlackBox>(genomeDecoder, evaluator);
// Wrap the list evaluator in a 'selective' evaulator that will only evaluate new genomes. That is, we skip re-evaluating any genomes
// that were in the population in previous generations (elite genomes). This is determined by examining each genome's evaluation info object.
IGenomeListEvaluator<NeatGenome> selectiveEvaluator = new SelectiveGenomeListEvaluator<NeatGenome>(
innerEvaluator,
SelectiveGenomeListEvaluator<NeatGenome>.CreatePredicate_OnceOnly());
// Initialize the evolution algorithm.
ea.Initialize(selectiveEvaluator, genomeFactory, genomeList);
// Finished. Return the evolution algorithm
return ea;
}
public NeatEvolutionAlgorithm<NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory<NeatGenome> genomeFactory, List<NeatGenome> genomeList)
{
IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0);
ISpeciationStrategy<NeatGenome> speciationStrategy = new KMeansClusteringStrategy<NeatGenome>(distanceMetric);
IComplexityRegulationStrategy complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold);
NeatEvolutionAlgorithm<NeatGenome> ea = new NeatEvolutionAlgorithm<NeatGenome>(_eaParams, speciationStrategy, complexityRegulationStrategy);
// Create black box evaluator
SimpleEvaluator evaluator = new SimpleEvaluator(_optimizer);
IGenomeDecoder<NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder();
IGenomeListEvaluator<NeatGenome> innerEvaluator = new UnityParallelListEvaluator<NeatGenome, IBlackBox>(genomeDecoder, evaluator, _optimizer);
IGenomeListEvaluator<NeatGenome> selectiveEvaluator = new SelectiveGenomeListEvaluator<NeatGenome>(innerEvaluator,
SelectiveGenomeListEvaluator<NeatGenome>.CreatePredicate_OnceOnly());
//ea.Initialize(selectiveEvaluator, genomeFactory, genomeList);
ea.Initialize(innerEvaluator, genomeFactory, genomeList);
return ea;
}
