public void Initialize()
{
/*** Initialize experiment ***/
experiment = new PCGNeatExperiment() as INeatExperiment;
// Null because not reading settings from xmlFile
experiment.Initialize("PCG Conetent EA", null);
/*** Randomly generate population ***/
// Set initial settings
// ? means it is nullable
int?popSize = experiment.DefaultPopulationSize;
// Create a genome factory appropriate for the experiment.
IGenomeFactory <NeatGenome> genomeFactory = experiment.CreateGenomeFactory();
// Create an initial population of randomly generated genomes.
// 0u is a struct for a 32 bit unsigned integer
List <NeatGenome> genomeList = genomeFactory.CreateGenomeList(popSize.Value, 0u);
// Check number of species is <= the number of the genomes.
if (genomeList.Count < experiment.NeatEvolutionAlgorithmParameters.SpecieCount)
{
Debug.Log("Genome count must be >= specie count. Genomes=" + genomeList.Count
+ " Species=" + experiment.NeatEvolutionAlgorithmParameters.SpecieCount);
return;
}
/*** Create the algorithm interface ***/
contentEA = experiment.CreateEvolutionAlgorithm(genomeFactory, genomeList);
}
/// <summary>
/// Writes a list of genomes to the save file fitting the experiment name and the ExperimentFileType.
/// </summary>
private static bool WriteGenomes(INeatExperiment experiment, IList <NeatGenome> genomeList, ExperimentFileType fileType)
{
XmlWriterSettings _xwSettings = new XmlWriterSettings();
_xwSettings.Indent = true;
string filePath = GetSaveFilePath(experiment.Name, fileType);
DirectoryInfo dirInf = new DirectoryInfo(Application.persistentDataPath);
if (!dirInf.Exists)
{
Debug.Log("ExperimentIO - Creating subdirectory");
dirInf.Create();
}
try
{
using (XmlWriter xw = XmlWriter.Create(filePath, _xwSettings))
{
NeatGenomeXmlIO.WriteComplete(xw, genomeList, false);
Debug.Log("Successfully saved the genomes of the '" + fileType.ToString() + "' for the experiment '" + experiment.Name + "' to the location:\n" + filePath);
}
}
catch (Exception e1)
{
Debug.Log("Error saving the genomes of the '" + fileType.ToString() + "' for the experiment '" + experiment.Name + "' to the location:\n" + filePath);
return(false);
}
return(true);
}
// Initialize with pre-existing xml data
public void Initialize(string xmlData)
{
/*** Initialize experiment ***/
experiment = new PCGNeatExperiment() as INeatExperiment;
// Null because not reading settings from xmlFile
experiment.Initialize("PCG Conetent EA", null);
/*** Load population of genomes from xml string ***/
List <NeatGenome> genomeList;
using (XmlReader xr = XmlReader.Create(new StringReader(xmlData)))
{
genomeList = experiment.LoadPopulation(xr);
}
if (genomeList.Count == 0)
{
Debug.LogError("No genomes loaded from XML data from network. Check data is being read correctly.");
return;
}
else
{
Debug.Log("Loaded " + genomeList.Count + " Genomes");
}
/*** Create the algorithm interface ***/
contentEA = experiment.CreateEvolutionAlgorithm(genomeList[0].GenomeFactory, genomeList);
}
/// <summary>
/// Loads a list of genomes from the save file fitting the experiment name and the ExperimentFileType.
/// </summary>
private static List <NeatGenome> ReadGenomes(INeatExperiment experiment, ExperimentFileType fileType, bool createNewGenesIfNotLoadable = true)
{
List <NeatGenome> genomeList = null;
NeatGenomeFactory genomeFactory = (NeatGenomeFactory)experiment.CreateGenomeFactory();
string filePath = GetSaveFilePath(experiment.Name, fileType);
try
{
using (XmlReader xr = XmlReader.Create(filePath))
{
genomeList = NeatGenomeXmlIO.ReadCompleteGenomeList(xr, false, genomeFactory);
if (genomeList != null && genomeList.Count > 0)
{
Utility.Log("Successfully loaded the genomes of the '" + fileType.ToString() + "' for the experiment '" + experiment.Name + "' from the location:\n" + filePath);
}
}
}
catch (Exception e1)
{
Utility.Log("Error loading genome from file, could not find the file at: " + filePath + "\n" + e1.Message);
if (createNewGenesIfNotLoadable)
{
genomeList = genomeFactory.CreateGenomeList(experiment.DefaultPopulationSize, 0);
}
}
return(genomeList);
}
/// <summary>
/// Deletes all savefiles of the specified experiment, which is the population file and the champion file (best genome).
/// </summary>
public static void DeleteAllSaveFiles(INeatExperiment experiment)
{
File.Delete(GetSaveFilePath(experiment.Name, ExperimentFileType.Champion));
File.Delete(GetSaveFilePath(experiment.Name, ExperimentFileType.Population));
Debug.Log("ExperimentIO - Deleted all savefiles.");
}
// Initialize with pre-existing xml data
public void Initialize(string xmlData, PCGSharpHighLevelFeatures originalFeatures)
{
/*** Initialize experiment ***/
experiment = new CPPNRepairExperiment() as INeatExperiment;
// Null because not reading settings from xmlFile
experiment.Initialize("PCG Conetent EA", null);
/*** Load population of genomes from xml string ***/
List <NeatGenome> genomeList;
using (XmlReader xr = XmlReader.Create(new StringReader(xmlData)))
{
genomeList = experiment.LoadPopulation(xr);
}
if (genomeList.Count == 0)
{
Debug.LogError("No genomes loaded from XML data from network. Check data is being read correctly.");
return;
}
else
{
Debug.Log("Loaded " + genomeList.Count + " Genomes");
}
Debug.Log(".........Population loaded");
((CPPNRepairExperiment)experiment).SetOriginalFeatures(originalFeatures);
Debug.Log("........Original features added to experiment");
/*** Create the algorithm interface ***/
contentEA = experiment.CreateEvolutionAlgorithm(genomeList[0].GenomeFactory, genomeList);
Debug.Log("........Content EA created");
}
private void btnSearchStart_Click(object sender, EventArgs e)
{
if (_eaRunner is not null)
{ // Resume existing EA & update GUI state.
_eaRunner.StartOrResume();
UpdateUIState();
return;
}
// Get the current neat experiment, with parameters set from the UI.
INeatExperiment <double> neatExperiment = GetNeatExperiment();
// Create evolution algorithm and runner.
NeatEvolutionAlgorithm <double> ea = NeatUtils.CreateNeatEvolutionAlgorithm(neatExperiment, _neatPop);
ea.Initialise();
_eaRunner = new EvolutionAlgorithmRunner(ea, UpdateScheme.CreateTimeSpanUpdateScheme(TimeSpan.FromSeconds(1)));
// Attach event listeners.
_eaRunner.UpdateEvent += _eaRunner_UpdateEvent;
// Start the algorithm & update GUI state.
_eaRunner.StartOrResume();
UpdateUIState();
}
public GenomeIo(INeatExperiment neatExperiment)
{
_neatExperiment = neatExperiment;
_championGenomeMemoryStream = new MemoryStream();
_xmlWriterSettings = new XmlWriterSettings { Indent = true, Encoding = Encoding.UTF8 };
}
/// <summary>
/// Create a new instance of <see cref="NeatEvolutionAlgorithm{T}"/> for the given neat experiment, and neat population.
/// </summary>
/// <param name="neatExperiment">A neat experiment instance; this conveys everything required to create a new evolution algorithm instance that is ready to be run.</param>
/// <param name="neatPop">A pre constructed/loaded neat population; this must be compatible with the provided neat experiment, otherwise an exception will be thrown.</param>
/// <returns>A new instance of <see cref="NeatEvolutionAlgorithm{T}"/>.</returns>
public static NeatEvolutionAlgorithm <double> CreateNeatEvolutionAlgorithm(
INeatExperiment <double> neatExperiment,
NeatPopulation <double> neatPop)
{
// Validate MetaNeatGenome and NeatExperiment are compatible; normally the former should have been created based on the latter, but this is not enforced.
MetaNeatGenome <double> metaNeatGenome = neatPop.MetaNeatGenome;
ValidateCompatible(neatExperiment, metaNeatGenome);
// Create a genomeList evaluator based on the experiment's configuration settings.
var genomeListEvaluator = CreateGenomeListEvaluator(neatExperiment);
// Create a speciation strategy based on the experiment's configuration settings.
var speciationStrategy = CreateSpeciationStrategy(neatExperiment);
// Create an instance of the default connection weight mutation scheme.
var weightMutationScheme = WeightMutationSchemeFactory.CreateDefaultScheme(neatExperiment.ConnectionWeightScale);
// Pull all of the parts together into an evolution algorithm instance.
var ea = new NeatEvolutionAlgorithm <double>(
neatExperiment.NeatEvolutionAlgorithmSettings,
genomeListEvaluator,
speciationStrategy,
neatPop,
neatExperiment.ComplexityRegulationStrategy,
neatExperiment.ReproductionAsexualSettings,
neatExperiment.ReproductionSexualSettings,
weightMutationScheme);
return(ea);
}
/// <summary>
/// Create a new instance of <see cref="NeatEvolutionAlgorithm{T}"/> for the given neat experiment.
/// </summary>
/// <param name="neatExperiment">A neat experiment instance; this conveys everything required to create a new evolution algorithm instance that is ready to be run.</param>
/// <returns>A new instance of <see cref="NeatEvolutionAlgorithm{T}"/>.</returns>
public static NeatEvolutionAlgorithm <double> CreateNeatEvolutionAlgorithm(
INeatExperiment <double> neatExperiment)
{
// Create a genomeList evaluator based on the experiment's configuration settings.
var genomeListEvaluator = CreateGenomeListEvaluator(neatExperiment);
// Create a MetaNeatGenome.
var metaNeatGenome = CreateMetaNeatGenome(neatExperiment);
// Create an initial population of genomes.
NeatPopulation <double> neatPop = NeatPopulationFactory <double> .CreatePopulation(
metaNeatGenome,
connectionsProportion : neatExperiment.InitialInterconnectionsProportion,
popSize : neatExperiment.PopulationSize);
// Create a speciation strategy based on the experiment's configuration settings.
var speciationStrategy = CreateSpeciationStrategy(neatExperiment);
// Create an instance of the default connection weight mutation scheme.
var weightMutationScheme = WeightMutationSchemeFactory.CreateDefaultScheme(neatExperiment.ConnectionWeightScale);
// Pull all of the parts together into an evolution algorithm instance.
var ea = new NeatEvolutionAlgorithm <double>(
neatExperiment.NeatEvolutionAlgorithmSettings,
genomeListEvaluator,
speciationStrategy,
neatPop,
neatExperiment.ComplexityRegulationStrategy,
neatExperiment.ReproductionAsexualSettings,
neatExperiment.ReproductionSexualSettings,
weightMutationScheme);
return(ea);
}
public static IBlackBox LoadBrain(string filePath, INeatExperiment experiment)
{
NeatGenome genome = null;
// Try to load the genome from the XML document.
try
{
using (XmlReader xr = XmlReader.Create(filePath))
genome = NeatGenomeXmlIO.ReadCompleteGenomeList(xr, false, (NeatGenomeFactory)experiment.CreateGenomeFactory())[0];
}
catch (Exception e1)
{
print(filePath + " Error loading genome from file!\nLoading aborted.\n"
+ e1.Message + "\nJoe: " + filePath);
return(null);
}
// Get a genome decoder that can convert genomes to phenomes.
var genomeDecoder = experiment.CreateGenomeDecoder();
// Decode the genome into a phenome (neural network).
var phenome = genomeDecoder.Decode(genome);
return(phenome);
}
private static void ReadNeatReproductionSexualSettings(
INeatExperiment <T> target, JsonElement jelem)
{
if (jelem.TryGetProperty("reproductionSexualSettings", out JsonElement settingsElem))
{
NeatReproductionSexualSettingsJsonReader.Read(target.ReproductionSexualSettings, settingsElem);
}
}
private static void ReadNeatEvolutionAlgorithmSettings(
INeatExperiment <T> target, JsonElement jelem)
{
if (jelem.TryGetProperty("evolutionAlgorithmSettings", out JsonElement settingsElem))
{
NeatEvolutionAlgorithmSettingsJsonReader.Read(target.NeatEvolutionAlgorithmSettings, settingsElem);
}
}
private void GetSettingsFromUI(INeatExperiment <double> experiment)
{
GetSettingsFromUI(experiment.NeatEvolutionAlgorithmSettings);
GetSettingsFromUI(experiment.ReproductionAsexualSettings);
experiment.PopulationSize = GetValue(txtPopulationSize, experiment.PopulationSize);
experiment.InitialInterconnectionsProportion = GetValue(txtInitialInterconnectionsProportion, experiment.InitialInterconnectionsProportion);
}
public static List <NeatGenome> ReadChampions(INeatExperiment experiment)
{
return(ReadChampionGenomes(experiment, ExperimentFileType.Population, false));
// if (championPop == null || championPop.Count == 0)
// return null;
// return championPop[0];
}
private static void ReadComplexityRegulationStrategy(
INeatExperiment <T> target, JsonElement jelem)
{
if (jelem.TryGetProperty("complexityRegulationStrategy", out JsonElement settingsElem))
{
target.ComplexityRegulationStrategy = ComplexityRegulationStrategyJsonReader.Read(settingsElem);
}
}
public EvolutionAlgorithmHostGenerational(
INeatExperiment <double> experiment,
int stopGenerationCount)
{
_experiment = experiment;
_stopGenerationCount = stopGenerationCount;
_stopwatch = new Stopwatch();
}
static void Main(string[] args)
{
// Intercept termination of the console app, to flush and close the output file stream
// (apparently the 'finally' block below is not executed if the app is terminated with Ctrl-C).
Console.CancelKeyPress += delegate
{
if (__streamWriter is not null)
{
__streamWriter.Close();
}
};
// Read command line arguments.
StopCondition?stopCond = ArgUtils.ReadArgs(args, out string?experimentId, out string?filename);
if (stopCond is null || experimentId is null || filename is null)
{
return;
}
// Initialise log4net (log to console).
var logRepository = LogManager.GetRepository(Assembly.GetEntryAssembly());
XmlConfigurator.Configure(logRepository, new FileInfo("log4net.properties"));
// Create and configure a NEAT experiment instance.
INeatExperiment <double>?experiment = InitExperiment(experimentId);
if (experiment is null)
{
return;
}
// Create an evolution algorithm host.
IEvolutionAlgorithmHost eaHost = CreateEvolutionAlgorithmHost(experiment, stopCond);
// Open and initialise the output file.
__streamWriter = InitOutputFile(filename);
try
{
// Run the main efficacy sampling loop until the process is terminated.
for (;;)
{
Sample s = eaHost.Sample();
__streamWriter.WriteLine($"{s.ElapsedTimeSecs},{s.GenerationCount},{s.BestFitness:0.#####},{s.MeanFitness:0.#####},{s.MaxComplexity:0.#####},{s.MeanComplexity:0.#####},{s.EvaluationCount}");
__streamWriter.Flush();
}
}
finally
{
if (__streamWriter is not null)
{
__streamWriter.Close();
}
}
}
private static IEvolutionAlgorithmHost CreateEvolutionAlgorithmHost(
INeatExperiment <double> experiment,
StopCondition stopCond)
{
return(stopCond.StopConditionType switch
{
StopConditionType.ElapsedClockTime => new EvolutionAlgorithmHostClockTime(experiment, stopCond.Value),
StopConditionType.GenerationCount => new EvolutionAlgorithmHostGenerational(experiment, stopCond.Value),
_ => throw new ArgumentException(nameof(stopCond)),
});
private static void ReadNeatReproductionAsexualSettings(
INeatExperiment <T> target, JObject jobj)
{
JObject settingsJobj = (JObject)jobj["reproductionAsexualSettings"];
if (settingsJobj != null)
{
NeatReproductionAsexualSettingsJsonReader.Read(target.ReproductionAsexualSettings, settingsJobj);
}
}
private static void ReadNeatEvolutionAlgorithmSettings(
INeatExperiment <T> target, JObject jobj)
{
JObject settingsJobj = (JObject)jobj["evolutionAlgorithmSettings"];
if (settingsJobj != null)
{
NeatEvolutionAlgorithmSettingsJsonReader.Read(target.NeatEvolutionAlgorithmSettings, settingsJobj);
}
}
private static void ReadComplexityRegulationStrategy(
INeatExperiment <T> target, JObject jobj)
{
JObject settingsJobj = (JObject)jobj["complexityRegulationStrategy"];
if (settingsJobj != null)
{
target.ComplexityRegulationStrategy = ComplexityRegulationStrategyJsonReader.Read(settingsJobj);
}
}
/// <summary>
/// Loads the saved champion genome from the champion safe file of the specified experiment (by default: myexperimentname.champ.xml).
/// If the file does not exist, then null is returned.
/// </summary>
public static NeatGenome ReadChampion(INeatExperiment experiment)
{
List <NeatGenome> championPop = ReadGenomes(experiment, ExperimentFileType.Champion, false);
if (championPop == null || championPop.Count == 0)
{
return(null);
}
return(championPop[0]);
}
private static INeatExperiment <double> InitExperiment_BinaryElevenMultiplexer()
{
// Read experiment json config from file.
// Note. We read the entire contents into a string; we don't ever expect to see large json files here, so this fine.
string jsonStr = File.ReadAllText("config/binary-eleven-multiplexer.config.json");
// Create an instance of INeatExperiment for the binary 11-multiplexer task, configured using the supplied json config.
var experimentFactory = new BinaryElevenMultiplexerExperimentFactory();
INeatExperiment <double> neatExperiment = experimentFactory.CreateExperiment(jsonStr);
return(neatExperiment);
}
private INeatExperiment <double> GetNeatExperiment()
{
// Create a new experiment instance if one has not already been created.
if (_neatExperiment is null)
{
_neatExperiment = CreateAndConfigureExperiment((ExperimentInfo)cmbExperiments.SelectedItem);
}
// Read settings from the UI into the experiment instance, and return.
GetSettingsFromUI(_neatExperiment);
return(_neatExperiment);
}
private static INeatExperiment <double> InitExperiment_Sinewave()
{
// Read experiment json config from file.
// Note. We read the entire contents into a string; we don't ever expect to see large json files here, so this fine.
string jsonStr = File.ReadAllText("config/generative-sinewave.config.json");
// Create an instance of INeatExperiment for the generative sinewave task, configured using the supplied json config.
var experimentFactory = new GenerativeFnRegressionExperimentFactory();
INeatExperiment <double> neatExperiment = experimentFactory.CreateExperiment(jsonStr);
return(neatExperiment);
}
private static IGenomeDecoder <NeatGenome <double>, IBlackBox <double> > CreateGenomeDecoder(
INeatExperiment <double> neatExperiment)
{
if (neatExperiment.IsAcyclic)
{
return(NeatGenomeDecoderFactory.CreateGenomeDecoderAcyclic(
neatExperiment.EnableHardwareAcceleratedNeuralNets));
}
return(NeatGenomeDecoderFactory.CreateGenomeDecoderCyclic(
neatExperiment.CyclesPerActivation,
neatExperiment.EnableHardwareAcceleratedNeuralNets));
}
/// <summary>
/// Read json from a file into a target instance of <see cref="NeatExperiment{T}"/>.
/// Settings that are present are read and set on the target settings object; all other settings
/// remain unchanged on the target object.
/// </summary>
/// <param name="target">The target settings object to store the read values on.</param>
/// <param name="filename">The filename of the json to read from.</param>
public static void ReadFile(
INeatExperiment <T> target, string filename)
{
// Read the entire contents into a string; we don't ever expect to see large json files here, so this fine.
string jsonStr = File.ReadAllText(filename);
// TODO: Switch to System.Text.Json.JsonDocument.
// Parse the json string.
var jobj = JObject.Parse(jsonStr);
// Read the parsed json into our target experiment object.
Read(target, jobj);
}
private void btnCreateRandomPop_Click(object sender, EventArgs e)
{
INeatExperiment <double> neatExperiment = GetNeatExperiment();
MetaNeatGenome <double> metaNeatGenome = NeatUtils.CreateMetaNeatGenome(neatExperiment);
// Create an initial population of genomes.
_neatPop = NeatPopulationFactory <double> .CreatePopulation(
metaNeatGenome,
connectionsProportion : neatExperiment.InitialInterconnectionsProportion,
popSize : neatExperiment.PopulationSize);
// Update UI.
UpdateUIState();
}
/// <summary>
/// Create a <see cref="MetaNeatGenome{T}"/> based on the parameters supplied by an <see cref="INeatExperiment{T}"/>.
/// </summary>
/// <param name="neatExperiment">The neat experiment.</param>
/// <returns>A new instance of <see cref="MetaNeatGenome{T}"/>.</returns>
public static MetaNeatGenome <double> CreateMetaNeatGenome(INeatExperiment <double> neatExperiment)
{
// Resolve the configured activation function name to an activation function instance.
var actFnFactory = new DefaultActivationFunctionFactory <double>(neatExperiment.EnableHardwareAcceleratedActivationFunctions);
var activationFn = actFnFactory.GetActivationFunction(neatExperiment.ActivationFnName);
var metaNeatGenome = new MetaNeatGenome <double>(
inputNodeCount: neatExperiment.EvaluationScheme.InputCount,
outputNodeCount: neatExperiment.EvaluationScheme.OutputCount,
isAcyclic: neatExperiment.IsAcyclic,
activationFn: activationFn,
connectionWeightScale: neatExperiment.ConnectionWeightScale);
return(metaNeatGenome);
}
private void cmbExperiments_SelectedIndexChanged(object sender, EventArgs e)
{
// Clear any existing references, as these are specific to each experiment.
_neatExperiment = null;
_experimentUI = null;
// Close the genome form if it is open, as the content of this form is specific to each experiment.
GenomeForm bestGenomeForm = _bestGenomeForm;
if (bestGenomeForm is not null)
{
// Note. This will trigger the FormClosed event which will do further clean-up; Close() will also Dispose() the form.
bestGenomeForm.Close();
}
}
// Initialize with pre-existing xml data
public void Initialize(string xmlData)
{
/*** Initialize experiment ***/
experiment = new PCGNeatExperiment() as INeatExperiment;
// Null because not reading settings from xmlFile
experiment.Initialize("PCG Conetent EA",null);
/*** Load population of genomes from xml string ***/
List<NeatGenome> genomeList;
using(XmlReader xr = XmlReader.Create(new StringReader(xmlData)))
{
genomeList = experiment.LoadPopulation(xr);
}
if(genomeList.Count == 0) {
Debug.LogError("No genomes loaded from XML data from network. Check data is being read correctly.");
return;
}
else
Debug.Log("Loaded " + genomeList.Count + " Genomes");
/*** Create the algorithm interface ***/
contentEA = experiment.CreateEvolutionAlgorithm(genomeList[0].GenomeFactory, genomeList);
}
public void Initialize()
{
/*** Initialize experiment ***/
experiment = new PCGNeatExperiment() as INeatExperiment;
// Null because not reading settings from xmlFile
experiment.Initialize("PCG Conetent EA",null);
/*** Randomly generate population ***/
// Set initial settings
// ? means it is nullable
int? popSize = experiment.DefaultPopulationSize;
// Create a genome factory appropriate for the experiment.
IGenomeFactory<NeatGenome> genomeFactory = experiment.CreateGenomeFactory();
// Create an initial population of randomly generated genomes.
// 0u is a struct for a 32 bit unsigned integer
List<NeatGenome> genomeList = genomeFactory.CreateGenomeList(popSize.Value, 0u);
// Check number of species is <= the number of the genomes.
if (genomeList.Count < experiment.NeatEvolutionAlgorithmParameters.SpecieCount)
{
Debug.Log("Genome count must be >= specie count. Genomes=" + genomeList.Count
+ " Species=" + experiment.NeatEvolutionAlgorithmParameters.SpecieCount);
return;
}
/*** Create the algorithm interface ***/
contentEA = experiment.CreateEvolutionAlgorithm(genomeFactory, genomeList);
}
//public static IBlackBox LoadBrain(string filePath)
//{
// OptimizationExperiment experiment = new OptimizationExperiment();
// XmlDocument xmlConfig = new XmlDocument();
// TextAsset textAsset = (TextAsset)Resources.Load("phototaxis.config");
// // xmlConfig.Load(OptimizerParameters.ConfigFile);
// xmlConfig.LoadXml(textAsset.text);
// // experiment.SetOptimizer(this);
// experiment.Initialize(OptimizerParameters.Name, xmlConfig.DocumentElement, OptimizerParameters.NumInputs, OptimizerParameters.NumOutputs);
// return LoadBrain(filePath, experiment);
//}
public static IBlackBox LoadBrain(string filePath, INeatExperiment experiment)
{
NeatGenome genome = null;
// Try to load the genome from the XML document.
try
{
using (XmlReader xr = XmlReader.Create(filePath))
genome = NeatGenomeXmlIO.ReadCompleteGenomeList(xr, false, (NeatGenomeFactory)experiment.CreateGenomeFactory())[0];
}
catch (Exception e1)
{
print(filePath + " Error loading genome from file!\nLoading aborted.\n"
+ e1.Message + "\nJoe: " + filePath);
return null;
}
// Get a genome decoder that can convert genomes to phenomes.
var genomeDecoder = experiment.CreateGenomeDecoder();
// Decode the genome into a phenome (neural network).
var phenome = genomeDecoder.Decode(genome);
return phenome;
}
static void Main(string[] args)
{
// This program expects certain command line options, that are defined as annotated properties in the NeatSimConsole.Options class
// We instantiate this class...
_options = new Options();
// ... and pass the arguments to this program to the options parser, who uses it to set the properties in 'options'.
// If the command line options are incorrect, ParseArgumentsStrict prints a help message to the screen and exits...
if (!CommandLine.Parser.Default.ParseArgumentsStrict(args, _options))
{
// ... therefore, this should really never ever happen.
throw new SystemException("Something went wrong parsing arguments.");
}
// Now, all the properties in 'options' are set.
FastRandom.__seedRng = new FastRandom(_options.Seed);
// Initialise log4net (log to console).
// XmlConfigurator.Configure(new FileInfo("log4net.properties"));
// We instatiate a remote batch simulation experiment, and use the properties set in the XML file to initialize the experiment.
// The XML file contains properties like the number of generations to run the program for, and the number of individuals in the population.
// For properties that are not set in the XML file, we initialize default values.
_experiment = new RemoteBatchSimExperiment();
var xmlConfig = new XmlDocument();
try
{
xmlConfig.Load("neatsim.config.xml");
}
catch (FileNotFoundException e)
{
Console.WriteLine(@"Could not find neatsim.config.xml. Aborting.");
return;
}
_experiment.Initialize("NeatSim", xmlConfig.DocumentElement);
// The XML file cannot contain information about the inital number of connected neurons.
// We want to initialize our population minimally, and do this by setting an absurdly small initial connections proportion.
// The number of connected input neurons will always be at least one.
// Note that there is an absurdly small chance that more than a single neuron will be connected in generation one.
_experiment.NeatGenomeParameters.InitialInterconnectionsProportion = 0.0000000000001;
// Create a genome factory with our neat genome parameters object and the appropriate number of input and output neuron genes.
_genomeFactory = _experiment.CreateGenomeFactory();
// Create an initial population of randomly generated genomes ('born' in generation 0).
_genomeList = _genomeFactory.CreateGenomeList(_options.PopulationSize, 0);
// Create evolution algorithm and attach update events.
_ea = _experiment.CreateEvolutionAlgorithm(_genomeFactory, _genomeList);
_ea.PausedEvent += (s, e) => Console.WriteLine(_ea.RunState == RunState.Paused
? @"Program is paused"
: _ea.RunState == RunState.Running
? @"Program is unpaused."
: @"Program is in unknown state...");
_neatSimLogger = new NeatSimLogger(_options.LogFileName + '_' + DateTime.Now.ToString("yyyyMMdd"));
//
var nextGeneration = _ea.CurrentGeneration;
var doneEvent = new AutoResetEvent(false);
_ea.UpdateEvent += (s, e) =>
{
if (_ea.CurrentGeneration < nextGeneration)
{
Console.WriteLine("Aborting!");
return;
}
Console.WriteLine(string.Format("gen={0:N0} bestFitness={1:N6}", _ea.CurrentGeneration, _ea.Statistics._maxFitness));
SaveChampionGenome();
_neatSimLogger.Log(_ea);
if (_ea.CurrentGeneration >= _options.Generations)
{
_ea.Stop();
_neatSimLogger.Close();
doneEvent.Set();
}
nextGeneration++;
};
// Start algorithm (it will run on a background thread).
_ea.StartContinue();
// Hit return to quit.
//Console.ReadLine();
doneEvent.WaitOne();
}
