public virtual void Initialize(string name, XmlElement xmlConfig)
{
_name = name;
_populationSize = XmlUtils.GetValueAsInt(xmlConfig, "PopulationSize");
_specieCount = XmlUtils.GetValueAsInt(xmlConfig, "SpecieCount");
_activationScheme = ExperimentUtils.CreateActivationScheme(xmlConfig, "Activation");
_complexityRegulationStr = XmlUtils.TryGetValueAsString(xmlConfig,
"DefaultComplexityRegulationStrategy");
_complexityThreshold = XmlUtils.TryGetValueAsInt(xmlConfig, "ComplexityThreshold");
_description = XmlUtils.TryGetValueAsString(xmlConfig, "Description");
_parallelOptions = ExperimentUtils.ReadParallelOptions(xmlConfig);
_eaParams = new NeatEvolutionAlgorithmParameters();
_eaParams.SpecieCount = _specieCount;
_neatGenomeParams = new NeatGenomeParameters();
_neatGenomeParams.FeedforwardOnly = _activationScheme.AcyclicNetwork;
DefaultComplexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(
_complexityRegulationStr,
_complexityThreshold);
DefaultSpeciationStrategy = new KMeansClusteringStrategy<NeatGenome>(new ManhattanDistanceMetric(1.0, 0.0, 10.0));
DefaultNeatEvolutionAlgorithm = new NeatEvolutionAlgorithm<NeatGenome>(
NeatEvolutionAlgorithmParameters,
DefaultSpeciationStrategy,
DefaultComplexityRegulationStrategy);
}
/// <summary>
/// Construct a NEAT statistics object based on a specified set of NEAT parameters.
/// </summary>
public NeatAlgorithmStats(NeatEvolutionAlgorithmParameters eaParams)
{
// _bestFitnessMA = new DoubleCircularBufferWithStats(eaParams.BestFitnessMovingAverageHistoryLength);
_bestFitnessMA = new DoubleCircularBufferWithStats(5);
_meanSpecieChampFitnessMA = new DoubleCircularBufferWithStats(eaParams.MeanSpecieChampFitnessMovingAverageHistoryLength);
_complexityMA = new DoubleCircularBufferWithStats(eaParams.ComplexityMovingAverageHistoryLength);
}
/// <summary>
/// Initialize the experiment with configuration file parameters.
/// </summary>
/// <param name="name">The name of the experiment</param>
/// <param name="xmlConfig">The parent XML configuration element</param>
public virtual void Initialize(string name, XmlElement xmlConfig)
{
// Set all properties
Name = name;
DefaultPopulationSize = XmlUtils.GetValueAsInt(xmlConfig, "PopulationSize");
Description = XmlUtils.GetValueAsString(xmlConfig, "Description");
// Set all internal class variables
_activationScheme = ExperimentUtils.CreateActivationScheme(xmlConfig, "Activation");
ComplexityRegulationStrategy = XmlUtils.TryGetValueAsString(xmlConfig, "ComplexityRegulationStrategy");
Complexitythreshold = XmlUtils.TryGetValueAsInt(xmlConfig, "ComplexityThreshold");
ParallelOptions = ExperimentUtils.ReadParallelOptions(xmlConfig);
// Set evolution/genome parameters
NeatEvolutionAlgorithmParameters = new NeatEvolutionAlgorithmParameters
{
SpecieCount = XmlUtils.GetValueAsInt(xmlConfig, "SpecieCount"),
InterspeciesMatingProportion = XmlUtils.GetValueAsDouble(xmlConfig,
"InterspeciesMatingProbability"),
MinTimeAlive = XmlUtils.GetValueAsInt(xmlConfig, "MinTimeAlive")
};
NeatGenomeParameters = ExperimentUtils.ReadNeatGenomeParameters(xmlConfig);
// Set experiment-specific parameters
MaxTimesteps = XmlUtils.TryGetValueAsInt(xmlConfig, "MaxTimesteps");
MinSuccessDistance = XmlUtils.TryGetValueAsInt(xmlConfig, "MinSuccessDistance");
MaxDistanceToTarget = XmlUtils.TryGetValueAsInt(xmlConfig, "MaxDistanceToTarget");
MazeVariant =
MazeVariantUtl.convertStringToMazeVariant(XmlUtils.TryGetValueAsString(xmlConfig, "MazeVariant"));
}
public NeatTrainer(ExperimentSettings experimentSettings, NeatEvolutionAlgorithmParameters evolutionAlgorithmParameters, TrainingGameSettings gameSettings)
{
var neuromonPhenomeEvaluator = new NeuromonEvaluator(gameSettings, experimentSettings);
var neatGenomeParameters = new NeatGenomeParameters();
_neuromonExperiment = new NeuromonExperiment(experimentSettings, evolutionAlgorithmParameters, neuromonPhenomeEvaluator, neatGenomeParameters);
_genomeIo = new GenomeIo(_neuromonExperiment);
_genomeFactory = _neuromonExperiment.CreateGenomeFactory();
if (experimentSettings.LoadExistingPopulation)
{
_genomePopulation = _genomeIo.Read(experimentSettings.ExistingPopulationFilePath);
}
else
{
// Randomly generate a new population
_genomePopulation = _genomeFactory.CreateGenomeList(experimentSettings.PopulationSize, 0);
}
_genomeIo.CacheChampion(_genomePopulation.OrderByDescending(g => g.EvaluationInfo.Fitness).First());
_fitnessStagnationDetector = new FitnessStagnationDetector(experimentSettings.StagnationDetectionTriggerValue);
_desiredFitness = experimentSettings.DesiredFitness;
_previousGeneration = 0;
_overallBestFitness = 0.0;
}
public BraidNeatEvolutionAlgorithm(NeatEvolutionAlgorithmParameters eaParams,
ISpeciationStrategy <TGenome> speciationStrategy,
IComplexityRegulationStrategy complexityRegulationStrategy) : base(eaParams,
speciationStrategy,
complexityRegulationStrategy)
{
myLogger = new Logger(new MyLogger());
myLogger.Log(logTag, "Initialized: ");
}
/// <summary>
/// Constructs with the default NeatEvolutionAlgorithmParameters and speciation strategy
/// (KMeansClusteringStrategy with ManhattanDistanceMetric).
/// </summary>
public NeatEvolutionAlgorithm()
{
_eaParams = new NeatEvolutionAlgorithmParameters();
_eaParamsComplexifying = _eaParams;
_eaParamsSimplifying = _eaParams.CreateSimplifyingParameters();
_stats = new NeatAlgorithmStats(_eaParams);
_speciationStrategy = new KMeansClusteringStrategy <TGenome>(new ManhattanDistanceMetric());
_complexityRegulationMode = ComplexityRegulationMode.Complexifying;
_complexityRegulationStrategy = new NullComplexityRegulationStrategy();
}
private void initialize()
{
EvoParameters = new NeatEvolutionAlgorithmParameters()
{
SpecieCount = Parameters.Species
};
NeatParameters = new NeatGenomeParameters()
{
ActivationFn = PlainSigmoid.__DefaultInstance
};
}
/// <summary>
/// Constructs with the provided NeatEvolutionAlgorithmParameters and ISpeciationStrategy.
/// </summary>
public NeatEvolutionAlgorithm(NeatEvolutionAlgorithmParameters eaParams,
ISpeciationStrategy <TGenome> speciationStrategy,
IComplexityRegulationStrategy complexityRegulationStrategy)
{
_eaParams = eaParams;
_eaParamsComplexifying = _eaParams;
_eaParamsSimplifying = _eaParams.CreateSimplifyingParameters();
_stats = new NeatAlgorithmStats(_eaParams);
_speciationStrategy = speciationStrategy;
_complexityRegulationMode = ComplexityRegulationMode.Complexifying;
_complexityRegulationStrategy = complexityRegulationStrategy;
}
/// <summary>
/// Constructs with the default NeatEvolutionAlgorithmParameters and speciation strategy
/// (KMeansClusteringStrategy with ManhattanDistanceMetric).
/// </summary>
/*
* public NeatEvolutionAlgorithm()
* {
* _eaParams = new NeatEvolutionAlgorithmParameters();
* _eaParamsComplexifying = _eaParams;
* _eaParamsSimplifying = _eaParams.CreateSimplifyingParameters();
* _stats = new NeatAlgorithmStats(_eaParams);
* _speciationStrategy = new KMeansClusteringStrategy<TGenome>(new ManhattanDistanceMetric());
*
* _complexityRegulationMode = ComplexityRegulationMode.Complexifying;
* _complexityRegulationStrategy = new NullComplexityRegulationStrategy();
* }
*/
/// <summary>
/// Constructs with the provided NeatEvolutionAlgorithmParameters and ISpeciationStrategy.
/// </summary>
/*
* public NeatEvolutionAlgorithm(NeatEvolutionAlgorithmParameters eaParams,
* ISpeciationStrategy<TGenome> speciationStrategy,
* IComplexityRegulationStrategy complexityRegulationStrategy)
* {
* _eaParams = eaParams;
* _eaParamsComplexifying = _eaParams;
* _eaParamsSimplifying = _eaParams.CreateSimplifyingParameters();
* _stats = new NeatAlgorithmStats(_eaParams);
* _speciationStrategy = speciationStrategy;
*
* _complexityRegulationMode = ComplexityRegulationMode.Complexifying;
* _complexityRegulationStrategy = complexityRegulationStrategy;
* }
*/
public void Construct(NeatEvolutionAlgorithmParameters eaParams,
ISpeciationStrategy <TGenome> speciationStrategy,
IComplexityRegulationStrategy complexityRegulationStrategy,
IGenomeListEvaluator <TGenome> initialGenomeListEvaluator)
{
_eaParams = eaParams;
_eaParamsComplexifying = _eaParams;
_eaParamsSimplifying = _eaParams.CreateSimplifyingParameters();
_stats = new NeatAlgorithmStats(_eaParams);
_speciationStrategy = speciationStrategy;
_complexityRegulationMode = ComplexityRegulationMode.Complexifying;
_complexityRegulationStrategy = complexityRegulationStrategy;
_initialGenomeListEvaluator = initialGenomeListEvaluator;
}
/// <summary>
/// Initialize the experiment with configuration file parameters.
/// </summary>
/// <param name="name">The name of the experiment</param>
/// <param name="xmlConfig">The parent XML configuration element</param>
public void Initialize(string name, XmlElement xmlConfig)
{
// Set all properties
Name = name;
DefaultPopulationSize = XmlUtils.GetValueAsInt(xmlConfig, "PopulationSize");
Description = XmlUtils.GetValueAsString(xmlConfig, "Description");
// Set all internal class variables
_activationScheme = ExperimentUtils.CreateActivationScheme(xmlConfig, "Activation");
_complexityRegulationStrategy = XmlUtils.TryGetValueAsString(xmlConfig, "ComplexityRegulationStrategy");
_complexitythreshold = XmlUtils.TryGetValueAsInt(xmlConfig, "ComplexityThreshold");
_parallOptions = ExperimentUtils.ReadParallelOptions(xmlConfig);
// Set evolution/genome parameters
NeatEvolutionAlgorithmParameters = new NeatEvolutionAlgorithmParameters();
NeatEvolutionAlgorithmParameters.SpecieCount = XmlUtils.GetValueAsInt(xmlConfig, "SpecieCount");
NeatGenomeParameters = new NeatGenomeParameters();
}
public NeuromonExperiment(ExperimentSettings experimentSettings, NeatEvolutionAlgorithmParameters evolutionAlgorithmParameters, IPhenomeEvaluator<IBlackBox> neuromonPhenomeEvaluator, NeatGenomeParameters genomeParameters)
{
Name = experimentSettings.ExperimentName;
Description = experimentSettings.Description;
InputCount = experimentSettings.InputCount;
OutputCount = experimentSettings.OutputCount;
DefaultPopulationSize = experimentSettings.PopulationSize;
_neuromonPhenomeEvaluator = neuromonPhenomeEvaluator;
_complexityRegulationStrategy = experimentSettings.ComplexityRegulationStrategy;
_complexityThreshold = experimentSettings.ComplexityThreshold;
// Removed from .xml configuration. TODO: Possibly make configurable via json config
_networkActivationScheme = NetworkActivationScheme.CreateCyclicFixedTimestepsScheme(1);
NeatEvolutionAlgorithmParameters = evolutionAlgorithmParameters;
NeatGenomeParameters = genomeParameters;
}
/// <summary>
/// Construct a NEAT statistics object based on a specified set of NEAT parameters.
/// </summary>
public NeatAlgorithmStats(NeatEvolutionAlgorithmParameters eaParams)
{
_bestFitnessMA = new DoubleCircularBufferWithStats(eaParams.BestFitnessMovingAverageHistoryLength);
_meanSpecieChampFitnessMA = new DoubleCircularBufferWithStats(eaParams.MeanSpecieChampFitnessMovingAverageHistoryLength);
_complexityMA = new DoubleCircularBufferWithStats(eaParams.ComplexityMovingAverageHistoryLength);
}
public void Initialize(string name, XmlElement xmlConfig)
{
// Read these from Domain XML file
_name = name;
_populationSize = XmlUtils.GetValueAsInt(xmlConfig, "PopulationSize");
_specieCount = XmlUtils.GetValueAsInt(xmlConfig, "SpecieCount");
_activationSchemeCppn = ExperimentUtils.CreateActivationScheme(xmlConfig, "ActivationCppn");
_activationScheme = ExperimentUtils.CreateActivationScheme(xmlConfig, "Activation");
_complexityRegulationStr = XmlUtils.TryGetValueAsString(xmlConfig, "ComplexityRegulationStrategy");
_complexityThreshold = XmlUtils.TryGetValueAsInt(xmlConfig, "ComplexityThreshold");
_description = XmlUtils.TryGetValueAsString(xmlConfig, "Description");
_parallelOptions = ExperimentUtils.ReadParallelOptions(xmlConfig);
_parallelOptions.MaxDegreeOfParallelism = Environment.ProcessorCount / 2;
_visualFieldResolution = XmlUtils.GetValueAsInt(xmlConfig, "Resolution");
_visualFieldPixelCount = _visualFieldResolution * _visualFieldResolution;
_lengthCppnInput = XmlUtils.GetValueAsBool(xmlConfig, "LengthCppnInput");
_eaParams = new NeatEvolutionAlgorithmParameters();
_eaParams.SpecieCount = _specieCount;
// Set these manually, use a high mutator just to test the water
_neatGenomeParams = new NeatGenomeParameters()
{
AddConnectionMutationProbability = 0.10,
DeleteConnectionMutationProbability = 0.10,
ConnectionWeightMutationProbability = 0.90,
AddNodeMutationProbability = 0.05,
InitialInterconnectionsProportion = 0.10
};
// Clear OUTPUT and FITNESS directories before starting
var directory = new DirectoryInfo(Constants.OUTPUT_DIR);
directory.Empty();
directory = new DirectoryInfo(Constants.FITNESS_DIR);
directory.Empty();
directory = new DirectoryInfo(Constants.PLOTS_DIR);
directory.Empty();
}
/// <summary>
/// Initialize the experiment with some optional XML configuration data.
/// </summary>
public void Initialize(string name, XmlElement xmlConfig)
{
_name = name;
_populationSize = XmlUtils.GetValueAsInt(xmlConfig, "PopulationSize");
_specieCount = XmlUtils.GetValueAsInt(xmlConfig, "SpecieCount");
_activationScheme = ExperimentUtils.CreateActivationScheme(xmlConfig, "Activation");
_complexityRegulationStr = XmlUtils.TryGetValueAsString(xmlConfig, "ComplexityRegulationStrategy");
_complexityThreshold = XmlUtils.TryGetValueAsInt(xmlConfig, "ComplexityThreshold");
_description = XmlUtils.TryGetValueAsString(xmlConfig, "Description");
_parallelOptions = ExperimentUtils.ReadParallelOptions(xmlConfig);
_eaParams = new NeatEvolutionAlgorithmParameters();
_eaParams.SpecieCount = _specieCount;
_neatGenomeParams = new NeatGenomeParameters();
_neatGenomeParams.FeedforwardOnly = _activationScheme.AcyclicNetwork;
// Determine what function to regress.
string fnIdStr = XmlUtils.GetValueAsString(xmlConfig, "Function");
FunctionId fnId = (FunctionId)Enum.Parse(typeof(FunctionId), fnIdStr);
_func = FunctionRegressionEvaluator.GetFunction(fnId);
// Read parameter sampling scheme settings.
int sampleResolution = XmlUtils.GetValueAsInt(xmlConfig, "SampleResolution");
double sampleMin = XmlUtils.GetValueAsDouble(xmlConfig, "SampleMin");
double sampleMax = XmlUtils.GetValueAsDouble(xmlConfig, "SampleMax");
int paramCount = _func.InputCount;
_paramSamplingInfoArr = new ParameterSamplingInfo[paramCount];
for(int i=0; i<paramCount; i++) {
_paramSamplingInfoArr[i] = new ParameterSamplingInfo(sampleMin, sampleMax, sampleResolution);
}
}
/// <summary>
/// Initialize the experiment with some optional XML configutation data.
/// </summary>
public void Initialize(string name, XmlElement xmlConfig)
{
_name = name;
_populationSize = XmlUtils.GetValueAsInt(xmlConfig, "PopulationSize");
_specieCount = XmlUtils.GetValueAsInt(xmlConfig, "SpecieCount");
_activationScheme = ExperimentUtils.CreateActivationScheme(xmlConfig, "Activation");
_complexityRegulationStr = XmlUtils.TryGetValueAsString(xmlConfig, "ComplexityRegulationStrategy");
_complexityThreshold = XmlUtils.TryGetValueAsInt(xmlConfig, "ComplexityThreshold");
_description = XmlUtils.TryGetValueAsString(xmlConfig, "Description");
_timeStepsPerGeneration = (ulong)XmlUtils.GetValueAsInt(xmlConfig, "TimeStepsPerGeneration");
_stepReward = XmlUtils.GetValueAsInt(xmlConfig, "StepReward");
_agentType =(AgentTypes) Enum.Parse(typeof(AgentTypes), XmlUtils.TryGetValueAsString(xmlConfig, "AgentType"));
_plantLayout = (PlantLayoutStrategies)Enum.Parse(typeof(PlantLayoutStrategies), XmlUtils.TryGetValueAsString(xmlConfig, "PlantLayout"));
_paradigm = (EvolutionParadigm)Enum.Parse(typeof(EvolutionParadigm), XmlUtils.TryGetValueAsString(xmlConfig, "EvolutionParadigm"));
bool? diverse = XmlUtils.TryGetValueAsBool(xmlConfig, "LogDiversity");
if (diverse.HasValue && diverse.Value)
_logDiversity = true;
if (_agentType == AgentTypes.Social)
{
var memSection = xmlConfig.GetElementsByTagName("Memory")[0] as XmlElement;
_memory = (MemoryParadigm)Enum.Parse(typeof(MemoryParadigm), XmlUtils.TryGetValueAsString(memSection, "Paradigm"));
SocialAgent.DEFAULT_MEMORY_SIZE = XmlUtils.GetValueAsInt(memSection, "Size");
if (_memory == MemoryParadigm.IncrementalGrowth)
{
_memGens = XmlUtils.GetValueAsInt(memSection, "GrowthGenerations");
_maxMemorySize = XmlUtils.GetValueAsInt(memSection, "MaxSize");
}
_teaching = (TeachingParadigm)Enum.Parse(typeof(TeachingParadigm), XmlUtils.TryGetValueAsString(xmlConfig, "TeachingParadigm"));
}
var species = new List<PlantSpecies>();
var plants = xmlConfig.GetElementsByTagName("Plant");
for (int i = 0; i < plants.Count; i++)
{
var plant = plants[i] as XmlElement;
species.Add(new PlantSpecies(i)
{
Name = XmlUtils.GetValueAsString(plant, "Name"),
Radius = XmlUtils.GetValueAsInt(plant, "Radius"),
Reward = XmlUtils.GetValueAsInt(plant, "Reward"),
Count = XmlUtils.GetValueAsInt(plant, "Count")
});
}
Random random = new Random();
var agents = new List<ForagingAgent>();
const int NUM_AGENTS = 10;
for (int i = 0; i < NUM_AGENTS; i++)
{
agents.Add(new SpinningAgent(i) { X = random.Next(500), Y = random.Next(500), Orientation = random.Next(360) });
}
List<Predator> predators = new List<Predator>();
_predCount = XmlUtils.GetValueAsInt(xmlConfig, "Predators");
var predStr = XmlUtils.TryGetValueAsString(xmlConfig, "PredatorDistribution");
if (predStr != null)
PredatorDistribution = (PredatorDistributionTypes)Enum.Parse(typeof(PredatorDistributionTypes), predStr, true);
_predTypes = XmlUtils.GetValueAsInt(xmlConfig, "PredatorTypes");
if (PredatorDistribution == PredatorDistributionTypes.Alternating)
_predGens = XmlUtils.GetValueAsDouble(xmlConfig, "PredatorGenerations");
_distinguishPreds = XmlUtils.GetValueAsBool(xmlConfig, "DistinguishPredators");
_world = new World(agents, XmlUtils.GetValueAsInt(xmlConfig, "WorldHeight"), XmlUtils.GetValueAsInt(xmlConfig, "WorldHeight"), species, predators)
{
AgentHorizon = XmlUtils.GetValueAsInt(xmlConfig, "AgentHorizon"),
PlantLayoutStrategy = _plantLayout,
StepReward = _stepReward,
PredatorTypes = _predTypes
};
var outputs = XmlUtils.TryGetValueAsInt(xmlConfig, "Outputs");
var navigation = XmlUtils.TryGetValueAsBool(xmlConfig, "AgentsNavigate");
var hiding = XmlUtils.TryGetValueAsBool(xmlConfig, "AgentsHide");
_navigationEnabled = navigation.HasValue ? navigation.Value : false;
_hidingEnabled = hiding.HasValue ? hiding.Value : false;
if (!outputs.HasValue)
{
if (_navigationEnabled || _hidingEnabled)
_outputs = (_navigationEnabled ? 2 : 0) + (_hidingEnabled ? _predTypes + 1 : 0);
else
_outputs = outputs.HasValue ? outputs.Value : 2;
}
else
_outputs = outputs.Value;
var inputs = XmlUtils.TryGetValueAsInt(xmlConfig, "Inputs");
_inputs = inputs.HasValue ? inputs.Value : _world.PlantTypes.Count() * World.SENSORS_PER_OBJECT_TYPE + (_distinguishPreds ? _predTypes : 1) * World.SENSORS_PER_OBJECT_TYPE + 1;
_eaParams = new NeatEvolutionAlgorithmParameters();
_eaParams.SpecieCount = _specieCount;
_neatGenomeParams = new NeatGenomeParameters()
{
ActivationFn = PlainSigmoid.__DefaultInstance
};
if (_teaching != TeachingParadigm.EgalitarianEvolvedAcceptability)
_neatGenomeParams.InitialInterconnectionsProportion = 0.1;
}
/// <summary>
/// Initialize the experiment with some optional XML configutation data.
/// </summary>
public void Initialize(string name, XmlElement xmlConfig)
{
_name = name;
_populationSize = XmlUtils.GetValueAsInt(xmlConfig, "PopulationSize");
_specieCount = XmlUtils.GetValueAsInt(xmlConfig, "SpecieCount");
_activationSchemeCppn = ExperimentUtils.CreateActivationScheme(xmlConfig, "ActivationCppn");
_activationScheme = ExperimentUtils.CreateActivationScheme(xmlConfig, "Activation");
_complexityRegulationStr = XmlUtils.TryGetValueAsString(xmlConfig, "ComplexityRegulationStrategy");
_complexityThreshold = XmlUtils.TryGetValueAsInt(xmlConfig, "ComplexityThreshold");
_description = XmlUtils.TryGetValueAsString(xmlConfig, "Description");
_parallelOptions = ExperimentUtils.ReadParallelOptions(xmlConfig);
_lengthCppnInput = XmlUtils.GetValueAsBool(xmlConfig, "LengthCppnInput");
_eaParams = new NeatEvolutionAlgorithmParameters();
_eaParams.SpecieCount = _specieCount;
_neatGenomeParams = new NeatGenomeParameters();
_neatGenomeParams.FeedforwardOnly = _activationSchemeCppn.AcyclicNetwork;
_neatGenomeParams.InitialInterconnectionsProportion = 0.5;
}
public void Initialize(string name, XmlElement xmlConfig, int input, int output)
{
_name = name;
_populationSize = XmlUtils.GetValueAsInt(xmlConfig, "PopulationSize");
_specieCount = XmlUtils.GetValueAsInt(xmlConfig, "SpecieCount");
_activationScheme = ExperimentUtils.CreateActivationScheme(xmlConfig, "Activation");
_complexityRegulationStr = XmlUtils.TryGetValueAsString(xmlConfig, "ComplexityRegulationStrategy");
_complexityThreshold = XmlUtils.TryGetValueAsInt(xmlConfig, "ComplexityThreshold");
_description = XmlUtils.TryGetValueAsString(xmlConfig, "Description");
_eaParams = new NeatEvolutionAlgorithmParameters();
_eaParams.SpecieCount = _specieCount;
_neatGenomeParams = new NeatGenomeParameters();
_neatGenomeParams.FeedforwardOnly = _activationScheme.AcyclicNetwork;
_inputCount = input;
_outputCount = output;
}
/// <summary>
/// Initialize the experiment with some optional XML configutation data.
/// </summary>
public void Initialize(string name, XmlElement xmlConfig)
{
_name = name;
_description = "Just a test experiment class";
// Dont use xml, just hard code the values for now
_populationSize = 50;
_specieCount = 5;
// PicBreeder appears to use acyclic networks, so we will do the same.
// Cyclic ("recurrent") networks seem better for realtime reactive controllers, e.g. predator-prey, where the recurrent connections allow for memory of past events
_activationScheme = NetworkActivationScheme.CreateAcyclicScheme();
// Next two values just seem to be commen.
// Relative just means that limit of complexification is relative to the last simplification process (so it can continue to grow)
// Alternative is "Absolute", which means, with a threshold of 10, network wont ever be more complex than 10 connections
_complexityRegulationStr = "Absolute";
_complexityThreshold = 50;
//_parallelOptions = new ParallelOptions();
// Param constructors set defaul param values, a lot of experiments just leave them as default
_eaParams = new NeatEvolutionAlgorithmParameters();
_eaParams.SpecieCount = _specieCount;
_neatGenomeParams = new NeatGenomeParameters();
_neatGenomeParams.FeedforwardOnly = _activationScheme.AcyclicNetwork;
}
/// <summary>
/// Initialize the experiment with some optional XML configutation data.
/// </summary>
public void Initialize(string name, XmlElement xmlConfig)
{
_name = name;
_populationSize = XmlUtils.GetValueAsInt(xmlConfig, "PopulationSize");
_specieCount = XmlUtils.GetValueAsInt(xmlConfig, "SpecieCount");
_activationScheme = ExperimentUtils.CreateActivationScheme(xmlConfig, "Activation");
_complexityRegulationStr = XmlUtils.TryGetValueAsString(xmlConfig, "ComplexityRegulationStrategy");
_complexityThreshold = XmlUtils.TryGetValueAsInt(xmlConfig, "ComplexityThreshold");
_description = XmlUtils.TryGetValueAsString(xmlConfig, "Description");
_parallelOptions = ExperimentUtils.ReadParallelOptions(xmlConfig);
_eaParams = new NeatEvolutionAlgorithmParameters();
_eaParams.SpecieCount = _specieCount;
_neatGenomeParams = new NeatGenomeParameters();
}
/// <summary>
/// Initializes the experiment with some optional XML configutation data.
/// </summary>
/// <param name="name">The name of the experiment.</param>
/// <param name="xmlConfig">The reference to the top-level configuration element for the experiment.</param>
public void Initialize(string name, XmlElement xmlConfig)
{
// Read in boiler plate configuration settings
Name = name;
Description = XmlUtils.TryGetValueAsString(xmlConfig, "Description");
DefaultPopulationSize = XmlUtils.GetValueAsInt(xmlConfig, "PopulationSize");
InputCount = OutputCount = XmlUtils.GetValueAsInt(xmlConfig, "AutoencoderSize");
_numInitialHiddenNodes = XmlUtils.GetValueAsInt(xmlConfig, "NumInitialHiddenNodes");
// Read in algorithm/logging configuration
_activationScheme = ExperimentUtils.CreateActivationScheme(xmlConfig, "Activation");
_complexityRegulationStr = XmlUtils.TryGetValueAsString(xmlConfig, "ComplexityRegulationStrategy");
_complexityThreshold = XmlUtils.TryGetValueAsInt(xmlConfig, "ComplexityThreshold");
_parallelOptions = ExperimentUtils.ReadParallelOptions(xmlConfig);
_generationalLogFile = XmlUtils.TryGetValueAsString(xmlConfig, "GenerationalLogFile");
// Construct NEAT EA parameters
NeatEvolutionAlgorithmParameters = new NeatEvolutionAlgorithmParameters();
NeatEvolutionAlgorithmParameters.SpecieCount = XmlUtils.GetValueAsInt(xmlConfig, "SpecieCount");
// Construct NEAT genome parameters
NeatGenomeParameters = ExperimentUtils.ReadNeatGenomeParameters(xmlConfig);
NeatGenomeParameters.FeedforwardOnly = _activationScheme.AcyclicNetwork;
NeatGenomeParameters.ActivationFn = PlainSigmoid.__DefaultInstance;
// Read in experiment domain-specific parameters
_trainingImagesFilename = XmlUtils.TryGetValueAsString(xmlConfig, "TrainingImages");
_numImageSamples = XmlUtils.GetValueAsInt(xmlConfig, "NumImageSamples");
_learningRate = XmlUtils.GetValueAsDouble(xmlConfig, "LearningRate");
_numBackpropIterations = XmlUtils.GetValueAsInt(xmlConfig, "NumBackpropagationIterations");
_trainingSampleProportion = XmlUtils.GetValueAsDouble(xmlConfig, "TrainingSampleProportion");
}
/// <summary>
/// Initialize the experiment with some optional XML configutation data.
/// </summary>
public void Initialize(string name, XmlElement xmlConfig)
{
_name = name;
var outputs = XmlUtils.TryGetValueAsInt(xmlConfig, "Outputs");
_outputs = outputs.HasValue ? outputs.Value : 2;
_populationSize = XmlUtils.GetValueAsInt(xmlConfig, "PopulationSize");
_specieCount = XmlUtils.GetValueAsInt(xmlConfig, "SpecieCount");
_activationScheme = ExperimentUtils.CreateActivationScheme(xmlConfig, "Activation");
_complexityRegulationStr = XmlUtils.TryGetValueAsString(xmlConfig, "ComplexityRegulationStrategy");
_complexityThreshold = XmlUtils.TryGetValueAsInt(xmlConfig, "ComplexityThreshold");
_description = XmlUtils.TryGetValueAsString(xmlConfig, "Description");
_timeStepsPerGeneration = (ulong)XmlUtils.GetValueAsInt(xmlConfig, "TimeStepsPerGeneration");
_eaParams = new NeatEvolutionAlgorithmParameters();
_eaParams.SpecieCount = _specieCount;
_neatGenomeParams = new NeatGenomeParameters()
{
ActivationFn = PlainSigmoid.__DefaultInstance,
InitialInterconnectionsProportion = 1,
};
}
/// <summary>
/// Initialize the experiment with some optional XML configuration data.
/// </summary>
public void Initialize(string name, XmlElement xmlConfig)
{
_name = name;
_populationSize = XmlUtils.GetValueAsInt(xmlConfig, "PopulationSize");
_specieCount = XmlUtils.GetValueAsInt(xmlConfig, "SpecieCount");
_activationScheme = ExperimentUtils.CreateActivationScheme(xmlConfig, "Activation");
_complexityRegulationStr = XmlUtils.TryGetValueAsString(xmlConfig, "ComplexityRegulationStrategy");
_complexityThreshold = XmlUtils.TryGetValueAsInt(xmlConfig, "ComplexityThreshold");
_description = XmlUtils.TryGetValueAsString(xmlConfig, "Description");
_parallelOptions = ExperimentUtils.ReadParallelOptions(xmlConfig);
_eaParams = new NeatEvolutionAlgorithmParameters();
_eaParams.SpecieCount = _specieCount;
_eaParams.SelectionProportion = 0.5;
_eaParams.ElitismProportion = 0.5;
_eaParams.OffspringAsexualProportion = 0.95;
_eaParams.OffspringSexualProportion = 0.05;
_eaParams.InterspeciesMatingProportion = 0.00;
_neatGenomeParams = new NeatGenomeParameters();
_neatGenomeParams.AddConnectionMutationProbability = 0.1;
_neatGenomeParams.AddNodeMutationProbability = 0.01;
_neatGenomeParams.ConnectionWeightMutationProbability = 0.89;
_neatGenomeParams.InitialInterconnectionsProportion = 0.05;
}
/// <summary>
/// Initialize the experiment with some optional XML configutation data.
/// </summary>
public void Initialize(string name, XmlElement xmlConfig)
{
_name = name;
_populationSize = XmlUtils.GetValueAsInt(xmlConfig, "PopulationSize");
_specieCount = XmlUtils.GetValueAsInt(xmlConfig, "SpecieCount");
_activationScheme = ExperimentUtils.CreateActivationScheme(xmlConfig, "Activation");
_complexityRegulationStr = XmlUtils.TryGetValueAsString(xmlConfig, "ComplexityRegulationStrategy");
_complexityThreshold = XmlUtils.TryGetValueAsInt(xmlConfig, "ComplexityThreshold");
_description = XmlUtils.TryGetValueAsString(xmlConfig, "Description");
_parallelOptions = ExperimentUtils.ReadParallelOptions(xmlConfig);
ExperimentUtils.ReadRbfAuxArgMutationConfig(xmlConfig, out _rbfMutationSigmaCenter, out _rbfMutationSigmaRadius);
_eaParams = new NeatEvolutionAlgorithmParameters();
_eaParams.SpecieCount = _specieCount;
_neatGenomeParams = new NeatGenomeParameters();
_neatGenomeParams.ConnectionWeightMutationProbability = 0.788;
_neatGenomeParams.AddConnectionMutationProbability = 0.001;
_neatGenomeParams.AddConnectionMutationProbability = 0.01;
_neatGenomeParams.NodeAuxStateMutationProbability = 0.2;
_neatGenomeParams.DeleteConnectionMutationProbability = 0.001;
_neatGenomeParams.FeedforwardOnly = _activationScheme.AcyclicNetwork;
}
/// <summary>
/// Initialize the experiment with some optional XML configutation data.
/// </summary>
public void Initialize(string name, XmlElement xmlConfig)
{
_name = name;
_populationSize = XmlUtils.GetValueAsInt(xmlConfig, "PopulationSize");
_specieCount = XmlUtils.GetValueAsInt(xmlConfig, "SpecieCount");
_activationScheme = ExperimentUtils.CreateActivationScheme(xmlConfig, "Activation");
_complexityThreshold = XmlUtils.TryGetValueAsInt(xmlConfig, "ComplexityThreshold");
_description = XmlUtils.TryGetValueAsString(xmlConfig, "Description");
_parallelOptions = ExperimentUtils.ReadParallelOptions(xmlConfig);
_guesses = XmlUtils.GetValueAsInt(xmlConfig, "Guesses");
Hashed = XmlUtils.TryGetValueAsBool(xmlConfig, "Hashed").HasValue ? XmlUtils.GetValueAsBool(xmlConfig, "Hashed") : false;
ValidationGuesses = XmlUtils.GetValueAsInt(xmlConfig, "ValidationGuesses");
// Load the passwords from file
string pwdfile = XmlUtils.TryGetValueAsString(xmlConfig, "ValidationPasswordFile");
if (pwdfile != null)
{
Console.Write("Loading passwords from [{0}]...", pwdfile);
if (_passwords == null || _passwords.Count == 0)
{
int? pwLength = XmlUtils.TryGetValueAsInt(xmlConfig, "PasswordLength");
if (pwLength.HasValue)
Console.Write("Filtering to {0}-character passwords...", pwLength.Value);
_passwords = PasswordUtil.LoadPasswords(pwdfile, pwLength);
}
else
Console.WriteLine("WARNING: Not loading passwords for experiment (already set)");
}
else
Console.WriteLine("WARNING: Not loading passwords for experiment (not provided in config file)");
_eaParams = new NeatEvolutionAlgorithmParameters();
_eaParams.SpecieCount = _specieCount;
_neatGenomeParams = new NeatGenomeParameters();
_neatGenomeParams.FeedforwardOnly = false;
_neatGenomeParams.AddNodeMutationProbability = 0.03;
_neatGenomeParams.AddConnectionMutationProbability = 0.05;
// TODO: Load states from XML config file
// Generates all the valid states in the MC using all viable ASCII characters
var stateList = new List<string>();
for (uint i = 32; i < 127; i++)
stateList.Add(((char)i).ToString());
stateList.Add(null);
_states = stateList.ToArray();
_activationFnLibrary = MarkovActivationFunctionLibrary.CreateLibraryMc(_states);
}
/// <summary>
/// Initialize the experiment with some optional XML configutation data.
/// </summary>
public void Initialize(string name, XmlElement xmlConfig)
{
_name = name;
_populationSize = XmlUtils.GetValueAsInt(xmlConfig, "PopulationSize");
_specieCount = XmlUtils.GetValueAsInt(xmlConfig, "SpecieCount");
_activationScheme = ExperimentUtils.CreateActivationScheme(xmlConfig, "Activation");
_complexityRegulationStr = XmlUtils.TryGetValueAsString(xmlConfig, "ComplexityRegulationStrategy");
_complexityThreshold = XmlUtils.TryGetValueAsInt(xmlConfig, "ComplexityThreshold");
_trialsPerEvaluation = XmlUtils.GetValueAsInt(xmlConfig, "TrialsPerEvaluation");
_gridSize = XmlUtils.GetValueAsInt(xmlConfig, "GridSize");
_preyInitMoves = XmlUtils.GetValueAsInt(xmlConfig, "PreyInitMoves");
_preySpeed = XmlUtils.GetValueAsDouble(xmlConfig, "PreySpeed");
_sensorRange = XmlUtils.GetValueAsDouble(xmlConfig, "SensorRange");
_maxTimesteps = XmlUtils.GetValueAsInt(xmlConfig, "MaxTimesteps");
_description = XmlUtils.TryGetValueAsString(xmlConfig, "Description");
_parallelOptions = ExperimentUtils.ReadParallelOptions(xmlConfig);
_eaParams = new NeatEvolutionAlgorithmParameters();
_eaParams.SpecieCount = _specieCount;
_neatGenomeParams = new NeatGenomeParameters();
}
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);
}
/// <summary>
/// Progress forward by one generation. Perform one generation/iteration of the evolution algorithm.
/// </summary>
protected override void PerformOneGeneration()
{
// Calculate statistics for each specie (mean fitness, target size, number of offspring to produce etc.)
int offspringCount;
SpecieStats[] specieStatsArr = CalcSpecieStats(out offspringCount);
// Create offspring.
List <TGenome> offspringList = CreateOffspring(specieStatsArr, offspringCount);
// Trim species back to their elite genomes.
bool emptySpeciesFlag = TrimSpeciesBackToElite(specieStatsArr);
// Rebuild _genomeList. It will now contain just the elite genomes.
RebuildGenomeList();
// Append offspring genomes to the elite genomes in _genomeList. We do this before calling the
// _genomeListEvaluator.Evaluate because some evaluation schemes re-evaluate the elite genomes
// (otherwise we could just evaluate offspringList).
_genomeList.AddRange(offspringList);
// Evaluate genomes.
_genomeListEvaluator.Evaluate(_genomeList);
// Integrate offspring into species.
if (emptySpeciesFlag)
{
// We have one or more terminated species. Therefore we need to fully re-speciate all genomes to divide them
// evenly between the required number of species.
// Clear all genomes from species (we still have the elite genomes in _genomeList).
ClearAllSpecies();
// Speciate genomeList.
_speciationStrategy.SpeciateGenomes(_genomeList, _specieList);
}
else
{
// Integrate offspring into the existing species.
_speciationStrategy.SpeciateOffspring(offspringList, _specieList);
}
Debug.Assert(!TestForEmptySpecies(_specieList), "Speciation resulted in one or more empty species.");
// Sort the genomes in each specie. Fittest first (secondary sort - youngest first).
SortSpecieGenomes();
// Update stats and store reference to best genome.
UpdateBestGenome();
UpdateStats();
// Determine the complexity regulation mode and switch over to the appropriate set of evolution
// algorithm parameters. Also notify the genome factory to allow it to modify how it creates genomes
// (e.g. reduce or disable additive mutations).
_complexityRegulationMode = _complexityRegulationStrategy.DetermineMode(_stats);
_genomeFactory.SearchMode = (int)_complexityRegulationMode;
switch (_complexityRegulationMode)
{
case ComplexityRegulationMode.Complexifying:
_eaParams = _eaParamsComplexifying;
break;
case ComplexityRegulationMode.Simplifying:
_eaParams = _eaParamsSimplifying;
break;
}
// TODO: More checks.
Debug.Assert(_genomeList.Count == _populationSize);
}
/// <summary>
/// Initialize the experiment with some optional XML configutation data.
/// </summary>
public void Initialize(string name, XmlElement xmlConfig)
{
Name = name;
DefaultPopulationSize = XmlUtils.GetValueAsInt(xmlConfig, "PopulationSize");
_specieCount = XmlUtils.GetValueAsInt(xmlConfig, "SpecieCount");
_activationScheme = ExperimentUtils.CreateActivationScheme(xmlConfig, "Activation");
_complexityRegulationStr = XmlUtils.TryGetValueAsString(xmlConfig, "ComplexityRegulationStrategy");
_complexityThreshold = XmlUtils.TryGetValueAsInt(xmlConfig, "ComplexityThreshold");
Description = XmlUtils.TryGetValueAsString(xmlConfig, "Description");
_parallelOptions = ExperimentUtils.ReadParallelOptions(xmlConfig);
_generationalLogFile = XmlUtils.TryGetValueAsString(xmlConfig, "GenerationalLogFile");
NeatEvolutionAlgorithmParameters = new NeatEvolutionAlgorithmParameters();
NeatEvolutionAlgorithmParameters.SpecieCount = _specieCount;
NeatGenomeParameters = new NeatGenomeParameters();
NeatGenomeParameters.FeedforwardOnly = _activationScheme.AcyclicNetwork;
NeatGenomeParameters.ActivationFn = PlainSigmoid.__DefaultInstance;
}
/// <summary>
/// Initialize the experiment with some optional XML configutation data.
/// </summary>
public void Initialize(string name, XmlElement xmlConfig)
{
_name = name;
_populationSize = XmlUtils.GetValueAsInt(xmlConfig, "PopulationSize");
_specieCount = XmlUtils.GetValueAsInt(xmlConfig, "SpecieCount");
_activationSchemeCppn = ExperimentUtils.CreateActivationScheme(xmlConfig, "ActivationCppn");
_activationScheme = ExperimentUtils.CreateActivationScheme(xmlConfig, "Activation");
_complexityRegulationStr = XmlUtils.TryGetValueAsString(xmlConfig, "ComplexityRegulationStrategy");
_complexityThreshold = XmlUtils.TryGetValueAsInt(xmlConfig, "ComplexityThreshold");
_description = XmlUtils.TryGetValueAsString(xmlConfig, "Description");
_parallelOptions = ExperimentUtils.ReadParallelOptions(xmlConfig);
_visualFieldResolution = XmlUtils.GetValueAsInt(xmlConfig, "Resolution");
_visualFieldPixelCount = _visualFieldResolution * _visualFieldResolution;
_lengthCppnInput = XmlUtils.GetValueAsBool(xmlConfig, "LengthCppnInput");
_eaParams = new NeatEvolutionAlgorithmParameters();
_eaParams.SpecieCount = _specieCount;
_neatGenomeParams = new NeatGenomeParameters();
//_neatGenomeParams = ExperimentUtils.ReadNeatGenomeParameters(xmlConfig);
_resolutionReductionPerSide = XmlUtils.GetValueAsInt(xmlConfig, "ResolutionReductionPerSide");
// Read in experiment domain-specific parameters
_trainingImagesFilename = XmlUtils.TryGetValueAsString(xmlConfig, "TrainingImages");
_numImageSamples = XmlUtils.GetValueAsInt(xmlConfig, "NumImageSamples");
_learningRate = XmlUtils.GetValueAsDouble(xmlConfig, "LearningRate");
_numBackpropIterations = XmlUtils.GetValueAsInt(xmlConfig, "NumBackpropagationIterations");
_trainingSampleProportion = XmlUtils.GetValueAsDouble(xmlConfig, "TrainingSampleProportion");
}
/// <summary>
/// Constructs and initializes the initialization algorithm.
/// </summary>
/// <param name="xmlConfig">The XML configuration for the initialization algorithm.</param>
/// <param name="inputCount">The number of input neurons.</param>
/// <param name="outputCount">The number of output neurons.</param>
/// <returns>The constructed initialization algorithm.</returns>
public virtual void SetAlgorithmParameters(XmlElement xmlConfig, int inputCount, int outputCount)
{
// Read NEAT genome parameters
// Save off genome parameters specifically for the initialization algorithm
// (this is primarily because the initialization algorithm will quite likely have different NEAT parameters)
NeatGenomeParameters = ExperimentUtils.ReadNeatGenomeParameters(xmlConfig);
NeatGenomeParameters.FeedforwardOnly = NetworkActivationScheme.CreateAcyclicScheme().AcyclicNetwork;
// Read NEAT evolution parameters
NeatEvolutionAlgorithmParameters = ExperimentUtils.ReadNeatEvolutionAlgorithmParameters(xmlConfig);
// Get complexity constraint parameters
ComplexityRegulationStrategyDefinition = XmlUtils.TryGetValueAsString(xmlConfig,
"ComplexityRegulationStrategy");
ComplexityThreshold = XmlUtils.TryGetValueAsInt(xmlConfig, "ComplexityThreshold");
}