void Start()
{
if (SerializedGenome == string.Empty)
{
Debug.LogError("Spawned artefact without genome!");
}
// Deserialize genome
Profiler.BeginSample("Deserialize");
var genome = NeatGenomeXmlIO.ReadGenome(XmlReader.Create(new StringReader(SerializedGenome)), true);
Profiler.EndSample();
// we need to assign genome factory we used for creating the genome
Profiler.BeginSample("Create genome factory");
genome.GenomeFactory = EvolutionHelper.Instance.GenomeFactory;
Profiler.EndSample();
// Decode phenome from genome
Profiler.BeginSample("Decode");
var genomeDecoder = new NeatGenomeDecoder(NetworkActivationScheme.CreateAcyclicScheme());
var phenome = genomeDecoder.Decode(genome);
Profiler.EndSample();
// Evaluate phenome using voxel grid and generate mesh using Marching Cubes algorithm
Profiler.BeginSample("Evaluation");
ArtefactEvaluator.EvaluationInfo evaluationInfo;
var mesh = ArtefactEvaluator.Evaluate(phenome, m_voxelVolume, out evaluationInfo);
Profiler.EndSample();
// Add required components in order to render mesh
Profiler.BeginSample("Display");
DisplayMesh(mesh);
Profiler.EndSample();
}
private void initializeNetworks()
{
//UpdateMessage("Loading neural networks.");
// initialize modules
const string CHAMPION_FILE = @"host_parasite_champion_to_load.xml";
List <NeatGenome> anns;
XmlConfigurator.Configure(new System.IO.FileInfo("log4net.properties"));
// Load config XML.
XmlDocument xmlConfig = new XmlDocument();
//load genomes
// Save the best genome to file
XmlReaderSettings xwSettings = new XmlReaderSettings();
using (XmlReader xw = XmlReader.Create(CHAMPION_FILE, xwSettings))
{
anns = NeatGenomeXmlIO.ReadCompleteGenomeList(xw, false);
}
IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = new NeatGenomeDecoder(new SharpNeat.Decoders.NetworkActivationScheme(2));
rhythm1 = new NeatPlayer(genomeDecoder.Decode(anns[0]));
rhythm2 = new NeatPlayer(genomeDecoder.Decode(anns[1]));
pitch1 = new NeatPlayer(genomeDecoder.Decode(anns[2]));
pitch2 = new NeatPlayer(genomeDecoder.Decode(anns[3]));
}
/// <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 genome2 population and their associated/parent genome2 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 ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetric, _parallelOptions);
// Create complexity regulation strategy.
IComplexityRegulationStrategy complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold);
// Create the evolution algorithm.
NeatEvolutionAlgorithm <NeatGenome> ea = new NeatEvolutionAlgorithm <NeatGenome>(_eaParams, speciationStrategy, complexityRegulationStrategy);
// Create genome2 decoder.
IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = new NeatGenomeDecoder(_activationScheme);
// Create a genome2 list evaluator. This packages up the genome2 decoder with the genome2 evaluator.
IGenomeListEvaluator <NeatGenome> genomeListEvaluator = new ParallelGenomeListEvaluator <NeatGenome, IBlackBox>(genomeDecoder, PhenomeEvaluator, _parallelOptions);
// 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());
}
// Initialize the evolution algorithm.
ea.Initialize(genomeListEvaluator, genomeFactory, genomeList);
// Finished. Return the evolution algorithm
return(ea);
}
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);
}
}
/// <summary>
/// The map evaluator constructor.
/// </summary>
/// <param name="experimentParameters">The experiment definition and control parameters.</param>
/// <param name="agentInputNeuronCount">The number of input neurons in the agent neural controller.</param>
/// <param name="agentOutputNeuronCount">The number of output neurons in the agent neural controller.</param>
public MapEvaluator(ExperimentParameters experimentParameters, int agentInputNeuronCount,
int agentOutputNeuronCount)
{
// Create the NEAT genome (agent) decoder - acyclic activation is always used
_agentDecoder = new NeatGenomeDecoder(CreateActivationScheme(experimentParameters.ActivationScheme,
experimentParameters.ActivationIters, experimentParameters.ActivationDeltaThreshold));
// Create the maze decoder
_mazeDecoder = new MazeDecoder(experimentParameters.MazeScaleMultiplier);
// Initialize evaluation units
EvaluationUnits = new List <MazeNavigatorEvaluationUnit>();
// Create maze factory with default dimensions (NEAT factory will be set later based on structure of first
// genome encountered)
_mazeGenomeFactory = new MazeGenomeFactory(experimentParameters.MazeHeight, experimentParameters.MazeWidth,
experimentParameters.MazeQuadrantHeight, experimentParameters.MazeQuadrantWidth);
_neatGenomeFactory = new NeatGenomeFactory(agentInputNeuronCount, agentOutputNeuronCount);
// Set experiment parameters
_experimentParameters = experimentParameters;
// Create new agent ID list and maze ID/structure map
_agentGenomeIds = new List <int>();
_mazeIdStructureMap = new Dictionary <int, MazeStructure>();
}
public SimulatorExperimentConfiguration ReadExperimentConfigurationFile(string configurationFile)
{
XmlDocument xmlExperimentConfig = new XmlDocument();
// Parse experiment name out of configuration file
string experimentName = Path.GetFileNameWithoutExtension(configurationFile);
// Load experiment configuration file
xmlExperimentConfig.Load(configurationFile);
// Get the root element
XmlElement rootElement = xmlExperimentConfig.DocumentElement;
// Determine navigator ANN controller activation scheme
NetworkActivationScheme navigatorActivationScheme = ExperimentUtils.CreateActivationScheme(rootElement,
"Activation");
// Create a new navigator genome decoder based on the activation scheme
_navigatorGenomeDecoder = new NeatGenomeDecoder(navigatorActivationScheme);
// Read in maze properties
int mazeHeight = XmlUtils.GetValueAsInt(rootElement, "MazeHeight");
int mazeWidth = XmlUtils.GetValueAsInt(rootElement, "MazeWidth");
int mazeScaleMultiplier = XmlUtils.GetValueAsInt(rootElement, "MazeScaleMultiplier");
// Create a new maze genome decoder based on the maze size
_mazeGenomeDecoder = new MazeDecoder(mazeHeight, mazeWidth, mazeScaleMultiplier);
// Read experiment parameteres and return experiment configuration
return new SimulatorExperimentConfiguration(experimentName, mazeHeight, mazeWidth, mazeScaleMultiplier,
navigatorActivationScheme, XmlUtils.GetValueAsInt(rootElement, "MaxTimesteps"),
XmlUtils.GetValueAsInt(rootElement, "MinSuccessDistance"));
}
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);
}
private static IBlackBox BrainFromFile(string brainFileName, int inputCount, int outputCount)
{
// TODO: Refactor
var genomeDecoder = new NeatGenomeDecoder(NetworkActivationScheme.CreateCyclicFixedTimestepsScheme(1));
var genomeFactory = new NeatGenomeFactory(inputCount, outputCount, new NeatGenomeParameters());
NeatGenome genome;
using (var xr = XmlReader.Create(brainFileName))
{
genome = NeatGenomeXmlIO.ReadCompleteGenomeList(xr, false, genomeFactory)[0];
}
return genomeDecoder.Decode(genome);
}
public void Initialize(NeatGenome genome)
{
IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = new NeatGenomeDecoder(NetworkActivationScheme.CreateAcyclicScheme());
try {
_blackBox = genomeDecoder.Decode(genome);
}
catch (Exception) {
if (CyclicNetworkTest.IsNetworkCyclic(genome))
{
Debug.Log("Cyclic");
}
}
Genome = genome;
}
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();
}
void Start ()
{
evolutionHelper = new EvolutionHelper(k_numberOfInputs, k_numberOfOutputs);
currentGenome = evolutionHelper.CreateInitialGenome();
genomeDecoder = new NeatGenomeDecoder(NetworkActivationScheme.CreateAcyclicScheme());
ArtefactEvaluator.DefaultInputType = InputType;
SaveGenome();
Sine.__DefaultInstance.Curve = sineCurve;
m_meshGameObject = new GameObject("Mesh");
m_meshGameObject.AddComponent<MeshFilter>();
m_meshGameObject.AddComponent<MeshRenderer>();
m_meshGameObject.AddComponent<ProceduralMesh>();
m_meshGameObject.GetComponent<Renderer>().material = standardMaterial;
Camera.main.GetComponent<CameraMouseOrbit>().target = m_meshGameObject.transform;
}
public override void OnStartClient()
{
base.OnStartClient();
if (SerializedGenome == string.Empty)
{
Debug.LogError("Spawned artefact without genome!");
}
// Deserialize genome
Profiler.BeginSample("Deserialize");
var genome = NeatGenomeXmlIO.ReadGenome(XmlReader.Create(new StringReader(SerializedGenome)), true);
Profiler.EndSample();
// we need to assign genome factory we used for creating the genome
Profiler.BeginSample("Create genome factory");
genome.GenomeFactory = EvolutionHelper.Instance.GenomeFactory;
Profiler.EndSample();
// Decode phenome from genome
Profiler.BeginSample("Decode");
var genomeDecoder = new NeatGenomeDecoder(NetworkActivationScheme.CreateAcyclicScheme());
var phenome = genomeDecoder.Decode(genome);
Profiler.EndSample();
// Evaluate phenome using voxel grid and generate mesh using Marching Cubes algorithm
Profiler.BeginSample("Evaluation");
ArtefactEvaluator.EvaluationInfo evaluationInfo;
var mesh = ArtefactEvaluator.Evaluate(phenome, m_voxelVolume, out evaluationInfo);
Profiler.EndSample();
// Add required components in order to render mesh
Profiler.BeginSample("Display");
DisplayMesh(mesh);
Profiler.EndSample();
if (this.GetType() == typeof (Artefact))
{
//StartCoroutine(Grow());
StartCoroutine(Glow());
StartCoroutine(WaitForPlayer());
}
//var countText = GameObject.FindGameObjectWithTag("ArtefactCounter").GetComponent<Text>();
//countText.text = "" + (int.Parse(countText.text) + 1);
}
private void InitTeam(double teamDisc, NeatEvolutionAlgorithm <NeatGenome> team, NeatEvolutionAlgorithm <NeatGenome> opponent)
{
NeatGenomeParameters genomeParams = new NeatGenomeParameters();
genomeParams.FeedforwardOnly = true;
//genomeParams.InitialInterconnectionsProportion = 1.0;
IGenomeFactory <NeatGenome> genomeFactory = new NeatGenomeFactory(7 * 6, 7, genomeParams);
IGenomeDecoder <NeatGenome, IBlackBox> decoder = new NeatGenomeDecoder(SharpNeat.Decoders.NetworkActivationScheme.CreateAcyclicScheme());
IGenomeListEvaluator <NeatGenome> evaluator = new CacheFirstParallelGenomeListEvaluator <NeatGenome, IBlackBox>(
decoder, new ConnectFourEvaluator(teamDisc, opponent, decoder));
team.UpdateEvent += ((sender, eventArgs) => OnUpdate());
team.Initialize(evaluator, genomeFactory, populationSize);
}
void Start ()
{
evolutionHelper = new EvolutionHelper(k_numberOfInputs, k_numberOfOutputs);
var intialGenome = evolutionHelper.CreateInitialGenome();
genomeDecoder = new NeatGenomeDecoder(NetworkActivationScheme.CreateAcyclicScheme());
//parentGameObject = CreateGameObject("Parent");
for (int i = 0; i < numberOfChildren; i++)
{
var child = CreateGameObject("Child" + (i + 1));
var direction = Quaternion.Euler(0f, 0f, -(180f/(numberOfChildren - 1))*i) * Vector3.left;
child.transform.position = direction * 30f;
seedsGameObjects.Add(child);
}
SpawnSeeds(intialGenome);
}
/*
* List<NeatGenome> CreateNewGenome(IGenomeFactory<NeatGenome> genomeFactory)
* {
* Console.WriteLine("Saved genome not found, creating new files.");
* return genomeFactory.CreateGenomeList(_populationSize, 0);
* }
*/
/// <summary>
/// Creates and returns 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 genome2
/// population and their associated/parent genome2 factory.
/// </summary>
public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(
IGenomeFactory <NeatGenome> genomeFactory, List <NeatGenome> genomeList)
{
// Creates 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);
ISpeciationStrategy <NeatGenome> speciationStrategy = new ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetric, _parallelOptions);
IComplexityRegulationStrategy complexityRegulationStrategy =
ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold);
// Creates the evolution algorithm.
NeatEvolutionAlgorithm <NeatGenome> evolAlgorithm = new NeatEvolutionAlgorithm <NeatGenome>(
_eaParams, speciationStrategy, complexityRegulationStrategy, userName);
IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = new NeatGenomeDecoder(_activationScheme);
// Creates a genome2 list evaluator. This packages up the genome2 decoder with the genome2 evaluator.
IGenomeListEvaluator <NeatGenome> genomeListEvaluator =
new ParallelGenomeListEvaluator <NeatGenome, IBlackBox>(genomeDecoder, PhenomeEvaluator, _parallelOptions);
//To use single-thread evaluator:
//IGenomeListEvaluator<NeatGenome> genomeListEvaluator =
// new SerialGenomeListEvaluator<NeatGenome, IBlackBox>(genomeDecoder, PhenomeEvaluator, false);
// Wraps 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.
/*
* int reevaluationPeriod = 1;
* genomeListEvaluator = new SelectiveGenomeListEvaluator<NeatGenome>(
* genomeListEvaluator,
* SelectiveGenomeListEvaluator<NeatGenome>.CreatePredicate_PeriodicReevaluation(reevaluationPeriod));
*/
genomeListEvaluator = new SelectiveGenomeListEvaluator <NeatGenome>(
genomeListEvaluator,
SelectiveGenomeListEvaluator <NeatGenome> .CreatePredicate_OnceOnly());
// Initializes the evolution algorithm.
evolAlgorithm.Initialize(genomeListEvaluator, genomeFactory, genomeList);
// Finished. Return the evolution algorithm
return(evolAlgorithm);
}
public void Initialize(Vector2 pos, int amoutOfWarriorsOwns, int team, bool freeze)
{
Debug.Assert(amoutOfWarriorsOwns > 5);
transform.position = pos;
defaultPos = pos;
experiment = CreateExperiment(amoutOfWarriorsOwns);
decoder = experiment.CreateDecoder();
this.team = team;
this.amoutOfWarriorsOwns = amoutOfWarriorsOwns;
pointsToVisitDuringTraining = new List<Vector3>();
initialized = true;
lineRenderer = GetComponent<LineRenderer>();
isEvolutionFreezed = freeze;
nextPosChange = new Vector2();
}
public IBlackBox BestPhenome()
{
var genomeFactory = new NeatGenomeFactory(this.InputCount, this.OutputCount, new NeatGenomeParameters());
//var genomeFactory = new SharpNeat.Genomes.HyperNeat.CppnGenomeFactory(
// this.InputCount,
// this.OutputCount,
// SharpNeat.Network.DefaultActivationFunctionLibrary.CreateLibraryCppn(),
// new NeatGenomeParameters());
List <NeatGenome> genomeList;
using (XmlReader xr = XmlReader.Create(this.xmlPopulationFile))
{
genomeList = NeatGenomeXmlIO.ReadCompleteGenomeList(xr, false, genomeFactory);
}
//var decoder = new NeatGenomeDecoder(NetworkActivationScheme.CreateCyclicFixedTimestepsScheme(1));
var decoder = new NeatGenomeDecoder(NetworkActivationScheme.CreateAcyclicScheme());
return(decoder.Decode(genomeList[0]));
}
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();
}
/// <summary>
/// The map evaluator constructor.
/// </summary>
/// <param name="experimentParameters">The experiment definition and control parameters.</param>
/// <param name="agentInputNeuronCount">The number of input neurons in the agent neural controller.</param>
/// <param name="agentOutputNeuronCount">The number of output neurons in the agent neural controller.</param>
public MapEvaluator(ExperimentParameters experimentParameters, int agentInputNeuronCount,
int agentOutputNeuronCount)
{
// Create the NEAT genome (agent) decoder - acyclic activation is always used
_agentDecoder = new NeatGenomeDecoder(NetworkActivationScheme.CreateAcyclicScheme());
// Create the maze decoder
_mazeDecoder = new MazeDecoder(experimentParameters.MazeHeight, experimentParameters.MazeWidth,
experimentParameters.MazeScaleMultiplier);
// Initialize evaluation units
EvaluationUnits = new List<MazeNavigatorEvaluationUnit>();
// Create default maze factory (NEAT factory will be set later based on structure of first genome encountered)
_mazeGenomeFactory = new MazeGenomeFactory();
_neatGenomeFactory = new NeatGenomeFactory(agentInputNeuronCount, agentOutputNeuronCount);
// Set experiment parameters
_experimentParameters = experimentParameters;
// Create new agent ID list and maze ID/structure map
_agentGenomeIds = new List<int>();
_mazeIdStructureMap = new Dictionary<int, MazeStructure>();
}
public void VerifyBootstrappedStateTest()
{
const string parentDirectory =
"F:/User Data/Jonathan/Documents/school/Jonathan/Graduate/PhD/Development/C# NEAT/SharpNoveltyNeat/SharpNeatConsole/bin/Debug/";
const string agentGenomeFile = "ViableSeedGenomes.xml";
const string baseBitmapFilename = "AgentTrajectory";
const int mazeHeight = 20;
const int mazeWidth = 20;
const int scaleMultiplier = 16;
const int maxTimesteps = 400;
const int minSuccessDistance = 5;
// Setup stuff for the navigators
List<NeatGenome> agentGenomes;
NeatGenomeDecoder agentGenomeDecoder = new NeatGenomeDecoder(NetworkActivationScheme.CreateAcyclicScheme());
NeatGenomeFactory agentGenomeFactory = new NeatGenomeFactory(10, 2);
// Create new minimal maze (no barriers)
MazeStructure mazeStructure = new MazeDecoder(mazeHeight, mazeWidth, scaleMultiplier).Decode(
new MazeGenomeFactory(null, null, null).CreateGenome(0));
// Create behavior characterization factory
IBehaviorCharacterizationFactory behaviorCharacterizationFactory =
new TrajectoryBehaviorCharacterizationFactory(null);
// Create evaluator
MazeNavigatorMCSEvaluator mazeNavigatorEvaluator = new MazeNavigatorMCSEvaluator(maxTimesteps,
minSuccessDistance, behaviorCharacterizationFactory, 1);
// Set maze within evaluator
mazeNavigatorEvaluator.UpdateEvaluatorPhenotypes(new List<MazeStructure> {mazeStructure});
// Read in agents
using (XmlReader xr = XmlReader.Create(parentDirectory + agentGenomeFile))
{
agentGenomes = NeatGenomeXmlIO.ReadCompleteGenomeList(xr, false, agentGenomeFactory);
}
// Decode agent genomes to phenotype and run simulation
for (int i = 0; i < agentGenomes.Count; i++)
{
// Decode navigator genome
IBlackBox agentPhenome = agentGenomeDecoder.Decode(agentGenomes[i]);
// Run simulation
BehaviorInfo behaviorInfo = mazeNavigatorEvaluator.Evaluate(agentPhenome, 0, false, null, null);
// Print the navigator trajectory through the maze
DomainTestUtils.PrintMazeAndTrajectory(mazeStructure, behaviorInfo.Behaviors,
string.Format("{0}_{1}.bmp", baseBitmapFilename, i));
}
}
/// <summary>
/// Creates the evolution algorithm container using the given factories and genome lists.
/// </summary>
/// <param name="genomeFactory1">The agent genome factory.</param>
/// <param name="genomeFactory2">The maze genome factory.</param>
/// <param name="genomeList1">The agent genome list.</param>
/// <param name="genomeList2">The maze genome list.</param>
/// <returns>The instantiated coevolution algorithm container.</returns>
public override ICoevolutionAlgorithmContainer<NeatGenome, MazeGenome> CreateCoevolutionAlgorithmContainer(
IGenomeFactory<NeatGenome> genomeFactory1,
IGenomeFactory<MazeGenome> genomeFactory2, List<NeatGenome> genomeList1, List<MazeGenome> genomeList2)
{
List<NeatGenome> seedAgentPopulation = new List<NeatGenome>();
// Compute the maze max complexity
((MazeGenomeFactory) genomeFactory2).MaxComplexity = MazeUtils.DetermineMaxPartitions(_mazeHeight,
_mazeWidth, 200);
// Create maze decoder to decode initialization mazes
MazeDecoder mazeDecoder = new MazeDecoder(_mazeHeight, _mazeWidth, _mazeScaleMultiplier);
// Loop through every maze and evolve the requisite number of viable genomes that solve it
for (int idx = 0; idx < genomeList2.Count; idx++)
{
Console.WriteLine(@"Evolving viable agents for maze population index {0} and maze ID {1}", idx,
genomeList2[idx].Id);
// Evolve the number of agents required to meet the success MC for the current maze
List<NeatGenome> viableMazeAgents = EvolveViableAgents(genomeFactory1, genomeList1.ToList(),
mazeDecoder.Decode(genomeList2[idx]));
// Add the viable agent genomes who solve the current maze (but avoid adding duplicates, as identified by the genome ID)
// Note that it's fine to have multiple mazes solved by the same agent, so in this case, we'll leave the agent
// in the pool of seed agent genomes
foreach (
NeatGenome viableMazeAgent in
viableMazeAgents.Where(
viableMazeAgent =>
seedAgentPopulation.Select(sap => sap.Id).Contains(viableMazeAgent.Id) == false))
{
seedAgentPopulation.Add(viableMazeAgent);
}
}
// If we still lack the genomes to fill out agent specie count while still satisfying the maze MC,
// iteratively pick a random maze and evolve agents on that maze until we reach the requisite number
while (seedAgentPopulation.ToList().Count < _numAgentSuccessCriteria*AgentNumSpecies)
{
FastRandom rndMazePicker = new FastRandom();
// Pick a random maze on which to evolve agent(s)
MazeGenome mazeGenome = genomeList2[rndMazePicker.Next(genomeList2.Count - 1)];
Console.WriteLine(
@"Continuing viable agent evolution on maze {0}, with {1} of {2} required agents in place",
mazeGenome.Id, seedAgentPopulation.Count, (_numAgentSuccessCriteria*AgentNumSpecies));
// Evolve the number of agents required to meet the success MC for the maze
List<NeatGenome> viableMazeAgents = EvolveViableAgents(genomeFactory1, genomeList1.ToList(),
mazeDecoder.Decode(mazeGenome));
// Iterate through each viable agent and remove them if they've already solved a maze or add them to the list
// of viable agents if they have not
foreach (NeatGenome viableMazeAgent in viableMazeAgents)
{
// If they agent has already solved maze and is in the list of viable agents, remove that agent
// from the pool of seed genomes (this is done because here, we're interested in getting unique
// agents and want to avoid an endless loop wherein the same viable agents are returned)
if (seedAgentPopulation.Select(sap => sap.Id).Contains(viableMazeAgent.Id))
{
genomeList1.Remove(viableMazeAgent);
}
// Otherwise, add that agent to the list of viable agents
else
{
seedAgentPopulation.Add(viableMazeAgent);
}
}
}
// Set dummy fitness so that seed maze(s) will be marked as evaluated
foreach (MazeGenome mazeGenome in genomeList2)
{
mazeGenome.EvaluationInfo.SetFitness(0);
}
// Reset primary NEAT genome parameters on agent genome factory
((NeatGenomeFactory) genomeFactory1).ResetNeatGenomeParameters(NeatGenomeParameters);
// Create the NEAT (i.e. navigator) queueing evolution algorithm
AbstractEvolutionAlgorithm<NeatGenome> neatEvolutionAlgorithm =
new MultiQueueNeatEvolutionAlgorithm<NeatGenome>(
new NeatEvolutionAlgorithmParameters
{
SpecieCount = AgentNumSpecies,
MaxSpecieSize = AgentDefaultPopulationSize/AgentNumSpecies
},
new ParallelKMeansClusteringStrategy<NeatGenome>(new ManhattanDistanceMetric(1.0, 0.0, 10.0),
ParallelOptions), null, NavigatorBatchSize, RunPhase.Primary, _navigatorEvolutionDataLogger,
_navigatorLogFieldEnableMap, _navigatorPopulationGenomesDataLogger, _populationLoggingBatchInterval);
// Create the maze queueing evolution algorithm
AbstractEvolutionAlgorithm<MazeGenome> mazeEvolutionAlgorithm =
new MultiQueueNeatEvolutionAlgorithm<MazeGenome>(
new NeatEvolutionAlgorithmParameters
{
SpecieCount = MazeNumSpecies,
MaxSpecieSize = MazeDefaultPopulationSize/MazeNumSpecies
},
new ParallelKMeansClusteringStrategy<MazeGenome>(new ManhattanDistanceMetric(1.0, 0.0, 10.0),
ParallelOptions), null, MazeBatchSize, RunPhase.Primary, _mazeEvolutionDataLogger,
_mazeLogFieldEnableMap, _mazePopulationGenomesDataLogger, _populationLoggingBatchInterval);
// Create the maze phenome evaluator
IPhenomeEvaluator<MazeStructure, BehaviorInfo> mazeEvaluator = new MazeEnvironmentMCSEvaluator(
_maxTimesteps, _minSuccessDistance, BehaviorCharacterizationFactory, _numAgentSuccessCriteria, 0);
// Create navigator phenome evaluator
IPhenomeEvaluator<IBlackBox, BehaviorInfo> navigatorEvaluator = new MazeNavigatorMCSEvaluator(
_maxTimesteps, _minSuccessDistance, BehaviorCharacterizationFactory, _numMazeSuccessCriteria);
// Create maze genome decoder
IGenomeDecoder<MazeGenome, MazeStructure> mazeGenomeDecoder = new MazeDecoder(_mazeHeight, _mazeWidth,
_mazeScaleMultiplier);
// Create navigator genome decoder
IGenomeDecoder<NeatGenome, IBlackBox> navigatorGenomeDecoder = new NeatGenomeDecoder(ActivationScheme);
// Create the maze genome evaluator
IGenomeEvaluator<MazeGenome> mazeFitnessEvaluator =
new ParallelGenomeBehaviorEvaluator<MazeGenome, MazeStructure>(mazeGenomeDecoder, mazeEvaluator,
SelectionType.Queueing, SearchType.MinimalCriteriaSearch, ParallelOptions);
// Create navigator genome evaluator
IGenomeEvaluator<NeatGenome> navigatorFitnessEvaluator =
new ParallelGenomeBehaviorEvaluator<NeatGenome, IBlackBox>(navigatorGenomeDecoder, navigatorEvaluator,
SelectionType.Queueing, SearchType.MinimalCriteriaSearch, ParallelOptions);
// Create the coevolution container
ICoevolutionAlgorithmContainer<NeatGenome, MazeGenome> coevolutionAlgorithmContainer =
new CoevolutionAlgorithmContainer<NeatGenome, MazeGenome>(neatEvolutionAlgorithm, mazeEvolutionAlgorithm);
// Initialize the container and component algorithms
coevolutionAlgorithmContainer.Initialize(navigatorFitnessEvaluator, genomeFactory1, seedAgentPopulation,
AgentDefaultPopulationSize, mazeFitnessEvaluator, genomeFactory2, genomeList2, MazeDefaultPopulationSize,
MaxGenerations, MaxEvaluations);
return coevolutionAlgorithmContainer;
}
public static void Main(string[] args)
{
var random = new Random();
var circuits = circuitsFilePaths().ToArray();
var perceptionStep = TimeSpan.FromSeconds(0.1);
var simulationStep = TimeSpan.FromSeconds(0.05); // 20Hz
var maximumSimulationTime = TimeSpan.FromSeconds(60);
var tracks = circuits.Select(circuitPath => Track.Load($"{circuitPath}/circuit_definition.json"));
var worlds = tracks.Select(track => new StandardWorld(track, simulationStep)).ToArray();
var inputSamplesCount = 3;
var maximumScanningDistance = 200;
ILidar createLidarFor(ITrack track)
=> new Lidar(track, inputSamplesCount, Angle.FromDegrees(135), maximumScanningDistance);
var settings = new EvolutionSettings
{
PopulationSize = 1000,
SpeciesCount = 30,
ElitismProportion = 0,
ComplexityThreshold = 50
};
// prepare simulation
var parameters = new NeatEvolutionAlgorithmParameters
{
ElitismProportion = settings.ElitismProportion,
SpecieCount = settings.SpeciesCount
};
var distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0);
var parallelOptions = new ParallelOptions {
MaxDegreeOfParallelism = 4
};
var speciationStrategy = new ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetric, parallelOptions);
var complexityRegulationStrategy = new DefaultComplexityRegulationStrategy(ComplexityCeilingType.Absolute, settings.ComplexityThreshold);
var evolutionaryAlgorithm = new NeatEvolutionAlgorithm <NeatGenome>(
parameters,
speciationStrategy,
complexityRegulationStrategy);
var phenomeEvaluator = new RaceSimulationEvaluator(
random,
simulationStep,
perceptionStep,
maximumSimulationTime,
worlds,
createLidarFor);
var genomeDecoder = new NeatGenomeDecoder(NetworkActivationScheme.CreateAcyclicScheme());
var genomeListEvaluator = new ParallelGenomeListEvaluator <NeatGenome, IBlackBox>(
genomeDecoder,
phenomeEvaluator);
evolutionaryAlgorithm.Initialize(
genomeListEvaluator,
genomeFactory: new NeatGenomeFactory(
inputNeuronCount: inputSamplesCount,
outputNeuronCount: 2,
DefaultActivationFunctionLibrary.CreateLibraryNeat(new BipolarSigmoid()),
new NeatGenomeParameters
{
FeedforwardOnly = true,
AddNodeMutationProbability = 0.03,
DeleteConnectionMutationProbability = 0.05,
ConnectionWeightMutationProbability = 0.08,
FitnessHistoryLength = 10,
}),
settings.PopulationSize);
var lastVisualization = DateTimeOffset.Now;
evolutionaryAlgorithm.UpdateEvent += onUpdate;
evolutionaryAlgorithm.StartContinue();
Console.WriteLine("Press enter to stop the evolution.");
Console.ReadLine();
Console.WriteLine("Finishing the evolution.");
evolutionaryAlgorithm.Stop();
Console.WriteLine("Evolution is stopped.");
// simulate best individual
Console.WriteLine("Simulating best individual...");
evaluate(evolutionaryAlgorithm.CurrentChampGenome);
Console.WriteLine("Done.");
void onUpdate(object sender, EventArgs e)
{
Console.WriteLine($"Generation #{evolutionaryAlgorithm.CurrentGeneration}");
Console.WriteLine($"- max fitness: {evolutionaryAlgorithm.Statistics._maxFitness}");
Console.WriteLine($"- mean fitness: {evolutionaryAlgorithm.Statistics._meanFitness}");
Console.WriteLine();
if (DateTimeOffset.Now - lastVisualization > TimeSpan.FromSeconds(35))
{
lastVisualization = DateTimeOffset.Now;
Console.WriteLine("Simulating currently best individual...");
evaluate(evolutionaryAlgorithm.CurrentChampGenome);
}
}
void evaluate(NeatGenome genome)
{
var worldId = random.Next(0, worlds.Length - 1);
var world = worlds[worldId];
var bestIndividual = genomeDecoder.Decode(genome);
var agent = new NeuralNetworkAgent(createLidarFor(world.Track), bestIndividual);
var simulation = new Simulation.Simulation(agent, world);
var summary = simulation.Simulate(simulationStep, perceptionStep, maximumSimulationTime);
File.Copy($"{circuits[worldId]}/visualization.svg", "C:/Users/simon/Projects/racer-experiment/simulator/src/visualization.svg", overwrite: true);
IO.Simulation.StoreResult(world.Track, world.VehicleModel, summary, "", "C:/Users/simon/Projects/racer-experiment/simulator/src/report.json");
}
}
/// <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 genome2 population and their associated/parent genome2 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 ParallelKMeansClusteringStrategy<NeatGenome>(distanceMetric, _parallelOptions);
// Create complexity regulation strategy.
IComplexityRegulationStrategy complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold);
// Create the evolution algorithm.
NeatEvolutionAlgorithm<NeatGenome> ea = new NeatEvolutionAlgorithm<NeatGenome>(_eaParams, speciationStrategy, complexityRegulationStrategy);
// Create genome2 decoder.
IGenomeDecoder<NeatGenome, IBlackBox> genomeDecoder = new NeatGenomeDecoder(_activationScheme);
// Create a genome2 list evaluator. This packages up the genome2 decoder with the genome2 evaluator.
IGenomeListEvaluator<NeatGenome> genomeListEvaluator = new ParallelGenomeListEvaluator<NeatGenome, IBlackBox>(genomeDecoder, PhenomeEvaluator, _parallelOptions);
// 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());
// Initialize the evolution algorithm.
ea.Initialize(genomeListEvaluator, genomeFactory, genomeList);
// Finished. Return the evolution algorithm
return ea;
}
private void GetGenomeDecoder()
{
_GenomeDecoder = new SharpNeat.Decoders.Neat.NeatGenomeDecoder(_NetworkActivationScheme);
}
public override void Create()
{
double[] currentDurationPhrase = MusicLibrary.CurrentSongDuration();
int[] currentPitchPhrase = MusicLibrary.CurrentSongPitch();
double[] rhythmInputs = MusicEnvironment.createDurationInputs(currentDurationPhrase);
int[] pitchInputs = MusicEnvironment.createPitchInputs(currentPitchPhrase, currentDurationPhrase);
string CHAMPION_FILE = @"..\..\..\NeatMusic\bin\Debug\host_parasite_champion.xml";
List <NeatGenome> anns;
XmlConfigurator.Configure(new System.IO.FileInfo("log4net.properties"));
// Load config XML.
XmlDocument xmlConfig = new XmlDocument();
//load genomes
// Save the best genome to file
XmlReaderSettings xwSettings = new XmlReaderSettings();
using (XmlReader xw = XmlReader.Create(CHAMPION_FILE, xwSettings))
{
anns = NeatGenomeXmlIO.ReadCompleteGenomeList(xw, false);
}
foreach (var neatGenome in anns)
{
Console.WriteLine("id_" + neatGenome.Id);
}
// Load config XML.
XmlDocument xmlConfig1 = new XmlDocument();
xmlConfig1.Load(@"..\..\..\NeatMusic\bin\Debug\config.xml");
XmlElement xmlElement = xmlConfig1.DocumentElement;
var activation = ExperimentUtils.CreateActivationScheme(xmlElement, "Activation");
IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = new NeatGenomeDecoder(activation);
int MODULE_COUNT = anns.Count / 2;
int LENGHT = rhythmInputs.Length;
int LENGTHPITCH = currentPitchPhrase.Length;
//int LENGTHPITCH = LENGHT;
int SEED_PITCH = 0;
var rhythmPlayers = new List <NeatPlayer>();
var pitchPlayers = new List <NeatPlayer>();
for (int i = 0; i < MODULE_COUNT; i++)
{
rhythmPlayers.Add(new NeatPlayer(genomeDecoder.Decode(anns[i])));
}
for (int i = MODULE_COUNT; i < MODULE_COUNT * 2; i++)
{
pitchPlayers.Add(new NeatPlayer(genomeDecoder.Decode(anns[i])));
}
double[][] rhythmOutput = new double[MODULE_COUNT][];
int[][] pitchOutput = new int[MODULE_COUNT][];
for (int i = 0; i < MODULE_COUNT; i++)
{
rhythmOutput[i] = new double[LENGHT];
pitchOutput[i] = new int[LENGTHPITCH];
}
for (int i = 0; i < MODULE_COUNT; i++)
{
rhythmOutput[i] = new double[LENGHT];
pitchOutput[i] = new int[LENGHT];
}
for (int i = 0; i < LENGHT; i++)
{
for (int p = 0; p < MODULE_COUNT; p++)
{
var brainInput = MusicEnvironment.getBrainInputDelayed(pitchOutput, pitchInputs, p, MODULE_COUNT, i);
pitchOutput[p][i] = MusicEnvironment.convertToMidiClass(pitchPlayers[p].calculateOutput(brainInput));
}
}
for (int i = 0; i < LENGHT; i++)
{
for (int p = 0; p < MODULE_COUNT; p++)
{
var brainInput = MusicEnvironment.getBrainInputDelayed(rhythmOutput, rhythmInputs, p, MODULE_COUNT, i);
rhythmOutput[p][i] = rhythmPlayers[p].calculateOutput(brainInput);
}
}
printFitness(MODULE_COUNT, pitchPlayers, rhythmPlayers);
//get standard deviation
Console.WriteLine(@"Input deviation: {0}", SmoothedZSmoothening.StandardDeviation(rhythmInputs));
for (int i = 0; i < rhythmOutput.Length; i++)
{
double standardDev = SmoothedZSmoothening.StandardDeviation(rhythmOutput[i]);
Console.WriteLine(@"Module {0} deviation: {1}", i, standardDev);
}
//look at outputs and find out when there are new notes and what they are
//new note when current value is higher than previous one
List <double>[] durationsLists = new List <double> [MODULE_COUNT];
List <int>[] pitchLists = new List <int> [MODULE_COUNT];
for (int i = 0; i < MODULE_COUNT; i++)
{
durationsLists[i] = new List <double>();
pitchLists[i] = new List <int>();
findNewNotesFromOutput(rhythmOutput[i], pitchOutput[i], LENGHT, out durationsLists[i], out pitchLists[i]);
mergeRests(durationsLists[i], pitchLists[i]);
printResults(durationsLists[i], pitchLists[i], i + 1);
}
Sequence seq = new Sequence();
seq.Add(getTrack(currentPitchPhrase, currentDurationPhrase, 60));
//save input phrase in separate file
seq.Save("base.mid");
for (int i = 0; i < MODULE_COUNT; i++)
{
//int offset = i%2 == 0 ? 60 + 12 * (i/2 + 1) : 48 - 12 * (i/2 + 1); //how should this be done?
int offset = 48;
Track t = getTrack(pitchLists[i].ToArray(), durationsLists[i].ToArray(), offset);
Sequence singleTrack = new Sequence();
singleTrack.Add(t);
singleTrack.Save("track" + (i + 1) + ".mid");
seq.Add(t);
}
seq.Save("test.mid");
// Hit return to quit.
Console.ReadLine();
}
/// <inheritdoc />
/// <summary>
/// Creates the evolution algorithm container using the given factories and genome lists.
/// </summary>
/// <param name="genomeFactory1">The agent genome factory.</param>
/// <param name="genomeFactory2">The maze genome factory.</param>
/// <param name="genomeList1">The agent genome list.</param>
/// <param name="genomeList2">The maze genome list.</param>
/// <param name="isAgentListPreevolved">
/// Indicates whether the given agents have been pre-evolved to satisfy the MC with
/// respect to the maze population.
/// </param>
/// <returns>The instantiated MCC algorithm container.</returns>
public override IMCCAlgorithmContainer <NeatGenome, MazeGenome> CreateMCCAlgorithmContainer(
IGenomeFactory <NeatGenome> genomeFactory1, IGenomeFactory <MazeGenome> genomeFactory2,
List <NeatGenome> genomeList1, List <MazeGenome> genomeList2, bool isAgentListPreevolved)
{
// Either use pre-evolved agents or evolve the seed agents that meet the MC
var seedAgentPopulation = isAgentListPreevolved
? genomeList1
: EvolveSeedAgents(genomeList1, genomeList2, genomeFactory1, AgentSeedGenomeCount);
// Set dummy fitness so that seed maze(s) will be marked as evaluated
foreach (var mazeGenome in genomeList2)
{
mazeGenome.EvaluationInfo.SetFitness(0);
}
// Create the NEAT evolution algorithm parameters
var neatEaParams = new EvolutionAlgorithmParameters
{
SpecieCount = AgentNumSpecies,
MaxSpecieSize =
AgentNumSpecies > 0
? AgentDefaultPopulationSize / AgentNumSpecies
: AgentDefaultPopulationSize
};
// Create the maze evolution algorithm parameters
var mazeEaParams = new EvolutionAlgorithmParameters
{
SpecieCount = MazeNumSpecies,
MaxSpecieSize =
MazeNumSpecies > 0 ? MazeDefaultPopulationSize / MazeNumSpecies : MazeDefaultPopulationSize
};
// Create the NEAT (i.e. navigator) queueing evolution algorithm
AbstractEvolutionAlgorithm <NeatGenome> neatEvolutionAlgorithm = new QueueEvolutionAlgorithm <NeatGenome>(
neatEaParams, new NeatAlgorithmStats(neatEaParams), null, NavigatorBatchSize, RunPhase.Primary,
_navigatorEvolutionDataLogger, _navigatorLogFieldEnableMap, _navigatorPopulationDataLogger,
_navigatorGenomeDataLogger, _populationLoggingBatchInterval);
// Create the maze queueing evolution algorithm
AbstractEvolutionAlgorithm <MazeGenome> mazeEvolutionAlgorithm = new QueueEvolutionAlgorithm <MazeGenome>(
mazeEaParams, new MazeAlgorithmStats(mazeEaParams), null, MazeBatchSize, RunPhase.Primary,
_mazeEvolutionDataLogger, _mazeLogFieldEnableMap, _mazePopulationDataLogger, _mazeGenomeDataLogger,
_populationLoggingBatchInterval);
// Create the maze phenome evaluator
IPhenomeEvaluator <MazeStructure, BehaviorInfo> mazeEvaluator =
new MazeEnvironmentMCCEvaluator(MinSuccessDistance, BehaviorCharacterizationFactory,
NumAgentSuccessCriteria, NumAgentFailedCriteria);
// Create navigator phenome evaluator
IPhenomeEvaluator <IBlackBox, BehaviorInfo> navigatorEvaluator =
new MazeNavigatorMCCEvaluator(MinSuccessDistance, BehaviorCharacterizationFactory,
NumMazeSuccessCriteria);
// Create maze genome decoder
IGenomeDecoder <MazeGenome, MazeStructure> mazeGenomeDecoder = new MazeDecoder(MazeScaleMultiplier);
// Create navigator genome decoder
IGenomeDecoder <NeatGenome, IBlackBox> navigatorGenomeDecoder = new NeatGenomeDecoder(ActivationScheme);
// Create the maze genome evaluator
IGenomeEvaluator <MazeGenome> mazeFitnessEvaluator =
new ParallelGenomeBehaviorEvaluator <MazeGenome, MazeStructure>(mazeGenomeDecoder, mazeEvaluator, SearchType.MinimalCriteriaSearch, ParallelOptions);
// Create navigator genome evaluator
IGenomeEvaluator <NeatGenome> navigatorFitnessEvaluator =
new ParallelGenomeBehaviorEvaluator <NeatGenome, IBlackBox>(navigatorGenomeDecoder, navigatorEvaluator, SearchType.MinimalCriteriaSearch, ParallelOptions);
// Verify that the seed agent population satisfies MC constraints of both populations so that MCC starts in
// a valid state
if (isAgentListPreevolved &&
VerifyPreevolvedSeedAgents(genomeList1, genomeList2, navigatorFitnessEvaluator, mazeFitnessEvaluator) ==
false)
{
throw new SharpNeatException("Seed agent population failed viability verification.");
}
// Create the MCC container
IMCCAlgorithmContainer <NeatGenome, MazeGenome> mccAlgorithmContainer =
new MCCAlgorithmContainer <NeatGenome, MazeGenome>(neatEvolutionAlgorithm, mazeEvolutionAlgorithm);
// Initialize the container and component algorithms
mccAlgorithmContainer.Initialize(navigatorFitnessEvaluator, genomeFactory1, seedAgentPopulation,
AgentDefaultPopulationSize, mazeFitnessEvaluator, genomeFactory2, genomeList2,
MazeDefaultPopulationSize,
MaxGenerations, MaxEvaluations);
return(mccAlgorithmContainer);
}
