/// <summary> /// Novelty search runner constructor. /// </summary> /// <param name="comparisonExperimentConfig"> /// The experiment configuration against which to compare the given coevolution /// experiment. /// </param> /// <param name="refExperimentName">The name of the reference (novelty search) experiment configuration.</param> /// <param name="mazeDomain">The maze on which the comparison will be executed.</param> /// <param name="currentRun">The current run being analyzed.</param> /// <param name="totalRuns">The total number of runs in the coevolution experiment.</param> /// <param name="executionLogger">Execution file logger.</param> public NoveltySearchRunner(ExperimentDictionary comparisonExperimentConfig, string refExperimentName, MazeStructure mazeDomain, int currentRun, int totalRuns, ILog executionLogger) { _comparisonExperimentConfig = comparisonExperimentConfig; _referenceExperimentName = refExperimentName; _evaluationMazeDomain = mazeDomain; _currentRun = currentRun; _totalRuns = totalRuns; _executionLogger = executionLogger; }
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(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 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> /// Instantiates a new database context (opens the connection) and gets the experiment configuration key. /// </summary> public virtual void Open() { // Open the database connection DbContext = new ExperimentDataEntities(); // Query for the experiment configuration entity ExperimentConfiguration = DbContext.ExperimentDictionaries.Single(expName => expName.ExperimentName == ExperimentConfigurationName); }
/// <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> /// Handles per-batch comparison of coevolution-generated mazes on a reference algorithm (e.g. novelty search). /// </summary> /// <param name="batchesWithGenomeData">List of the batches that contain maze genome data.</param> /// <param name="curCoevoExperimentId">Identifier of the coevolution experiment.</param> /// <param name="curCoevoExperimentName">Name of the coevolution experiment.</param> /// <param name="curRun">The current run.</param> /// <param name="numRuns">The total number of runs in the experiment.</param> /// <param name="mazeDecoder">Reference to the maze genome decoder.</param> /// <param name="noveltySearchExperimentConfig">The experiment configuration for the reference (novelty search) experiment.</param> private static void RunPerBatchComparativeAnalysis(IList<int> batchesWithGenomeData, int curCoevoExperimentId, string curCoevoExperimentName, int curRun, int numRuns, MazeDecoder mazeDecoder, ExperimentDictionary noveltySearchExperimentConfig) { // Declare list to hold maze IDs that have already been evaluated using the comparison algorithm List<int> evaluatedMazeGenomeIds = new List<int>(); // Get the total number of initialization evaluations for the current run int coEvoInitEvaluations = ExperimentDataHandler.GetInitializationEvaluationsForRun(curCoevoExperimentId, curRun); // Iterate through each batch and run comparative algorithm on each maze foreach (int curBatch in batchesWithGenomeData) { _executionLogger.Info(string.Format("Executing comparative analysis for batch [{0}] of run [{1}/{2}]", curBatch, curRun, numRuns)); // Get list of all extant maze genomes for this batch IList<string> mazeGenomeXml = ExperimentDataHandler.GetMazeGenomeXml(curCoevoExperimentId, curRun, curBatch); foreach (string genomeXml in mazeGenomeXml) { MazeStructure curMazeStructure = null; MazeGenome curMazeGenome = null; // Create a new (mostly dummy) maze genome factory MazeGenomeFactory curMazeGenomeFactory = new MazeGenomeFactory(); // Convert each genome string to an equivalent genome object using (XmlReader xr = XmlReader.Create(new StringReader(genomeXml))) { curMazeGenome = MazeGenomeXmlIO.ReadSingleGenomeFromRoot(xr, curMazeGenomeFactory); } // If the maze has already been processed, continue on to the next one // (also exclude the initialization maze as a special case) if (evaluatedMazeGenomeIds.Contains((int) curMazeGenome.BirthGeneration) || curMazeGenome.BirthGeneration == 0) { continue; } // Get the total number of evaluations required to solve this maze // (this amounts to the total number of evaluations from both queues at the time of maze birth) int coEvoTotalEvaluations = coEvoInitEvaluations + ExperimentDataHandler.GetTotalPrimaryEvaluationsAtBatch( curCoevoExperimentId, curRun, (int) curMazeGenome.BirthGeneration); // Decode the maze structure curMazeStructure = mazeDecoder.Decode(curMazeGenome); // Instantiate new novelty search experiment for the current experiment/batch/maze NoveltySearchRunner nsRunner = new NoveltySearchRunner(noveltySearchExperimentConfig, curCoevoExperimentName, curMazeStructure, curRun, numRuns, _executionLogger); _executionLogger.Info(string.Format( "Executing novelty search on maze [{0}] with birth batch [{1}]", curMazeGenome.Id, curMazeGenome.BirthGeneration)); // Run novelty search on that maze until the maze is solved or the max evals have been reached INeatEvolutionAlgorithm<NeatGenome> eaFinalState = nsRunner.RunNoveltySearch(); // Write comparison results to output file ExperimentDataHandler.WriteNoveltySearchComparisonResults(curCoevoExperimentId, noveltySearchExperimentConfig.ExperimentDictionaryID, curRun, curBatch, (int) curMazeGenome.Id, (int) curMazeGenome.BirthGeneration, (int) eaFinalState.Statistics._minComplexity, (int) eaFinalState.Statistics._maxComplexity, eaFinalState.Statistics._meanComplexity, coEvoTotalEvaluations, (int) eaFinalState.CurrentEvaluations, !((int) eaFinalState.CurrentEvaluations >= noveltySearchExperimentConfig.MaxEvaluations), false); // Add maze genome ID to the list of processed mazes to its not considered for evaluation again evaluatedMazeGenomeIds.Add((int) curMazeGenome.Id); } } }
/// <summary> /// Runs post-hoc analysis for all batches in the given experiment/run. This can be part of either the initialization /// or primary run phase. /// </summary> /// <param name="batchesWithGenomeData">The total number of batches containing genome data.</param> /// <param name="runPhase"> /// Indicates whether this is part of the initialization or primary run phase. /// </param> /// <param name="experimentParameters">Experiment configuration parameters.</param> /// <param name="inputNeuronCount">Count of neurons in controller input layer.</param> /// <param name="outputNeuronCount">Count of neurons in controller output layer.</param> /// <param name="curRun">The run number.</param> /// <param name="numRuns">The total number of runs.</param> /// <param name="curExperimentConfiguration">The experiment configuration parameters.</param> /// <param name="generateSimulationResults">Indicates whether to write out the results of the batch simulation.</param> /// <param name="writeResultsToDatabase"> /// Indicates whether to write results directly into a database (if not, results are /// written to a flat file). /// </param> /// <param name="generateTrajectoryData">Indicates whether the full navigator trajectory should be simulated and persisted.</param> /// <param name="generateTrajectoryDiversityScore"> /// Indicates whether quantification of navigator trajectory diversity /// should be written out. /// </param> /// <param name="generateNaturalClustering">Indicates whether the natural population clusters should be analyzed.</param> /// <param name="generateMazeBitmaps">Indicates whether bitmap files of the distinct mazes should be written out.</param> /// <param name="generateTrajectoryBitmaps"> /// Indicates whether bitmap files depicting the navigator trajectory should be /// written out. /// </param> /// <param name="baseImageOutputDirectory">The path to the output directory for the trajectory images.</param> /// <param name="clusterImprovementThreshold"> /// The number of cluster additions that are permitted without further maximization of silhouette width. /// </param> /// <param name="sampleSize">The number of genomes sampled from the extant species for clustering analysis.</param> /// <param name="sampleClusterObservationsFromSpecies"> /// Indicates whether to sample observations used in clustering analysis /// from species or from the population as a whole. /// </param> private static void ProcessAndLogPerBatchResults(IList<int> batchesWithGenomeData, RunPhase runPhase, ExperimentParameters experimentParameters, int inputNeuronCount, int outputNeuronCount, int curRun, int numRuns, ExperimentDictionary curExperimentConfiguration, bool generateSimulationResults, bool generateTrajectoryData, bool generateTrajectoryDiversityScore, bool generateNaturalClustering, bool writeResultsToDatabase, bool generateMazeBitmaps, bool generateTrajectoryBitmaps, string baseImageOutputDirectory, int clusterImprovementThreshold, int sampleSize, bool sampleClusterObservationsFromSpecies) { IList<CoevolutionMCSMazeExperimentGenome> staticInitializationMazes = null; // If this invocation is processing initialization results, just get the maze up front as it will remain // the same throughout the initialization process if (runPhase == RunPhase.Initialization) { staticInitializationMazes = ExperimentDataHandler.GetMazeGenomeData(curExperimentConfiguration.ExperimentDictionaryID, curRun, 0); } // Iterate through each batch and evaluate maze/navigator combinations foreach (int curBatch in batchesWithGenomeData) { // Create the maze/navigator map MapEvaluator mapEvaluator = new MapEvaluator(experimentParameters, inputNeuronCount, outputNeuronCount); _executionLogger.Info(string.Format("Executing {0} run phase analysis for batch [{1}] of run [{2}/{3}]", runPhase, curBatch, curRun, numRuns)); // TODO: Check first to see if trajectory evaluations already exist // Get any existing navigation results (this avoids rerunning failed combinations) var successfulNavigations = ExperimentDataHandler.GetSuccessfulNavigations(curExperimentConfiguration.ExperimentDictionaryID, curRun, curBatch); // If successful navigation results were found and we're not re-running the simulations, // initialize the map evaluator with only those combinations known to be successful if (generateSimulationResults == false && successfulNavigations != null && successfulNavigations.Count > 0) { List<Tuple<CoevolutionMCSMazeExperimentGenome, CoevolutionMCSNavigatorExperimentGenome>> successfulGenomeCombos = new List<Tuple<CoevolutionMCSMazeExperimentGenome, CoevolutionMCSNavigatorExperimentGenome>> (successfulNavigations.Count()); // Get distinct maze and navigator genomes var mazeGenomeData = ExperimentDataHandler.GetMazeGenomeData(curExperimentConfiguration.ExperimentDictionaryID, curRun, curBatch, successfulNavigations.Select(n => n.MazeGenomeID).Distinct().ToList()); var navigatorGenomeData = ExperimentDataHandler.GetNavigatorGenomeData(curExperimentConfiguration.ExperimentDictionaryID, curRun, curBatch, runPhase, successfulNavigations.Select(n => n.NavigatorGenomeID).Distinct().ToList()); // Build list of successful maze/navigator combinations successfulGenomeCombos.AddRange( successfulNavigations.Select( successfulNav => new Tuple<CoevolutionMCSMazeExperimentGenome, CoevolutionMCSNavigatorExperimentGenome>( mazeGenomeData.First(gd => successfulNav.MazeGenomeID == gd.GenomeID), navigatorGenomeData.First(gd => successfulNav.NavigatorGenomeID == gd.GenomeID)))); // Initialize the maze/navigator map with combinations that are known to be successful mapEvaluator.Initialize(successfulGenomeCombos); } // Otherwise, just initialize with all combinations else { // Initialize the maze/navigator map with the serialized maze and navigator data (this does the parsing) mapEvaluator.Initialize( runPhase == RunPhase.Initialization ? staticInitializationMazes : ExperimentDataHandler.GetMazeGenomeData(curExperimentConfiguration.ExperimentDictionaryID, curRun, curBatch), ExperimentDataHandler.GetNavigatorGenomeData( curExperimentConfiguration.ExperimentDictionaryID, curRun, curBatch, runPhase)); } // Evaluate all of the maze/navigator combinations in the batch mapEvaluator.RunTrajectoryEvaluations(); if (generateSimulationResults) { // Save the evaluation results ExperimentDataHandler.WriteNavigatorMazeEvaluationData( curExperimentConfiguration.ExperimentDictionaryID, curRun, curBatch, runPhase, mapEvaluator.EvaluationUnits, CommitPageSize, writeResultsToDatabase); } if (generateMazeBitmaps) { // Generate bitmaps of distinct mazes extant at the current point in time ImageGenerationHandler.GenerateMazeBitmaps(baseImageOutputDirectory, curExperimentConfiguration.ExperimentName, curExperimentConfiguration.ExperimentDictionaryID, curRun, curBatch, mapEvaluator.EvaluationUnits); } if (generateTrajectoryBitmaps) { // Generate bitmaps of trajectory for all successful trials ImageGenerationHandler.GenerateBitmapsForSuccessfulTrials( baseImageOutputDirectory, curExperimentConfiguration.ExperimentName, curExperimentConfiguration.ExperimentDictionaryID, curRun, curBatch, mapEvaluator.EvaluationUnits, runPhase); } if (generateTrajectoryData && runPhase != RunPhase.Initialization) { // Write out the full trajectory of all agents through all solved mazes ExperimentDataHandler.WriteTrajectoryData(curExperimentConfiguration.ExperimentDictionaryID, curRun, curBatch, mapEvaluator.EvaluationUnits, CommitPageSize, writeResultsToDatabase); } // Compare trajectories of agents through maze to get quantitative sense of solution diversity // Mean euclidean distance will be calculated for selected trajectory against: // 1. Other agent trajectories in the current maze only // 2. Other agent trajectories on *another* maze only // 3. All other agent trajectories (regardless of maze) if (generateTrajectoryDiversityScore && runPhase != RunPhase.Initialization) { ExperimentDataHandler.WriteTrajectoryDiversityData( curExperimentConfiguration.ExperimentDictionaryID, curRun, curBatch, EvaluationHandler.CalculateTrajectoryDiversity(mapEvaluator.EvaluationUnits), writeResultsToDatabase); } // Only write clustering results for primary runs when the number of trajectories have surpassed // the minimum cluster count of 3 if (generateNaturalClustering && runPhase != RunPhase.Initialization) { // Extract uniform samples of maze and navigator genomes from each extant specie // on which to run clustering analysis var evaluationSamples = sampleClusterObservationsFromSpecies ? DataManipulationUtil.ExtractEvaluationUnitSamplesFromSpecies( curExperimentConfiguration.ExperimentDictionaryID, curRun, curBatch, mapEvaluator.EvaluationUnits.Where(eu => eu.IsMazeSolved).ToList(), sampleSize) : DataManipulationUtil.ExtractEvaluationUnitSamplesFromPopulation( mapEvaluator.EvaluationUnits.Where(eu => eu.IsMazeSolved).ToList(), sampleSize); // Calculate natural clustering of the population trajectories at each point in time and persist ExperimentDataHandler.WriteClusteringDiversityData( curExperimentConfiguration.ExperimentDictionaryID, curRun, curBatch, EvaluationHandler.CalculateNaturalClustering(evaluationSamples, clusterImprovementThreshold), writeResultsToDatabase); } } }
/// <summary> /// Runs post-hoc analysis for the entire experiment run in aggregate (i.e. not per batch). This analyzes the primary /// run phase only. /// </summary> /// <param name="batchesWithGenomeData">The total number of batches containing genome data.</param> /// <param name="experimentParameters">Experiment configuration parameters.</param> /// <param name="inputNeuronCount">Count of neurons in controller input layer.</param> /// <param name="outputNeuronCount">Count of neurons in controller output layer.</param> /// <param name="curRun">The run number.</param> /// <param name="numRuns">The total number of runs.</param> /// <param name="curExperimentConfiguration">The experiment configuration parameters.</param> /// <param name="generateSimulationResults">Indicates whether to write out the results of the batch simulation.</param> /// <param name="writeResultsToDatabase"> /// Indicates whether to write results directly into a database (if not, results are /// written to a flat file). /// </param> /// <param name="generateTrajectoryData">Indicates whether the full navigator trajectory should be simulated and persisted.</param> /// <param name="generateTrajectoryDiversityScore"> /// Indicates whether quantification of navigator trajectory diversity /// should be written out. /// </param> /// <param name="generateNaturalClustering">Indicates whether the natural population clusters should be analyzed.</param> /// <param name="generateMazeBitmaps">Indicates whether bitmap files of the distinct mazes should be written out.</param> /// <param name="generateTrajectoryBitmaps"> /// Indicates whether bitmap files depicting the navigator trajectory should be /// written out. /// </param> /// <param name="baseImageOutputDirectory">The path to the output directory for the trajectory images.</param> /// <param name="clusterImprovementThreshold"> /// The number of cluster additions that are permitted without further maximization of silhouette width. /// </param> /// <param name="specieSampleSize">The number of genomes sampled from the extant species for clustering analysis.</param> private static void ProcessAndLogAggregateRunResults(IList<int> batchesWithGenomeData, ExperimentParameters experimentParameters, int inputNeuronCount, int outputNeuronCount, int curRun, int numRuns, ExperimentDictionary curExperimentConfiguration, bool generateSimulationResults, bool generateTrajectoryData, bool generateTrajectoryDiversityScore, bool generateNaturalClustering, bool writeResultsToDatabase, bool generateMazeBitmaps, bool generateTrajectoryBitmaps, string baseImageOutputDirectory, int clusterImprovementThreshold, int specieSampleSize) { // Create the maze/navigator map MapEvaluator mapEvaluator = new MapEvaluator(experimentParameters, inputNeuronCount, outputNeuronCount); _executionLogger.Info(string.Format("Executing aggregate run analysis for run [{0}/{1}]", curRun, numRuns)); // TODO: Might need to consider the option of pinning the mazes in memory and batching through the agents // TODO: as pulling both into memory simultaneously is probably going to use too much memory // Initialize the evaluator with the maze genomes discovered throughout the entire run mapEvaluator.Initialize( ExperimentDataHandler.GetMazeGenomeData(curExperimentConfiguration.ExperimentDictionaryID, curRun)); // Then evaluate each agent against each maze on a batch-by-batch basis foreach (int curBatch in batchesWithGenomeData) { _executionLogger.Info(string.Format("Executing trajectory for batch [{0}] and run [{1}/{2}]", curBatch, curRun, numRuns)); // Initialize with the agent genomes from the current batch mapEvaluator.Initialize( ExperimentDataHandler.GetNavigatorGenomeData(curExperimentConfiguration.ExperimentDictionaryID, curRun, curBatch, RunPhase.Primary)); // Evaluate all of the maze/navigator combinations in the batch mapEvaluator.RunTrajectoryEvaluations(); if (generateSimulationResults) { // Save the evaluation results // TODO: Implement - not sure if this adds a whole lot of value beyond per-batch approach } if (generateMazeBitmaps) { // Generate bitmaps of distinct mazes extant throughout the run // TODO: Implement - not sure if this adds a whole lot of value beyond per-batch approach } if (generateTrajectoryBitmaps) { // Generate bitmaps of trajectory for all successful trials // TODO: Implement - not sure if this adds a whole lot of value beyond per-batch approach } if (generateTrajectoryData) { // Write out the full trajectory of all agents through all solved mazes // TODO: Implement - may end up removing this as it takes up an enormous amount of space } // Compare trajectories of agents through maze to get quantitative sense of solution diversity // Mean euclidean distance will be calculated for selected trajectory against: // 1. Other agent trajectories in the current maze only // 2. Other agent trajectories on *another* maze only // 3. All other agent trajectories (regardless of maze) if (generateTrajectoryDiversityScore) { // TODO: Implement ExperimentDataHandler.WriteTrajectoryDiversityData( curExperimentConfiguration.ExperimentDictionaryID, curRun, EvaluationHandler.CalculateTrajectoryDiversity(mapEvaluator.EvaluationUnits), writeResultsToDatabase); } if (generateNaturalClustering) { // Calculate natural clustering of the population trajectories throughout the run and persist ExperimentDataHandler.WriteClusteringDiversityData( curExperimentConfiguration.ExperimentDictionaryID, curRun, EvaluationHandler.CalculateNaturalClustering(mapEvaluator.EvaluationUnits, clusterImprovementThreshold), writeResultsToDatabase); } } }
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); }
/// <summary> /// Initialize the experiment with database configuration parameters. /// </summary> /// <param name="experimentDictionary">The handle to the experiment dictionary row pulled from the database.</param> public virtual void Initialize(ExperimentDictionary experimentDictionary) { // Set all properties Name = experimentDictionary.ExperimentName; DefaultPopulationSize = experimentDictionary.Primary_PopulationSize; Description = experimentDictionary.ExperimentName; // Set all internal class variables _activationScheme = NetworkActivationScheme.CreateAcyclicScheme(); ComplexityRegulationStrategy = experimentDictionary.Primary_ComplexityRegulationStrategy; Complexitythreshold = experimentDictionary.Primary_ComplexityThreshold; ParallelOptions = new ParallelOptions(); SerializeGenomeToXml = experimentDictionary.SerializeGenomeToXml; MaxEvaluations = (ulong) experimentDictionary.MaxEvaluations; MaxRestarts = experimentDictionary.MaxRestarts; // Set evolution/genome parameters NeatEvolutionAlgorithmParameters = ExperimentUtils.ReadNeatEvolutionAlgorithmParameters( experimentDictionary, true); NeatGenomeParameters = ExperimentUtils.ReadNeatGenomeParameters(experimentDictionary, true); NeatGenomeParameters.FeedforwardOnly = _activationScheme.AcyclicNetwork; // Set experiment-specific parameters MaxTimesteps = experimentDictionary.MaxTimesteps; MinSuccessDistance = experimentDictionary.MinSuccessDistance; MaxDistanceToTarget = experimentDictionary.MaxDistanceToTarget ?? default(int); MazeVariant = MazeVariantUtil.convertStringToMazeVariant(experimentDictionary.ExperimentDomainName); }
/// <summary> /// Reads NEAT genome parameters from the database. /// </summary> /// <param name="experimentDictionary">Reference to experiment dictionary table.</param> /// <param name="isPrimary">Flag indicating whether this is the primary or an initialization algorithm.</param> /// <returns>Initialized NEAT genome parameters.</returns> public static NeatGenomeParameters ReadNeatGenomeParameters(ExperimentDictionary experimentDictionary, bool isPrimary) { return (isPrimary ? new NeatGenomeParameters { InitialInterconnectionsProportion = experimentDictionary.Primary_ConnectionProportion, ConnectionWeightMutationProbability = experimentDictionary.Primary_MutateConnectionWeightsProbability, AddConnectionMutationProbability = experimentDictionary.Primary_MutateAddConnectionProbability, AddNodeMutationProbability = experimentDictionary.Primary_MutateAddNeuronProbability, DeleteConnectionMutationProbability = experimentDictionary.Primary_MutateDeleteConnectionProbability, ConnectionWeightRange = experimentDictionary.Primary_ConnectionWeightRange } : new NeatGenomeParameters { InitialInterconnectionsProportion = experimentDictionary.Initialization_ConnectionProportion ?? default(double), ConnectionWeightMutationProbability = experimentDictionary.Initialization_MutateConnectionWeightsProbability ?? default(double), AddConnectionMutationProbability = experimentDictionary.Initialization_MutateAddConnectionProbability ?? default(double), AddNodeMutationProbability = experimentDictionary.Initialization_MutateAddNeuronProbability ?? default(double), DeleteConnectionMutationProbability = experimentDictionary.Initialization_MutateDeleteConnectionProbability ?? default(double), ConnectionWeightRange = experimentDictionary.Initialization_ConnectionWeightRange ?? default(double) }); }
/// <summary> /// Reads NEAT evolution algorithm parameters from the database. /// </summary> /// <param name="experimentDictionary">Reference to the experiment dictionary table.</param> /// <param name="isPrimary">Flag indicating whether this is the primary or an initialization algorithm.</param> /// <returns>Initialized NEAT evolution algorithm parameters.</returns> public static NeatEvolutionAlgorithmParameters ReadNeatEvolutionAlgorithmParameters( ExperimentDictionary experimentDictionary, bool isPrimary) { return (isPrimary ? new NeatEvolutionAlgorithmParameters { SpecieCount = experimentDictionary.Primary_NumSpecies, InterspeciesMatingProportion = experimentDictionary.Primary_InterspeciesMatingProbability, ElitismProportion = experimentDictionary.Primary_ElitismProportion, SelectionProportion = experimentDictionary.Primary_SelectionProportion, OffspringAsexualProportion = experimentDictionary.Primary_AsexualProbability, OffspringSexualProportion = experimentDictionary.Primary_CrossoverProbability } : new NeatEvolutionAlgorithmParameters { SpecieCount = experimentDictionary.Initialization_NumSpecies ?? default(int), InterspeciesMatingProportion = experimentDictionary.Initialization_InterspeciesMatingProbability ?? default(double), ElitismProportion = experimentDictionary.Initialization_ElitismProportion ?? default(double), SelectionProportion = experimentDictionary.Initialization_SelectionProportion ?? default(double), OffspringAsexualProportion = experimentDictionary.Initialization_AsexualProbability ?? default(double), OffspringSexualProportion = experimentDictionary.Initialization_CrossoverProbability ?? default(double) }); }
/// <summary> /// Reads behavior characterization parameters from the database. /// </summary> /// <param name="experiment">The experiment dictionary entity.</param> /// <param name="isPrimary"> /// Boolean flag indicating whether this is the primary behavior characterization or the behavior /// characterization used for experiment initialization. /// </param> /// <returns></returns> public static IBehaviorCharacterizationFactory ReadBehaviorCharacterizationFactory( ExperimentDictionary experiment, bool isPrimary) { // Read behavior characterization String behaviorCharacterizationName = isPrimary ? experiment.Primary_BehaviorCharacterizationName : experiment.Initialization_BehaviorCharacterizationName; // Ensure that the behavior was specified if (behaviorCharacterizationName == null) { throw new ArgumentException("Missing or invalid BehaviorConfig settings."); } IMinimalCriteria minimalCriteria = null; // Get the appropriate minimal criteria type MinimalCriteriaType mcType = BehaviorCharacterizationUtil.ConvertStringToMinimalCriteria(isPrimary ? experiment.Primary_MCS_MinimalCriteriaName : experiment.Initialization_MCS_MinimalCriteriaName); // Starting location used in most criterias double xStart, yStart; switch (mcType) { case MinimalCriteriaType.EuclideanLocation: // TODO: Not implemented at the database layer yet break; case MinimalCriteriaType.FixedPointEuclideanDistance: // Read in the starting coordinates and the minimum required distance traveled xStart = isPrimary ? experiment.Primary_MCS_MinimalCriteriaStartX ?? default(double) : experiment.Initialization_MCS_MinimalCriteriaStartX ?? default(double); yStart = isPrimary ? experiment.Primary_MCS_MinimalCriteriaStartY ?? default(double) : experiment.Initialization_MCS_MinimalCriteriaStartY ?? default(double); double minimumDistanceTraveled = isPrimary ? experiment.Primary_MCS_MinimalCriteriaThreshold ?? default(double) : experiment.Initialization_MCS_MinimalCriteriaThreshold ?? default(double); // Set the euclidean distance minimal criteria on the behavior characterization minimalCriteria = new FixedPointEuclideanDistanceCriteria(xStart, yStart, minimumDistanceTraveled); break; case MinimalCriteriaType.Mileage: // Read in the starting coordinates and minimum required total distance traveled (mileage) xStart = isPrimary ? experiment.Primary_MCS_MinimalCriteriaStartX ?? default(double) : experiment.Initialization_MCS_MinimalCriteriaStartX ?? default(double); yStart = isPrimary ? experiment.Primary_MCS_MinimalCriteriaStartY ?? default(double) : experiment.Initialization_MCS_MinimalCriteriaStartY ?? default(double); double minimumMileage = isPrimary ? experiment.Primary_MCS_MinimalCriteriaThreshold ?? default(double) : experiment.Initialization_MCS_MinimalCriteriaThreshold ?? default(double); // Set the mileage minimal criteria on the behavior characterization minimalCriteria = new MileageCriteria(xStart, yStart, minimumMileage); break; } // Parse and generate the appropriate behavior characterization factory IBehaviorCharacterizationFactory behaviorCharacterizationFactory = BehaviorCharacterizationUtil.GenerateBehaviorCharacterizationFactory(behaviorCharacterizationName, minimalCriteria); return behaviorCharacterizationFactory; }