public IEnumerator Start()
{
Debug.Assert(_populationSize > 5);
Debug.Log($"Main thread is {Thread.CurrentThread.ManagedThreadId}");
Application.runInBackground = true;
_activationScheme = NetworkActivationScheme.CreateCyclicFixedTimestepsScheme(2, true);
_eaParams = new NeatEvolutionAlgorithmParameters();
_eaParams.ElitismProportion = _elitismProportion;
_eaParams.SpecieCount = _specieCount;
_neatGenomeParams = new NeatGenomeParameters();
_neatGenomeParams.AddConnectionMutationProbability = _AddConnectionMutationProbability;
_neatGenomeParams.DeleteConnectionMutationProbability = _DeleteConnectionMutationProbability;
_neatGenomeParams.AddNodeMutationProbability = _AddNodeMutationProbability;
_neatGenomeParams.ConnectionWeightMutationProbability = _ConnectionWeightMutationProbability;
_neatGenomeParams.InitialInterconnectionsProportion = _InitialInterconnectionsProportion;
_neatGenomeParams.FeedforwardOnly = _activationScheme.AcyclicNetwork;
Debug.Log("Creating evaluator");
yield return(new WaitForSeconds(0.1f));
_evaluator = CreateEvaluator();
Debug.Log("Creating algorithm");
yield return(new WaitForSeconds(0.1f));
_ea = CreateEvolutionAlgorithm(_evaluator, _populationSize);
_ea.UpdateEvent += _ea_UpdateEvent;
}
/// <summary>
/// Create a network activation scheme from the scheme setting in the provided config XML.
/// </summary>
/// <returns></returns>
public static NetworkActivationScheme CreateActivationScheme(XmlElement xmlConfig, string activationElemName)
{
// Get root activation element.
XmlNodeList nodeList = xmlConfig.GetElementsByTagName(activationElemName, "");
if (nodeList.Count != 1)
{
throw new ArgumentException("Missing or invalid activation XML config setting.");
}
XmlElement xmlActivation = nodeList[0] as XmlElement;
string schemeStr = XmlUtils.TryGetValueAsString(xmlActivation, "Scheme");
switch (schemeStr)
{
case "Acyclic":
return(NetworkActivationScheme.CreateAcyclicScheme());
case "CyclicFixedIters":
int iters = XmlUtils.GetValueAsInt(xmlActivation, "Iters");
return(NetworkActivationScheme.CreateCyclicFixedTimestepsScheme(iters));
case "CyclicRelax":
double deltaThreshold = XmlUtils.GetValueAsInt(xmlActivation, "Threshold");
int maxIters = XmlUtils.GetValueAsInt(xmlActivation, "MaxIters");
return(NetworkActivationScheme.CreateCyclicRelaxingActivationScheme(deltaThreshold, maxIters));
}
throw new ArgumentException(string.Format("Invalid or missing ActivationScheme XML config setting [{0}]", schemeStr));
}
/// <summary>
/// This is inspired by ExperimentUtils.CreateActivationScheme, but can't be put there, because NeatConfigInfo_Activation isn't
/// defined that low
/// </summary>
private static NetworkActivationScheme GetActivationScheme(ExperimentInitArgs_Activation scheme)
{
if (scheme == null)
{
throw new ArgumentNullException("scheme");
}
else if (scheme is ExperimentInitArgs_Activation_Acyclic)
{
return(NetworkActivationScheme.CreateAcyclicScheme());
}
else if (scheme is ExperimentInitArgs_Activation_CyclicFixedTimesteps)
{
ExperimentInitArgs_Activation_CyclicFixedTimesteps cast = (ExperimentInitArgs_Activation_CyclicFixedTimesteps)scheme;
return(NetworkActivationScheme.CreateCyclicFixedTimestepsScheme(cast.TimestepsPerActivation, cast.FastFlag));
}
else if (scheme is ExperimentInitArgs_Activation_CyclicRelaxing)
{
ExperimentInitArgs_Activation_CyclicRelaxing cast = (ExperimentInitArgs_Activation_CyclicRelaxing)scheme;
return(NetworkActivationScheme.CreateCyclicRelaxingActivationScheme(cast.SignalDeltaThreshold, cast.MaxTimesteps, cast.FastFlag));
}
else
{
throw new ArgumentException("Unknown scheme type: " + scheme.GetType().ToString());
}
}
private static void Play()
{
var neatGenomeFactory = new NeatGenomeFactory(NeatConsts.ViewX * NeatConsts.ViewY * NeatConsts.typeIds.Count, 1);
var activationScheme = NetworkActivationScheme.CreateCyclicFixedTimestepsScheme(1);
var genomeDecoder = new NeatGenomeDecoder(activationScheme);
XmlReader xr;
while (true)
{
try
{
xr = XmlReader.Create($"{NeatConsts.experimentName}/best.xml");
break;
}
catch (Exception)
{
}
}
var genome = NeatGenomeXmlIO.ReadCompleteGenomeList(xr, false, neatGenomeFactory)[0];
var phenome = genomeDecoder.Decode(genome);
using var game = new Game(true);
var brain = new BlackBoxBrain(phenome, game);
while (!game.hasEnded)
{
brain.Step();
Thread.Sleep(200);
}
}
NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(bool load)
{
// Create a genome2 factory with our neat genome2 parameters object and the appropriate number of input and output neuron genes.
var genomeFactory = new NeatGenomeFactory(TetrisEvaluator.NumInputs, TetrisEvaluator.NumOutputs);
// Create an initial population of randomly generated genomes.
List <NeatGenome> genomeList = null;
if (load)
{
try
{
using (var reader = XmlReader.Create("SavedProgress.xml"))
genomeList = NeatGenomeXmlIO.ReadCompleteGenomeList(reader, true, genomeFactory);
Console.WriteLine("Loaded network!");
}
catch
{
load = false;
}
}
if (!load)
{
genomeList = genomeFactory.CreateGenomeList(150, 0);
}
var parallelOpts = new ParallelOptions()
{
MaxDegreeOfParallelism = -1
};
// Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference.
var distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0);
var speciationStrategy = new ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetric, parallelOpts);
// Create the evolution algorithm.
var ea = new NeatEvolutionAlgorithm <NeatGenome>(new NeatEvolutionAlgorithmParameters {
SpecieCount = 10
}, speciationStrategy, new DefaultComplexityRegulationStrategy(ComplexityCeilingType.Absolute, 50));
// Create genome2 decoder.
var genomeDecoder = new NeatGenomeDecoder(NetworkActivationScheme.CreateCyclicFixedTimestepsScheme(2));
// Create a genome2 list evaluator. This packages up the genome2 decoder with the genome2 evaluator.
IGenomeListEvaluator <NeatGenome> genomeListEvaluator = new ParallelGenomeListEvaluator <NeatGenome, IBlackBox>(genomeDecoder, tetrisEvaluator, parallelOpts);
// 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 genome2's evaluation info object.
//if (!EvaluateParents)
//genomeListEvaluator = new SelectiveGenomeListEvaluator<NeatGenome>(genomeListEvaluator, SelectiveGenomeListEvaluator<NeatGenome>.CreatePredicate_OnceOnly());
ea.UpdateEvent += Ea_UpdateEvent;
// Initialize the evolution algorithm.
ea.Initialize(genomeListEvaluator, genomeFactory, genomeList);
// Finished. Return the evolution algorithm
return(ea);
}
public void Initialize(string name, XmlElement xmlConfig)
{
NeatEvolutionAlgorithmParameters = new NeatEvolutionAlgorithmParameters();
NeatEvolutionAlgorithmParameters.SpecieCount = 10;
// The NeatGenomeParameters object is passed to the NeatGenomeFactory.
// The NeatGenomeFactory creates a NeatGenome (which is an INetworkDefinition).
// The NeatGenome is constructed using the NeatGenomeParameters.
// For example, the NeatGenomeParameters define what activation function to use.
NeatGenomeParameters = new NeatGenomeParameters();
// Create fast cyclic activation scheme with 3 evaluations for convergence
_activationScheme = NetworkActivationScheme.CreateCyclicFixedTimestepsScheme(3, true);
}
public BattleExperiment()
{
_activationScheme = NetworkActivationScheme.CreateCyclicFixedTimestepsScheme(2, true);
_eaParams = new NeatEvolutionAlgorithmParameters();
_neatGenomeParams = new NeatGenomeParameters();
SharpNeat.Network.SReLU func = (SharpNeat.Network.SReLU) new SharpNeat.Network.SReLU();
func.SetParameters(-0.8, 0.8, 0.05);
_neatGenomeParams.ActivationFn = func;
_neatGenomeParams.AddConnectionMutationProbability = 0.7;
_neatGenomeParams.AddNodeMutationProbability = 0.2;
_neatGenomeParams.DeleteConnectionMutationProbability = 0.4;
_neatGenomeParams.ConnectionWeightMutationProbability = 0.94;
_neatGenomeParams.InitialInterconnectionsProportion = 0;
_neatGenomeParams.FeedforwardOnly = _activationScheme.AcyclicNetwork;
}
/// <summary>
/// Creates a cyclic or acyclic activation scheme for the network.
/// </summary>
private NetworkActivationScheme CreateActivationScheme(string activationScheme, int?activationIters,
double?activationDeltaThreshold)
{
switch (activationScheme)
{
case "Acyclic":
return(NetworkActivationScheme.CreateAcyclicScheme());
case "CyclicFixedIters":
if (activationIters == null)
{
throw new ArgumentException(
"Maximum iterations must be specified for cyclic activation scheme");
}
var iters = activationIters.Value;
return(NetworkActivationScheme.CreateCyclicFixedTimestepsScheme(iters));
case "CyclicRelax":
if (activationIters == null)
{
throw new ArgumentException(
"Maximum iterations must be specified for cyclic relaxation scheme");
}
if (activationDeltaThreshold == null)
{
throw new ArgumentException("Delta threshold must be specified for cyclic relaxation scheme");
}
var deltaThreshold = activationDeltaThreshold.Value;
var maxIters = activationIters.Value;
return(NetworkActivationScheme.CreateCyclicRelaxingActivationScheme(deltaThreshold, maxIters));
}
throw new ArgumentException($"Invalid ActivationScheme setting [{activationScheme}]");
}
private static void Train()
{
File.WriteAllText($"{NeatConsts.experimentName}/fitness.csv", "generation,firness\n");
var neatGenomeFactory = new NeatGenomeFactory(NeatConsts.ViewX * NeatConsts.ViewY * NeatConsts.typeIds.Count, 1);
var genomeList = neatGenomeFactory.CreateGenomeList(NeatConsts.SpecCount, 0);
var eaParams = new NeatEvolutionAlgorithmParameters
{
SpecieCount = NeatConsts.SpecCount
};
//var distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0);
var distanceMetric = new ManhattanDistanceMetric();
var parallelOptions = new ParallelOptions();
var speciationStrategy = new ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetric, parallelOptions);
//var speciationStrategy = new KMeansClusteringStrategy<NeatGenome>(distanceMetric);
//var speciationStrategy = new RandomClusteringStrategy<NeatGenome>();
var complexityRegulationStrategy = new NullComplexityRegulationStrategy();
//var complexityRegulationStrategy = new DefaultComplexityRegulationStrategy(ComplexityCeilingType.Relative, 0.50);
var ea = new NeatEvolutionAlgorithm <NeatGenome>(eaParams, speciationStrategy, complexityRegulationStrategy);
var activationScheme = NetworkActivationScheme.CreateCyclicFixedTimestepsScheme(1);
var genomeDecoder = new NeatGenomeDecoder(activationScheme);
var phenomeEvaluator = new GameEvaluator();
var genomeListEvaluator = new ParallelGenomeListEvaluator <NeatGenome, IBlackBox>(genomeDecoder, phenomeEvaluator, parallelOptions);
ea.Initialize(genomeListEvaluator, neatGenomeFactory, genomeList);
ea.UpdateScheme = new UpdateScheme(NeatConsts.LogRate);
ea.StartContinue();
ea.UpdateEvent += Ea_UpdateEvent;
while (ea.RunState != RunState.Paused)
{
}
ea.Stop();
}