/// <summary> /// Creates a CyclicNetwork from an INetworkDefinition. /// </summary> public static FastCyclicNetwork CreateFastCyclicNetwork(INetworkDefinition networkDef, NetworkActivationScheme activationScheme, bool boundedOutput) { FastConnection[] fastConnectionArray; IActivationFunction[] activationFnArray; double[][] neuronAuxArgsArray; InternalDecode(networkDef, activationScheme.RelaxingActivation ? activationScheme.MaxTimesteps : activationScheme.TimestepsPerActivation, out fastConnectionArray, out activationFnArray, out neuronAuxArgsArray); // Construct neural net. if (activationScheme.RelaxingActivation) { return(new FastRelaxingCyclicNetwork(fastConnectionArray, activationFnArray, neuronAuxArgsArray, networkDef.NodeList.Count, networkDef.InputNodeCount, networkDef.OutputNodeCount, activationScheme.MaxTimesteps, activationScheme.SignalDeltaThreshold, boundedOutput)); } return(new FastCyclicNetwork(fastConnectionArray, activationFnArray, neuronAuxArgsArray, networkDef.NodeList.Count, networkDef.InputNodeCount, networkDef.OutputNodeCount, activationScheme.TimestepsPerActivation, boundedOutput)); }
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> /// 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")); }
/// <summary> /// Creates a CyclicNetwork from an INetworkDefinition. /// </summary> public static FastCyclicNetwork CreateFastCyclicNetwork(INetworkDefinition networkDef, NetworkActivationScheme activationScheme) { FastConnection[] fastConnectionArray; IActivationFunction[] activationFnArray; double[][] neuronAuxArgsArray; InternalDecode(networkDef, activationScheme.RelaxingActivation ? activationScheme.MaxTimesteps : activationScheme.TimestepsPerActivation, out fastConnectionArray, out activationFnArray, out neuronAuxArgsArray); // Construct neural net. if(activationScheme.RelaxingActivation) { return new FastRelaxingCyclicNetwork(fastConnectionArray, activationFnArray, neuronAuxArgsArray, networkDef.NodeList.Count, networkDef.InputNodeCount, networkDef.OutputNodeCount, activationScheme.MaxTimesteps, activationScheme.SignalDeltaThreshold); } return new FastCyclicNetwork(fastConnectionArray, activationFnArray, neuronAuxArgsArray, networkDef.NodeList.Count, networkDef.InputNodeCount, networkDef.OutputNodeCount, activationScheme.TimestepsPerActivation); }
/// <summary> /// Creates a CyclicNetwork from an INetworkDefinition. /// </summary> public static CyclicNetwork CreateCyclicNetwork(INetworkDefinition networkDef, NetworkActivationScheme activationScheme) { List <Neuron> neuronList; List <Connection> connectionList; InternalDecode(networkDef, out neuronList, out connectionList); // Construct neural net. if (activationScheme.RelaxingActivation) { return(new RelaxingCyclicNetwork(neuronList, connectionList, networkDef.InputNodeCount, networkDef.OutputNodeCount, activationScheme.MaxTimesteps, activationScheme.SignalDeltaThreshold)); } return(new CyclicNetwork(neuronList, connectionList, networkDef.InputNodeCount, networkDef.OutputNodeCount, activationScheme.TimestepsPerActivation)); }
/// <summary> /// SimulatorExperimentConfiguration constructor. /// </summary> /// <param name="experimentName">The experiment name.</param> /// <param name="mazeHeight">The height of the maze.</param> /// <param name="mazeWidth">The width of the maze.</param> /// <param name="mazeScaleMultiplier"> /// The maze scale multiplication factor (this is the scale on which the navigator was /// evaluated, not at which the maze was evolved). /// </param> /// <param name="navigatorActivationScheme">The activation scheme (e.g. acyclic, cyclic) of the navigator ANN controller.</param> /// <param name="maxTimesteps">The maximum number of timesteps for one simulation trial.</param> /// <param name="minSuccessDistance">The minimum distance from the target to be considered a successful trial.</param> public SimulatorExperimentConfiguration(string experimentName, int mazeHeight, int mazeWidth, int mazeScaleMultiplier, NetworkActivationScheme navigatorActivationScheme, int maxTimesteps, int minSuccessDistance) { ExperimentName = experimentName; MazeHeight = mazeHeight*mazeScaleMultiplier; MazeWidth = mazeWidth*mazeScaleMultiplier; NavigatorAnnActivationScheme = navigatorActivationScheme; MaxTimesteps = maxTimesteps; MinSuccessDistance = minSuccessDistance; }
/// <summary> /// Creates a EspCyclicNetwork from a NeatGenome. /// </summary> public static EspCyclicNetwork CreateEspCyclicNetwork( NeatGenome givenGenome, NetworkActivationScheme activationScheme) { phenomeVariables = new PhenomeVariables(); genome = givenGenome; GetEasyVariables(); phenomeVariables.timestepsPerActivation = activationScheme.TimestepsPerActivation; InternalDecode(); /*foreach (KeyValuePair<int, int> entry in oldToNewIndex) * { * UnityEngine.Debug.Log("old index " + entry.Key + " new index " + entry.Value); * }*/ return(new EspCyclicNetwork(phenomeVariables)); }
/// <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> /// Creates a CyclicNetwork from an INetworkDefinition. /// </summary> public static CyclicNetwork CreateCyclicNetwork(INetworkDefinition networkDef, NetworkActivationScheme activationScheme) { List<Neuron> neuronList; List<Connection> connectionList; InternalDecode(networkDef, out neuronList, out connectionList); // Construct neural net. if(activationScheme.RelaxingActivation) { return new RelaxingCyclicNetwork(neuronList, connectionList, networkDef.InputNodeCount, networkDef.OutputNodeCount, activationScheme.MaxTimesteps, activationScheme.SignalDeltaThreshold); } return new CyclicNetwork(neuronList, connectionList, networkDef.InputNodeCount, networkDef.OutputNodeCount, activationScheme.TimestepsPerActivation); }
/// <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"); _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; _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> /// 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; _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"); _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(); }
/// <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> /// 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 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 configuration file parameters. /// </summary> /// <param name="name">The name of the experiment</param> /// <param name="xmlConfig">The parent XML configuration element</param> /// <param name="evolutionDataLogger">The optional evolution data logger.</param> /// <param name="evaluationDataLogger">The optional evaluation data logger.</param> public virtual void Initialize(string name, XmlElement xmlConfig, IDataLogger evolutionDataLogger, IDataLogger evaluationDataLogger) { // Set all properties Name = name; DefaultPopulationSize = XmlUtils.TryGetValueAsInt(xmlConfig, "PopulationSize") ?? default(int); 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); SerializeGenomeToXml = XmlUtils.TryGetValueAsBool(xmlConfig, "DecodeGenomesToXml") ?? false; MaxGenerations = XmlUtils.TryGetValueAsInt(xmlConfig, "MaxGenerations"); MaxEvaluations = XmlUtils.TryGetValueAsULong(xmlConfig, "MaxEvaluations"); MaxRestarts = XmlUtils.TryGetValueAsInt(xmlConfig, "MaxRestarts"); // Set evolution/genome parameters NeatEvolutionAlgorithmParameters = ExperimentUtils.ReadNeatEvolutionAlgorithmParameters(xmlConfig); NeatGenomeParameters = ExperimentUtils.ReadNeatGenomeParameters(xmlConfig); NeatGenomeParameters.FeedforwardOnly = _activationScheme.AcyclicNetwork; // Set experiment-specific parameters MaxTimesteps = XmlUtils.GetValueAsInt(xmlConfig, "MaxTimesteps"); MinSuccessDistance = XmlUtils.GetValueAsInt(xmlConfig, "MinSuccessDistance"); MaxDistanceToTarget = XmlUtils.GetValueAsInt(xmlConfig, "MaxDistanceToTarget"); MazeVariant = MazeVariantUtil.convertStringToMazeVariant(XmlUtils.TryGetValueAsString(xmlConfig, "MazeVariant")); }
/// <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); }
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> /// 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; 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"); _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(); }
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(); }