/// <summary>
        ///     Maze Navigator MCS evaluator constructor.
        /// </summary>
        /// <param name="minSuccessDistance">The minimum distance from the target to be considered a successful run.</param>
        /// <param name="behaviorCharacterizationFactory">The initialized behavior characterization factory.</param>
        /// <param name="agentNumSuccessesCriteria">
        ///     The number of mazes that must be solved successfully in order to satisfy the
        ///     minimal criterion.
        /// </param>
        public MazeNavigatorMCCEvaluator(int minSuccessDistance,
                                         IBehaviorCharacterizationFactory behaviorCharacterizationFactory, int agentNumSuccessesCriteria)
        {
            _behaviorCharacterizationFactory = behaviorCharacterizationFactory;
            _agentNumSuccessesCriteria       = agentNumSuccessesCriteria;
            EvaluationCount = 0;

            // Create factory for generating multiple mazes
            _multiMazeWorldFactory = new MultiMazeNavigationWorldFactory <BehaviorInfo>(minSuccessDistance);
        }
        /// <summary>
        ///     Maze Environment MCS evaluator constructor.
        /// </summary>
        /// <param name="minSuccessDistance">The minimum distance from the target to be considered a successful run.</param>
        /// <param name="behaviorCharacterizationFactory">The initialized behavior characterization factory.</param>
        /// <param name="numAgentsSolvedCriteria">
        ///     The number of successful attempts at maze navigation in order to satisfy the
        ///     minimal criterion.
        /// </param>
        /// <param name="numAgentsFailedCriteria">
        ///     The number of failed attempts at maze navigation in order to satisfy the minimal
        ///     criterion.
        /// </param>
        public MazeEnvironmentMCCEvaluator(int minSuccessDistance,
                                           IBehaviorCharacterizationFactory behaviorCharacterizationFactory, int numAgentsSolvedCriteria,
                                           int numAgentsFailedCriteria)
        {
            _behaviorCharacterizationFactory = behaviorCharacterizationFactory;
            _numAgentsSolvedCriteria         = numAgentsSolvedCriteria;
            _numAgentsFailedCriteria         = numAgentsFailedCriteria;

            // Create factory for maze world generation
            _multiMazeWorldFactory = new MultiMazeNavigationWorldFactory <BehaviorInfo>(minSuccessDistance);
        }
        /// <summary>
        ///     Maze Navigator fitness initialization evaluator constructor.
        /// </summary>
        /// <param name="minSuccessDistance">The minimum distance from the target to be considered a successful run.</param>
        /// <param name="maxDistanceToTarget">The maximum distance from the target possible.</param>
        /// <param name="behaviorCharacterizationFactory">The initialized behavior characterization factory.</param>
        /// <param name="startingEvaluations">The number of evaluations from which the evaluator is starting (defaults to 0).</param>
        public MazeNavigatorNoveltySearchInitializationEvaluator(int minSuccessDistance,
                                                                 int maxDistanceToTarget, IBehaviorCharacterizationFactory behaviorCharacterizationFactory,
                                                                 ulong startingEvaluations = 0)
        {
            EvaluationCount = startingEvaluations;
            _behaviorCharacterizationFactory = behaviorCharacterizationFactory;

            // Create factory for generating mazes
            _multiMazeWorldFactory = new MultiMazeNavigationWorldFactory <BehaviorInfo>(minSuccessDistance,
                                                                                        maxDistanceToTarget);
        }
 /// <inheritdoc />
 /// <summary>
 ///     Maze Navigator fitness initialization evaluator constructor.
 /// </summary>
 /// <param name="minSuccessDistance">The minimum distance from the target to be considered a successful run.</param>
 /// <param name="maxDistanceToTarget">The maximum distance from the target possible.</param>
 /// <param name="initialMazeStructure">
 ///     The maze structure with which to seed the list of maze structures in the maze
 ///     factory.
 /// </param>
 /// <param name="behaviorCharacterizationFactory">The initialized behavior characterization factory.</param>
 /// <param name="startingEvaluations">The number of evaluations from which the evaluator is starting (defaults to 0).</param>
 public MazeNavigatorNoveltySearchInitializationEvaluator(int minSuccessDistance,
                                                          int maxDistanceToTarget, MazeStructure initialMazeStructure,
                                                          IBehaviorCharacterizationFactory behaviorCharacterizationFactory, ulong startingEvaluations = 0)
     : this(
         minSuccessDistance, maxDistanceToTarget, behaviorCharacterizationFactory, startingEvaluations)
 {
     // Add initial maze structure
     _multiMazeWorldFactory.SetMazeConfigurations(new List <MazeStructure>(1)
     {
         initialMazeStructure
     });
 }
        /// <summary>
        ///     Constructs and initializes the maze navigator initialization algorithm (fitness using generational selection).  In
        ///     particular, this sets additional novelty search configuration parameters.
        /// </summary>
        /// <param name="xmlConfig">The XML configuration for the initialization algorithm.</param>
        /// <param name="isAcyclic">Flag indicating whether the network is acyclic (i.e. does not have recurrent connections).</param>
        /// <param name="numSuccessfulAgents">The minimum number of successful maze navigators that must be produced.</param>
        /// <param name="numUnsuccessfulAgents">The minimum number of unsuccessful maze navigators that must be produced.</param>
        /// <returns>The constructed initialization algorithm.</returns>
        public override void SetAlgorithmParameters(XmlElement xmlConfig, bool isAcyclic, int numSuccessfulAgents,
                                                    int numUnsuccessfulAgents)
        {
            // Set the boiler plate MCC parameters and minimal criterions
            base.SetAlgorithmParameters(xmlConfig, isAcyclic, numSuccessfulAgents, numUnsuccessfulAgents);

            // Read in the behavior characterization
            _behaviorCharacterizationFactory = ExperimentUtils.ReadBehaviorCharacterizationFactory(xmlConfig,
                                                                                                   "InitBehaviorConfig");

            // Read in the novelty archive parameters
            ExperimentUtils.ReadNoveltyParameters(xmlConfig, out _archiveAdditionThreshold,
                                                  out _archiveThresholdDecreaseMultiplier, out _archiveThresholdIncreaseMultiplier,
                                                  out _maxGenerationArchiveAddition, out _maxGenerationsWithoutArchiveAddition);

            // Read in nearest neighbors for behavior distance calculations
            _nearestNeighbors = XmlUtils.GetValueAsInt(xmlConfig, "NearestNeighbors");

            // Read in steady-state specific parameters
            _batchSize = XmlUtils.GetValueAsInt(xmlConfig, "OffspringBatchSize");
            _populationEvaluationFrequency = XmlUtils.GetValueAsInt(xmlConfig, "PopulationEvaluationFrequency");
        }
        public override void Initialize(string name, XmlElement xmlConfig, IDataLogger evolutionDataLogger,
            IDataLogger evaluationDataLogger)
        {
            base.Initialize(name, xmlConfig, evolutionDataLogger, evaluationDataLogger);

            // Read in the behavior characterization
            _behaviorCharacterizationFactory = ExperimentUtils.ReadBehaviorCharacterizationFactory(xmlConfig,
                "BehaviorConfig");

            // Read in number of offspring to produce in a single batch
            _batchSize = XmlUtils.GetValueAsInt(xmlConfig, "OffspringBatchSize");

            // Read in the minimal criteria update interval
            _minimalCriteriaUpdateInterval = XmlUtils.GetValueAsInt(xmlConfig, "MinimalCriteriaUpdateInterval");

            // Read in the bridging magnitude and number of applications
            _bridgingMagnitude = XmlUtils.TryGetValueAsInt(xmlConfig, "BridgingMagnitude") ?? default(int);
            _bridgingApplications = XmlUtils.TryGetValueAsInt(xmlConfig, "BridgingApplications") ?? default(int);

            // Read in the number of seed genomes to generate to bootstrap the primary algorithm
            SeedGenomeCount = XmlUtils.GetValueAsInt(xmlConfig, "SeedGenomeCount");

            // Read in log file path/name
            _evolutionDataLogger = evolutionDataLogger ??
                                   ExperimentUtils.ReadDataLogger(xmlConfig, LoggingType.Evolution);
            _evaluationDataLogger = evaluationDataLogger ??
                                    ExperimentUtils.ReadDataLogger(xmlConfig, LoggingType.Evaluation);

            // Setup the specific logging options based on parameters that are enabled/disabled
            _experimentLogFieldEnableMap = new Dictionary<FieldElement, bool>();

            // Enable or disable genome XML logging
            if (SerializeGenomeToXml)
            {
                _experimentLogFieldEnableMap.Add(EvolutionFieldElements.ChampGenomeXml, true);
            }

            // Enable or disable primary fitness logging (causing utilization of auxiliary fitness)
            if (_bridgingMagnitude > 0)
            {
                _experimentLogFieldEnableMap.Add(EvolutionFieldElements.ChampGenomeFitness, false);
            }

            // Log the MC threshold and location since it is dynamic
            _experimentLogFieldEnableMap.Add(EvolutionFieldElements.MinimalCriteriaThreshold, true);
            _experimentLogFieldEnableMap.Add(EvolutionFieldElements.MinimalCriteriaPointX, true);
            _experimentLogFieldEnableMap.Add(EvolutionFieldElements.MinimalCriteriaPointY, true);
        }
        public override void Initialize(ExperimentDictionary experimentDictionary)
        {
            base.Initialize(experimentDictionary);

            // Read in the behavior characterization
            _behaviorCharacterizationFactory = ExperimentUtils.ReadBehaviorCharacterizationFactory(
                experimentDictionary, true);

            // Read in number of offspring to produce in a single batch
            _batchSize = experimentDictionary.Primary_OffspringBatchSize ?? default(int);

            // Read in log file path/name
            _evolutionDataLogger = new McsExperimentEvaluationEntityDataLogger(experimentDictionary.ExperimentName);
            _evaluationDataLogger =
                new McsExperimentOrganismStateEntityDataLogger(experimentDictionary.ExperimentName);
        }
        public override void Initialize(string name, XmlElement xmlConfig, IDataLogger evolutionDataLogger,
            IDataLogger evaluationDataLogger)
        {
            base.Initialize(name, xmlConfig, evolutionDataLogger, evaluationDataLogger);

            // Read in the behavior characterization
            _behaviorCharacterizationFactory = ExperimentUtils.ReadBehaviorCharacterizationFactory(xmlConfig,
                "BehaviorConfig");

            // Read in steady-state specific parameters
            _batchSize = XmlUtils.GetValueAsInt(xmlConfig, "OffspringBatchSize");
            _populationEvaluationFrequency = XmlUtils.GetValueAsInt(xmlConfig, "PopulationEvaluationFrequency");

            // Read in MCS selection method
            _mcsSelectionMethod = XmlUtils.TryGetValueAsString(xmlConfig, "McsSelectionMethod");

            // Read in log file path/name
            _evolutionDataLogger = evolutionDataLogger ??
                                   ExperimentUtils.ReadDataLogger(xmlConfig, LoggingType.Evolution);
            _evaluationDataLogger = evaluationDataLogger ??
                                    ExperimentUtils.ReadDataLogger(xmlConfig, LoggingType.Evaluation);
        }
        public override void Initialize(ExperimentDictionary experimentDictionary)
        {
            base.Initialize(experimentDictionary);

            // Ensure the start position and minimum distance constraint are not null
            Debug.Assert(experimentDictionary.Primary_MCS_MinimalCriteriaStartX != null,
                "experimentDictionary.Primary_MCS_MinimalCriteriaStartX != null");
            Debug.Assert(experimentDictionary.Primary_MCS_MinimalCriteriaStartY != null,
                "experimentDictionary.Primary_MCS_MinimalCriteriaStartY != null");
            Debug.Assert(experimentDictionary.Primary_MCS_MinimalCriteriaThreshold != null,
                "experimentDictionary.Primary_MCS_MinimalCriteriaThreshold != null");

            // Read in the behavior characterization
            _behaviorCharacterizationFactory = ExperimentUtils.ReadBehaviorCharacterizationFactory(
                experimentDictionary, true);

            // Read in steady-state specific parameters
            _batchSize = experimentDictionary.Primary_OffspringBatchSize ?? default(int);
            _populationEvaluationFrequency = experimentDictionary.Primary_PopulationEvaluationFrequency ?? default(int);

            // Read in MCS selection method
            _mcsSelectionMethod = experimentDictionary.Primary_SelectionAlgorithmName;

            // Read in log file path/name
            _evolutionDataLogger = new NoveltyExperimentEvaluationEntityDataLogger(experimentDictionary.ExperimentName);
            _evaluationDataLogger =
                new NoveltyExperimentOrganismStateEntityDataLogger(experimentDictionary.ExperimentName);
        }
        public override void Initialize(ExperimentDictionary experimentDictionary)
        {
            base.Initialize(experimentDictionary);

            // Read in behavior characterization
            _behaviorCharacterizationFactory = ExperimentUtils.ReadBehaviorCharacterizationFactory(
                experimentDictionary, true);

            // Read in novelty archive parameters
            _archiveAdditionThreshold = experimentDictionary.Primary_NoveltySearch_ArchiveAdditionThreshold ??
                                        default(int);
            _archiveThresholdDecreaseMultiplier =
                experimentDictionary.Primary_NoveltySearch_ArchiveThresholdDecreaseMultiplier ?? default(double);
            _archiveThresholdIncreaseMultiplier =
                experimentDictionary.Primary_NoveltySearch_ArchiveThresholdIncreaseMultiplier ?? default(double);
            _maxGenerationArchiveAddition =
                experimentDictionary.Primary_NoveltySearch_MaxGenerationsWithArchiveAddition ?? default(int);
            _maxGenerationsWithoutArchiveAddition =
                experimentDictionary.Primary_NoveltySearch_MaxGenerationsWithoutArchiveAddition ?? default(int);

            // Read in nearest neighbors for behavior distance calculations
            _nearestNeighbors = experimentDictionary.Primary_NoveltySearch_NearestNeighbors ?? default(int);

            // Read in steady-state specific parameters
            _batchSize = experimentDictionary.Primary_OffspringBatchSize ?? default(int);
            _populationEvaluationFrequency = experimentDictionary.Primary_PopulationEvaluationFrequency ?? default(int);
        }
        public override void Initialize(ExperimentDictionary experimentDictionary)
        {
            base.Initialize(experimentDictionary);

            // Read in the behavior characterization
            _behaviorCharacterizationFactory = ExperimentUtils.ReadBehaviorCharacterizationFactory(
                experimentDictionary, true);

            // Read in number of offspring to produce in a single batch
            _batchSize = experimentDictionary.Primary_OffspringBatchSize ?? default(int);

            // Read in the bridging magnitude
            _bridgingMagnitude = experimentDictionary.Primary_MCS_BridgingMagnitude ?? default(int);
            _bridgingApplications = experimentDictionary.Primary_MCS_BridgingApplications ?? default(int);

            // TODO: Read seed genome count from the database

            // Read in log file path/name
            _evolutionDataLogger = new McsExperimentEvaluationEntityDataLogger(experimentDictionary.ExperimentName);
            _evaluationDataLogger =
                new McsExperimentOrganismStateEntityDataLogger(experimentDictionary.ExperimentName);

            // Initialize the initialization algorithm
            _mazeNavigationInitializer = new NoveltySearchMazeNavigationInitializer(MaxEvaluations, _evolutionDataLogger,
                _evaluationDataLogger,
                SerializeGenomeToXml);

            // Setup initialization algorithm
            _mazeNavigationInitializer.SetAlgorithmParameters(experimentDictionary, InputCount, OutputCount);

            // Pass in maze experiment specific parameters
            _mazeNavigationInitializer.SetEnvironmentParameters(MaxDistanceToTarget, MaxTimesteps, MazeVariant,
                MinSuccessDistance);
        }
        /// <summary>
        ///     Constructs and initializes the MCS initialization algorithm (novelty search) using the database configuration.
        /// </summary>
        /// <param name="experimentDictionary">The reference to the experiment dictionary entity.</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 void SetAlgorithmParameters(ExperimentDictionary experimentDictionary, int inputCount,
            int outputCount)
        {
            // Read NEAT parameters
            NeatGenomeParameters neatGenomeParameters =
                ExperimentUtils.ReadNeatGenomeParameters(experimentDictionary, false);

            // Read NEAT evolution parameters
            NeatEvolutionAlgorithmParameters =
                ExperimentUtils.ReadNeatEvolutionAlgorithmParameters(experimentDictionary, false);

            // Get complexity constraint parameters
            ComplexityRegulationStrategyDefinition =
                experimentDictionary.Initialization_ComplexityRegulationStrategy;
            ComplexityThreshold = experimentDictionary.Initialization_ComplexityThreshold;

            // Read in the behavior characterization
            _behaviorCharacterizationFactory =
                ExperimentUtils.ReadBehaviorCharacterizationFactory(experimentDictionary, false);

            // Read in the novelty archive parameters
            _archiveAdditionThreshold =
                experimentDictionary.Initialization_NoveltySearch_ArchiveAdditionThreshold ?? default(double);
            _archiveThresholdDecreaseMultiplier =
                experimentDictionary.Initialization_NoveltySearch_ArchiveThresholdDecreaseMultiplier ??
                default(double);
            _archiveThresholdIncreaseMultiplier =
                experimentDictionary.Initialization_NoveltySearch_ArchiveThresholdIncreaseMultiplier ??
                default(double);
            _maxGenerationArchiveAddition =
                experimentDictionary.Initialization_NoveltySearch_MaxGenerationsWithArchiveAddition ??
                default(int);
            _maxGenerationsWithoutArchiveAddition =
                experimentDictionary.Initialization_NoveltySearch_MaxGenerationsWithoutArchiveAddition ??
                default(int);

            // Read in nearest neighbors for behavior distance calculations
            _nearestNeighbors = experimentDictionary.Initialization_NoveltySearch_NearestNeighbors ?? default(int);

            // Read in steady-state specific parameters
            _batchSize = experimentDictionary.Initialization_OffspringBatchSize ?? default(int);
            _populationEvaluationFrequency = experimentDictionary.Initialization_PopulationEvaluationFrequency ??
                                             default(int);
        }
        /// <summary>
        ///     Constructs and initializes the MCS initialization algorithm (novelty search).
        /// </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 override void SetAlgorithmParameters(XmlElement xmlConfig, int inputCount, int outputCount)
        {
            // Set the boiler plate parameters
            base.SetAlgorithmParameters(xmlConfig, inputCount, outputCount);

            // Read the target population size
            PopulationSize = XmlUtils.GetValueAsInt(xmlConfig, "PopulationSize");

            // Read in the behavior characterization
            _behaviorCharacterizationFactory = ExperimentUtils.ReadBehaviorCharacterizationFactory(xmlConfig,
                "InitBehaviorConfig");

            // Read in the novelty archive parameters
            ExperimentUtils.ReadNoveltyParameters(xmlConfig, out _archiveAdditionThreshold,
                out _archiveThresholdDecreaseMultiplier, out _archiveThresholdIncreaseMultiplier,
                out _maxGenerationArchiveAddition, out _maxGenerationsWithoutArchiveAddition);

            // Read in nearest neighbors for behavior distance calculations
            _nearestNeighbors = XmlUtils.GetValueAsInt(xmlConfig, "NearestNeighbors");

            // Read in steady-state specific parameters
            _batchSize = XmlUtils.GetValueAsInt(xmlConfig, "OffspringBatchSize");
            _populationEvaluationFrequency = XmlUtils.GetValueAsInt(xmlConfig, "PopulationEvaluationFrequency");
        }
        public override void Initialize(string name, XmlElement xmlConfig, IDataLogger evolutionDataLogger,
            IDataLogger evaluationDataLogger)
        {
            base.Initialize(name, xmlConfig, evolutionDataLogger, evaluationDataLogger);

            // Read in the behavior characterization
            _behaviorCharacterizationFactory = ExperimentUtils.ReadBehaviorCharacterizationFactory(xmlConfig,
                "BehaviorConfig");

            // Read in the novelty archive parameters
            ExperimentUtils.ReadNoveltyParameters(xmlConfig, out _archiveAdditionThreshold,
                out _archiveThresholdDecreaseMultiplier, out _archiveThresholdIncreaseMultiplier,
                out _maxGenerationArchiveAddition, out _maxGenerationsWithoutArchiveAddition);

            // Read in nearest neighbors for behavior distance calculations
            _nearestNeighbors = XmlUtils.GetValueAsInt(xmlConfig, "NearestNeighbors");

            // Read in steady-state specific parameters
            _batchSize = XmlUtils.GetValueAsInt(xmlConfig, "OffspringBatchSize");
            _populationEvaluationFrequency = XmlUtils.GetValueAsInt(xmlConfig, "PopulationEvaluationFrequency");

            // Read in log file path/name
            _generationalLogFile = XmlUtils.TryGetValueAsString(xmlConfig, "GenerationalLogFile");
        }
        public override void Initialize(string name, XmlElement xmlConfig, IDataLogger evolutionDataLogger,
            IDataLogger evaluationDataLogger)
        {
            base.Initialize(name, xmlConfig, evolutionDataLogger, evaluationDataLogger);

            // Read in the behavior characterization
            _behaviorCharacterizationFactory = ExperimentUtils.ReadBehaviorCharacterizationFactory(xmlConfig,
                "BehaviorConfig");

            // Read in number of offspring to produce in a single batch
            _batchSize = XmlUtils.GetValueAsInt(xmlConfig, "OffspringBatchSize");

            // Read in the bridging magnitude and number of applications
            _bridgingMagnitude = XmlUtils.TryGetValueAsInt(xmlConfig, "BridgingMagnitude") ?? default(int);
            _bridgingApplications = XmlUtils.TryGetValueAsInt(xmlConfig, "BridgingApplications") ?? default(int);

            // Read in the number of seed genomes to generate to bootstrap the primary algorithm
            SeedGenomeCount = XmlUtils.GetValueAsInt(xmlConfig, "SeedGenomeCount");

            // Read in log file path/name
            _evolutionDataLogger = evolutionDataLogger ??
                                   ExperimentUtils.ReadDataLogger(xmlConfig, LoggingType.Evolution);
            _evaluationDataLogger = evaluationDataLogger ??
                                    ExperimentUtils.ReadDataLogger(xmlConfig, LoggingType.Evaluation);

            // Setup the specific logging options based on parameters that are enabled/disabled
            _experimentLogFieldEnableMap = EvolutionFieldElements.PopulateEvolutionFieldElementsEnableMap();

            // Enable or disable genome XML logging
            if (SerializeGenomeToXml == false)
            {
                _experimentLogFieldEnableMap.Add(EvolutionFieldElements.ChampGenomeXml, false);
            }

            // Enable or disable primary fitness logging (causing utilization of auxiliary fitness)
            if (_bridgingMagnitude > 0)
            {
                _experimentLogFieldEnableMap.Add(EvolutionFieldElements.ChampGenomeFitness, false);
            }

            // Initialize the initialization algorithm
            _mazeNavigationInitializer = new NoveltySearchMazeNavigationInitializer(MaxEvaluations, _evolutionDataLogger,
                _evaluationDataLogger,
                SerializeGenomeToXml);

            // Setup initialization algorithm
            _mazeNavigationInitializer.SetAlgorithmParameters(
                xmlConfig.GetElementsByTagName("InitializationAlgorithmConfig", "")[0] as XmlElement, InputCount,
                OutputCount);

            // Pass in maze experiment specific parameters
            _mazeNavigationInitializer.SetEnvironmentParameters(MaxDistanceToTarget, MaxTimesteps, MazeVariant,
                MinSuccessDistance);
        }
Beispiel #16
0
        /// <inheritdoc />
        /// <summary>
        ///     Initializes the MCC maze navigation experiment by reading in all of the configuration parameters and
        ///     setting up the bootstrapping/initialization algorithm.
        /// </summary>
        /// <param name="name">The name of the experiment.</param>
        /// <param name="xmlConfig">The reference to the XML configuration file.</param>
        /// <param name="population1EvolutionLogger">The navigator evolution data logger.</param>
        /// <param name="population1PopulationLogger">The navigator population logger.</param>
        /// <param name="population1GenomeLogger">The navigator genome logger.</param>
        /// <param name="population2EvolutionLogger">The maze evolution data logger.</param>
        /// <param name="population2PopulationLogger">The maze population logger.</param>
        /// <param name="population2GenomeLogger">The maze genome logger.</param>
        public virtual void Initialize(string name, XmlElement xmlConfig,
                                       IDataLogger population1EvolutionLogger  = null, IDataLogger population1PopulationLogger = null,
                                       IDataLogger population1GenomeLogger     = null, IDataLogger population2EvolutionLogger  = null,
                                       IDataLogger population2PopulationLogger = null, IDataLogger population2GenomeLogger     = null)
        {
            // Set boiler plate properties
            Name             = name;
            Description      = XmlUtils.GetValueAsString(xmlConfig, "Description");
            ActivationScheme = ExperimentUtils.CreateActivationScheme(xmlConfig, "Activation");
            ParallelOptions  = ExperimentUtils.ReadParallelOptions(xmlConfig);

            // Set the genome parameters
            NeatGenomeParameters = ExperimentUtils.ReadNeatGenomeParameters(xmlConfig);
            NeatGenomeParameters.FeedforwardOnly = ActivationScheme.AcyclicNetwork;
            MazeGenomeParameters = ExperimentUtils.ReadMazeGenomeParameters(xmlConfig);

            // Configure evolutionary algorithm parameters
            AgentDefaultPopulationSize      = XmlUtils.GetValueAsInt(xmlConfig, "AgentPopulationSize");
            MazeDefaultPopulationSize       = XmlUtils.GetValueAsInt(xmlConfig, "MazePopulationSize");
            AgentSeedGenomeCount            = XmlUtils.GetValueAsInt(xmlConfig, "AgentSeedGenomeCount");
            MazeSeedGenomeCount             = XmlUtils.GetValueAsInt(xmlConfig, "MazeSeedGenomeCount");
            AgentNumSpecies                 = XmlUtils.GetValueAsInt(xmlConfig, "AgentNumSpecies");
            MazeNumSpecies                  = XmlUtils.GetValueAsInt(xmlConfig, "MazeNumSpecies");
            BehaviorCharacterizationFactory = ExperimentUtils.ReadBehaviorCharacterizationFactory(xmlConfig,
                                                                                                  "BehaviorConfig");
            NavigatorBatchSize = XmlUtils.GetValueAsInt(xmlConfig, "NavigatorOffspringBatchSize");
            MazeBatchSize      = XmlUtils.GetValueAsInt(xmlConfig, "MazeOffspringBatchSize");

            // Set run-time bounding parameters
            MaxGenerations = XmlUtils.TryGetValueAsInt(xmlConfig, "MaxGenerations");
            MaxEvaluations = XmlUtils.TryGetValueAsULong(xmlConfig, "MaxEvaluations");

            // Set experiment-specific parameters
            MinSuccessDistance  = XmlUtils.GetValueAsInt(xmlConfig, "MinSuccessDistance");
            MazeHeight          = XmlUtils.GetValueAsInt(xmlConfig, "MazeHeight");
            MazeWidth           = XmlUtils.GetValueAsInt(xmlConfig, "MazeWidth");
            MazeQuadrantHeight  = XmlUtils.GetValueAsInt(xmlConfig, "MazeQuadrantHeight");
            MazeQuadrantWidth   = XmlUtils.GetValueAsInt(xmlConfig, "MazeQuadrantWidth");
            MazeScaleMultiplier = XmlUtils.GetValueAsInt(xmlConfig, "MazeScaleMultiplier");

            // Get success/failure criteria constraints
            NumMazeSuccessCriteria  = XmlUtils.GetValueAsInt(xmlConfig, "NumMazesSolvedCriteria");
            NumAgentSuccessCriteria = XmlUtils.GetValueAsInt(xmlConfig, "NumAgentsSolvedCriteria");
            NumAgentFailedCriteria  = XmlUtils.GetValueAsInt(xmlConfig, "NumAgentsFailedCriteria");

            // Read in the maximum number of initialization evaluations
            _maxInitializationEvaluations = XmlUtils.GetValueAsUInt(xmlConfig, "MaxInitializationEvaluations");

            // Initialize the initialization algorithm
            _mazeNavigationInitializer =
                ExperimentUtils.DetermineMCCInitializer(
                    xmlConfig.GetElementsByTagName("InitializationAlgorithmConfig", "")[0] as XmlElement);

            // Setup initialization algorithm
            _mazeNavigationInitializer.SetAlgorithmParameters(
                xmlConfig.GetElementsByTagName("InitializationAlgorithmConfig", "")[0] as XmlElement,
                ActivationScheme.AcyclicNetwork, NumAgentSuccessCriteria, 0);

            // Pass in maze experiment specific parameters
            // (note that a new maze structure is created here for the sole purpose of extracting the maze dimensions and calculating max distance to target)
            _mazeNavigationInitializer.SetEnvironmentParameters(MinSuccessDistance,
                                                                new MazeDecoder(MazeScaleMultiplier).Decode(
                                                                    new MazeGenomeFactory(MazeGenomeParameters, MazeHeight, MazeWidth, MazeQuadrantHeight,
                                                                                          MazeQuadrantWidth).CreateGenome(0)));

            // The size of the randomly generated agent genome pool from which to evolve agent bootstraps
            AgentInitializationGenomeCount = _mazeNavigationInitializer.PopulationSize;
        }
        public override void Initialize(string name, XmlElement xmlConfig, IDataLogger evolutionDataLogger,
            IDataLogger evaluationDataLogger)
        {
            base.Initialize(name, xmlConfig, evolutionDataLogger, evaluationDataLogger);

            // Read in the behavior characterization
            _behaviorCharacterizationFactory = ExperimentUtils.ReadBehaviorCharacterizationFactory(xmlConfig,
                "BehaviorConfig");

            // Read in the novelty archive parameters
            // Read in the novelty archive parameters
            ExperimentUtils.ReadNoveltyParameters(xmlConfig, out _archiveAdditionThreshold,
                out _archiveThresholdDecreaseMultiplier, out _archiveThresholdIncreaseMultiplier,
                out _maxGenerationArchiveAddition, out _maxGenerationsWithoutArchiveAddition);

            // Read in nearest neighbors for behavior distance calculations
            _nearestNeighbors = XmlUtils.GetValueAsInt(xmlConfig, "NearestNeighbors");
        }