private static ExperimentParameters GetExperimentParameters(EvolutionParameters evolutionParameters)
{
return(new ExperimentParameters(
numberOfDimensions: GetInt(nameof(ExperimentParameters.NumberOfDimensions)),
maximumNumberOfConstraints: GetInt(nameof(ExperimentParameters.MaximumNumberOfConstraints)),
numberOfConstraintsCoefficients: GetInt(nameof(ExperimentParameters.NumberOfConstraintsCoefficients)),
evolutionParameters: evolutionParameters,
seed: GetInt(nameof(ExperimentParameters.Seed)),
trackEvolutionSteps: GetBool(nameof(ExperimentParameters.TrackEvolutionSteps)),
useRedundantConstraintsRemoving: GetBool(nameof(ExperimentParameters.UseRedundantConstraintsRemoving)),
useDataNormalization: GetBool(nameof(ExperimentParameters.UseDataNormalization)),
allowQuadraticTerms: GetBool(nameof(ExperimentParameters.AllowQuadraticTerms)),
useSeeding: GetBool(nameof(ExperimentParameters.UseSeeding)),
typeOfBenchmark: GetEnum <BenchmarkType>(nameof(ExperimentParameters.TypeOfBenchmark)),
ballnBoundaryValue: GetDouble(nameof(ExperimentParameters.BallnBoundaryValue)),
cubenBoundaryValue: GetDouble(nameof(ExperimentParameters.CubenBoundaryValue)),
simplexnBoundaryValue: GetDouble(nameof(ExperimentParameters.SimplexnBoundaryValue)),
numberOfDomainSamples: GetInt(nameof(ExperimentParameters.NumberOfDomainSamples)),
numberOfTestPoints: GetInt(nameof(ExperimentParameters.NumberOfTestPoints)),
numberOfPositivePoints: GetInt(nameof(ExperimentParameters.NumberOfPositivePoints)),
numberOfNegativePoints: GetInt(nameof(ExperimentParameters.NumberOfNegativePoints)),
defaultDomainLowerLimit: GetDouble(nameof(ExperimentParameters.DefaultDomainLowerLimit)),
defaultDomainUpperLimit: GetDouble(nameof(ExperimentParameters.DefaultDomainUpperLimit)),
maxNumberOfPointsInSingleArray: GetInt(nameof(ExperimentParameters.MaxNumberOfPointsInSingleArray))
));
}
public NsmStdDevsMutator(EvolutionParameters evolutionParameters)
{
_globalLearningRate = evolutionParameters.GlobalLearningRate;
_individualLearningRate = evolutionParameters.IndividualLearningRate;
_stepThreshold = evolutionParameters.StepThreshold;
_randomGenerator = MersenneTwister.Instance;
}
public static void NewExperiment(EvolutionParameters parameters)
{
DateTime now = DateTime.Now;
if (_currentExperiment != null)
{
//WriteData(new []{(now - _start).TotalMilliseconds.ToString()});
}
string experimentString = parameters.Selection + "-" +
parameters.Container + "-[" +
string.Join <Variation>("-", parameters.Variations) + "]";
foreach (string experiment in _experiments)
{
if (experiment.Contains(experimentString))
{
_currentExperiment = experiment;
_start = now;
return;
}
}
_currentExperiment = now.ToString("yyyyMMddHHmmss") + "-" + experimentString + ".txt";
_experiments.Add(_currentExperiment);
_start = now;
}
public RecombinerBase Create(EvolutionParameters evolutionParameters)
{
var typeOfMutation = (MutationType)evolutionParameters.TypeOfMutation;
var typeOfStdDevsRecombination = (RecombinationType)evolutionParameters.TypeOfStdDeviationsRecombination;
if (typeOfMutation == MutationType.UncorrelatedOneStep)
{
switch (typeOfStdDevsRecombination)
{
case RecombinationType.Discrete:
return(new OsmStdDevsDiscreteRecombiner());
case RecombinationType.Intermediate:
return(new OsmStdDevsIntermediateRecombiner());
default:
throw new ArgumentOutOfRangeException();
}
}
switch (typeOfStdDevsRecombination)
{
case RecombinationType.Discrete:
return(new NsmStdDevsDiscreteRecombiner());
case RecombinationType.Intermediate:
return(new NsmStdDevsIntermediateRecombiner());
default:
throw new ArgumentOutOfRangeException();
}
}
public void LoadEvolutionParametersFromJsonTest()
{
EvolutionParameters parameters = JsonConvert.DeserializeObject <EvolutionParameters>(EvolutionParamterJson);
Assert.AreEqual(PopulationSize, parameters.PopulationSize);
Assert.AreEqual(Iterations, parameters.Iterations);
Assert.AreEqual(RoundEval, parameters.RoundEvaluation);
Assert.AreEqual(ParentSelectionPercentage, parameters.ParentSelectionPercentage);
Assert.AreEqual(ChildMutationPercentage, parameters.ChildMutationPercentage);
Assert.AreEqual(ElitismSelectedPercentage, parameters.ElitismSelectedPercentage);
Assert.AreEqual(ElitismPoolSizePercentage, parameters.ElitismPoolSizePercentage);
Assert.AreEqual(ScoreConnectTwoMin, parameters.GetCandidateScoreParameterMin(CandidateScoreTypes.ScoreConnectTwo));
Assert.AreEqual(ScoreConnectTwoMax, parameters.GetCandidateScoreParameterMax(CandidateScoreTypes.ScoreConnectTwo));
Assert.AreEqual(ScoreConnectThreeMin, parameters.GetCandidateScoreParameterMin(CandidateScoreTypes.ScoreConnectThree));
Assert.AreEqual(ScoreConnectThreeMax, parameters.GetCandidateScoreParameterMax(CandidateScoreTypes.ScoreConnectThree));
Assert.AreEqual(ScoreConnectFourMin, parameters.GetCandidateScoreParameterMin(CandidateScoreTypes.ScoreConnectFour));
Assert.AreEqual(ScoreConnectFourMax, parameters.GetCandidateScoreParameterMax(CandidateScoreTypes.ScoreConnectFour));
Assert.AreEqual(GiveScoreConnectTwoMin, parameters.GetCandidateScoreParameterMin(CandidateScoreTypes.GiveConnectTwo));
Assert.AreEqual(GiveScoreConnectTwoMax, parameters.GetCandidateScoreParameterMax(CandidateScoreTypes.GiveConnectTwo));
Assert.AreEqual(GiveScoreConnectThreeMin, parameters.GetCandidateScoreParameterMin(CandidateScoreTypes.GiveConnectThree));
Assert.AreEqual(GiveScoreConnectThreeMax, parameters.GetCandidateScoreParameterMax(CandidateScoreTypes.GiveConnectThree));
Assert.AreEqual(GiveScoreConnectFourMin, parameters.GetCandidateScoreParameterMin(CandidateScoreTypes.GiveConnectFour));
Assert.AreEqual(GiveScoreConnectFourMax, parameters.GetCandidateScoreParameterMax(CandidateScoreTypes.GiveConnectFour));
}
/// <summary>
/// Creat an AI Player based off the evolutionary parameters provded.
/// </summary>
/// <param name="parameters">Evolutionary parameters defining the boundaries of this candidates characteristics.</param>
/// <param name="id">AI Player id.</param>
/// <param name="generation">The generation this AI player will belong to.</param>
/// <returns>AI Player built.</returns>
public IAiPlayer BuildAiPlayer(EvolutionParameters parameters, int id, int generation = 1)
{
// Set score boundaries
if (!_scoreParametersSet)
{
SetupScoreParameters(parameters);
_scoreParametersSet = true;
}
var characteristics = new Characteristics
{
ScoreConnectTwo = _rand.Next(_scoreConnectTwoMin, _scoreConnectTwoMax),
ScoreConnectThree = _rand.Next(_scoreConnectThreeMin, _scoreConnectThreeMax),
ScoreConnectFour = _rand.Next(_scoreConnectFourMin, _scoreConnectFourMax),
ScoreGivingConnectTwo = _rand.Next(_scoreGivingConnectTwoMin, _scoreGivingConnectTwoMax),
ScoreGivingConnectThree = _rand.Next(_scoreGivingConnectThreeMin, _scoreGivingConnectThreeMax),
ScoreGivingConnectFour = _rand.Next(_scoreGivingConnectFourMin, _scoreGivingConnectFourMax)
};
var aiPlayer = new AiPlayer(characteristics)
{
Id = id,
Generation = 1
};
return(aiPlayer);
}
static void Main(string[] args)
{
Console.WriteLine("Reading EA parameters");
EvolutionParameters parameters = LoadEvolutionParameters();
// Ensure population size is divisable by two
if (parameters.PopulationSize % 2 != 0)
{
parameters.PopulationSize++;
}
Console.WriteLine("Creating population");
IPopulationBuilder populationBuilder = new PopulationBuilder();
IList <IAiPlayer> candidates = populationBuilder.CreateInitialPopulation(parameters);
candidates = candidates.OrderBy(a => Guid.NewGuid()).ToList();
Console.WriteLine("Creating matches");
for (int i = 0; i < candidates.Count; i += 2)
{
var playerOne = (AiPlayer)candidates[i];
playerOne.GamePiece = ConnectFourGame.ConnectFourGame.PlayerOneGamePiece;
var playerTwo = (AiPlayer)candidates[i + 1];
playerTwo.GamePiece = ConnectFourGame.ConnectFourGame.PlayerTwoGamePiece;
var match = new ConnectFourGame.ConnectFourGame(playerOne, playerTwo);
match.PlayGame();
playerOne.LastGameScore = playerOne.GetBoardScore(match.Board);
playerTwo.LastGameScore = playerTwo.GetBoardScore(match.Board);
if (match.Winner == ConnectFourGame.ConnectFourGame.WinningPlayer.NoWinners)
{
Console.WriteLine($"Player {i} and {i + 1} drew at the game with scores: {playerOne.LastGameScore} vs {playerTwo.LastGameScore}");
}
else
{
var winningPlayer = match.Winner == ConnectFourGame.ConnectFourGame.WinningPlayer.PlayerOneWins ? "Player One" : "Player Two";
Console.WriteLine($"{winningPlayer} wins with scores: {playerOne.LastGameScore} vs {playerTwo.LastGameScore}");
}
}
Console.WriteLine("Selecting Elite players");
int eliteSelectionSize = (int)(parameters.ElitismSelectedPercentage * parameters.PopulationSize / 100);
int elitePoolSize = (int)(parameters.ElitismPoolSizePercentage * parameters.PopulationSize / 100);
var elites = populationBuilder.SelectElitePlayers(candidates, eliteSelectionSize, elitePoolSize);
// todo add functionality and loop through these until end condition has been met
// Console.WriteLine("Selecting parents");
// Console.WriteLine("Creating children");
// Console.WriteLine("Creating next generation");
// Finish
Console.WriteLine("------------------------");
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
}
/// <summary>
/// Creates a population of AI players (candidates).
/// </summary>
/// <param name="parameters">Evolutionary algorithm parameters.</param>
/// <returns>List of </returns>
public IList <IAiPlayer> CreateInitialPopulation(EvolutionParameters parameters)
{
IList <IAiPlayer> candidates = new List <IAiPlayer>();
ICandidateBuilder candidateBuilder = new CandidateBuilder();
for (int i = 0; i < parameters.PopulationSize; i++)
{
candidates.Add(candidateBuilder.BuildAiPlayer(parameters, i));
}
return(candidates);
}
public IEngine Create(EvolutionParameters evolutionParameters)
{
IEngine engine;
IGenericFactory <Solution> solutionsFactory = new SolutionsFactory();
IGenericFactory <PopulationGeneratorBase> populationGeneratorsFactory = new PopulationGeneratorsFactory(solutionsFactory);
IGenericFactory <MutatorBase> objectMutatorsFactory = new ObjectMutatorsFactory();
IGenericFactory <MutatorBase> stdDevsMutatorsFactory = new StdDevsMutatorsFactory();
IGenericFactory <MutationRuleSupervisorBase> mutationRuleSupervisorsFactory = new MutationRuleSupervisorsFactory();
IGenericFactory <ParentsSelectorBase> parentsSelectorsFactory = new ParentsSelectorsFactory();
IGenericFactory <SurvivorsSelectorBase> survivorsSelectorsFactory = new SurvivorsSelectorsFactory();
var typeOfMutation = (MutationType)evolutionParameters.TypeOfMutation;
if (typeOfMutation == MutationType.Correlated)
{
IGenericFactory <MutatorBase> rotationsMutatorsFactory = new RotationsMutatorsFactory();
if (evolutionParameters.UseRecombination)
{
IGenericFactory <RecombinerBase> objectRecombinersFactory = new ObjectRecombinersFactory();
IGenericFactory <RecombinerBase> stdDevsRecombinersFactory = new StdDevsRecombinersFactory();
IGenericFactory <RecombinerBase> rotationsRecombinersFactory = new RotationsRecombinersFactory();
engine = Create(evolutionParameters, solutionsFactory, populationGeneratorsFactory,
objectMutatorsFactory, stdDevsMutatorsFactory, mutationRuleSupervisorsFactory, parentsSelectorsFactory, survivorsSelectorsFactory, rotationsMutatorsFactory, objectRecombinersFactory, stdDevsRecombinersFactory, rotationsRecombinersFactory);
}
else
{
engine = Create(evolutionParameters, solutionsFactory, populationGeneratorsFactory,
objectMutatorsFactory, stdDevsMutatorsFactory, mutationRuleSupervisorsFactory, parentsSelectorsFactory, survivorsSelectorsFactory, rotationsMutatorsFactory);
}
}
else
{
if (evolutionParameters.UseRecombination)
{
IGenericFactory <RecombinerBase> objectRecombinersFactory = new ObjectRecombinersFactory();
IGenericFactory <RecombinerBase> stdDevsRecombinersFactory = new StdDevsRecombinersFactory();
engine = Create(evolutionParameters, solutionsFactory, populationGeneratorsFactory,
objectMutatorsFactory, stdDevsMutatorsFactory, mutationRuleSupervisorsFactory, parentsSelectorsFactory, survivorsSelectorsFactory, null, objectRecombinersFactory, stdDevsRecombinersFactory);
}
else
{
engine = Create(evolutionParameters, solutionsFactory, populationGeneratorsFactory,
objectMutatorsFactory, stdDevsMutatorsFactory, mutationRuleSupervisorsFactory, parentsSelectorsFactory, survivorsSelectorsFactory);
}
}
return(engine);
}
public override Solution[] GeneratePopulation(EvolutionParameters evolutionParameters)
{
var basePopulationSize = evolutionParameters.BasePopulationSize;
var population = new Solution[basePopulationSize];
for (var i = 0; i < basePopulationSize; i++)
{
var solution = _solutionsFactory.Create(evolutionParameters);
population[i] = GenerateCoefficients(solution);
}
return(population);
}
public ParentsSelectorBase Create(EvolutionParameters evolutionParameters)
{
switch ((ParentsSelectionType)evolutionParameters.TypeOfParentsSelection)
{
case ParentsSelectionType.Random:
return(new ParentsRandomSelector());
case ParentsSelectionType.Even:
return(new ParentsEvenSelector(evolutionParameters));
default:
throw new ArgumentOutOfRangeException();
}
}
public ParentsEvenSelector(EvolutionParameters evolutionParameters)
{
_randomGenerator = MersenneTwister.Instance;
var basePopulationSize = evolutionParameters.BasePopulationSize;
_parentIndexesReadonly = new List <int>(basePopulationSize);
for (var i = 0; i < basePopulationSize; i++)
{
_parentIndexesReadonly.Add(i);
}
_parentIndexes = _parentIndexesReadonly.DeepCopyByExpressionTree();
}
public SurvivorsSelectorBase Create(EvolutionParameters evolutionParameters)
{
var typeOfSurvivorsSelection = (SurvivorsSelectionType)evolutionParameters.TypeOfSurvivorsSelection;
switch (typeOfSurvivorsSelection)
{
case SurvivorsSelectionType.Distinct:
return(new SurvivorsDistinctSelector(evolutionParameters));
case SurvivorsSelectionType.Union:
return(new SurvivorsUnionSelector(evolutionParameters));
default:
throw new ArgumentOutOfRangeException();
}
}
public RecombinerBase Create(EvolutionParameters evolutionParameters)
{
var typeOfObjectsRecombination = (RecombinationType)evolutionParameters.TypeOfObjectsRecombination;
switch (typeOfObjectsRecombination)
{
case RecombinationType.Discrete:
return(new ObjectDiscreteRecombiner());
case RecombinationType.Intermediate:
return(new ObjectIntermediateRecombiner());
default:
throw new ArgumentOutOfRangeException();
}
}
public IEngine Create(EvolutionParameters evolutionParameters, IGenericFactory <Solution> solutionsFactory, IGenericFactory <PopulationGeneratorBase> populationGeneratorsFactory, IGenericFactory <MutatorBase> objectMutatorsFactory, IGenericFactory <MutatorBase> stdDevsMutatorsFactory, IGenericFactory <MutationRuleSupervisorBase> mutationRuleSupervisorsFactory, IGenericFactory <ParentsSelectorBase> parentsSelectorsFactory, IGenericFactory <SurvivorsSelectorBase> survivorsSelectorsFactory,
IGenericFactory <MutatorBase> rotationsMutatorsFactory = null, IGenericFactory <RecombinerBase> objectRecombinersFactory = null,
IGenericFactory <RecombinerBase> stdDevsRecombinersFactory = null, IGenericFactory <RecombinerBase> rotationsRecombinersFactory = null)
{
IEngine engine;
var populationGenerator = populationGeneratorsFactory.Create(evolutionParameters);
var objectMutator = objectMutatorsFactory.Create(evolutionParameters);
var stdDevsMutator = stdDevsMutatorsFactory.Create(evolutionParameters);
var mutationRuleSupervisor = mutationRuleSupervisorsFactory.Create(evolutionParameters);
var rotationsMutator = rotationsMutatorsFactory?.Create(evolutionParameters);
var parentsSelector = parentsSelectorsFactory.Create(evolutionParameters);
var survivorsSelector = survivorsSelectorsFactory.Create(evolutionParameters);
var objectRecombiner = objectRecombinersFactory?.Create(evolutionParameters);
var stdDevsRecombiner = stdDevsRecombinersFactory?.Create(evolutionParameters);
var rotationsRecombiner = rotationsRecombinersFactory?.Create(evolutionParameters);
var statistics = new Statistics();
var stoper = new Stopwatch();
var typeOfMutation = (MutationType)evolutionParameters.TypeOfMutation;
if (typeOfMutation == MutationType.Correlated)
{
if (evolutionParameters.UseRecombination)
{
engine = new CmEngineWithRecombination(evolutionParameters, solutionsFactory, populationGenerator, objectMutator, stdDevsMutator, mutationRuleSupervisor, parentsSelector, survivorsSelector, statistics, stoper, objectRecombiner, stdDevsRecombiner, rotationsMutator, rotationsRecombiner);
}
else
{
engine = new CmEngineWithoutRecombination(evolutionParameters, solutionsFactory, populationGenerator, objectMutator, stdDevsMutator, mutationRuleSupervisor, parentsSelector, survivorsSelector, statistics, stoper, rotationsMutator);
}
}
else
{
if (evolutionParameters.UseRecombination)
{
engine = new UmEngineWithRecombination(evolutionParameters, solutionsFactory, populationGenerator, objectMutator, stdDevsMutator, mutationRuleSupervisor, parentsSelector, survivorsSelector, statistics, stoper, objectRecombiner, stdDevsRecombiner);
}
else
{
engine = new UmEngineWithoutRecombination(evolutionParameters, solutionsFactory, populationGenerator, objectMutator, stdDevsMutator, mutationRuleSupervisor, parentsSelector, survivorsSelector, statistics, stoper);
}
}
return(engine);
}
protected EngineBase(EvolutionParameters evolutionParameters, IGenericFactory <Solution> solutionsFactory, PopulationGeneratorBase populationGenerator, MutatorBase objectMutator, MutatorBase stdDeviationsMutator, MutationRuleSupervisorBase mutationRuleSupervisor, ParentsSelectorBase parentsSelector, SurvivorsSelectorBase survivorsSelector, Statistics statistics, Stopwatch stoper)
{
Parameters = evolutionParameters;
SolutionsFactory = solutionsFactory;
PopulationGenerator = populationGenerator;
ObjectMutator = objectMutator;
StdDeviationsMutator = stdDeviationsMutator;
MutationRuleSupervisor = mutationRuleSupervisor;
ParentsSelector = parentsSelector;
SurvivorsSelector = survivorsSelector;
Statistics = statistics;
Stoper = stoper;
BasePopulation = new Solution[evolutionParameters.BasePopulationSize];
OffspringPopulation = new Solution[evolutionParameters.OffspringPopulationSize];
EvolutionStepsSimple = new List <Solution>(evolutionParameters.NumberOfGenerations);
EvolutionSteps = new Dictionary <int, EvolutionStep>(evolutionParameters.NumberOfGenerations);
}
public MutationRuleSupervisorBase Create(EvolutionParameters evolutionParameters)
{
var typeOfMutation = (MutationType)evolutionParameters.TypeOfMutation;
switch (typeOfMutation)
{
case MutationType.UncorrelatedOneStep:
return(new OsmOneFifthRuleSupervisor(evolutionParameters.OneFifthRuleCheckInterval, evolutionParameters.OneFifthRuleScalingFactor));
case MutationType.UncorrelatedNSteps:
return(new NsmOneFifthRuleSupervisor(evolutionParameters.OneFifthRuleCheckInterval, evolutionParameters.OneFifthRuleScalingFactor));
case MutationType.Correlated:
return(new NsmOneFifthRuleSupervisor(evolutionParameters.OneFifthRuleCheckInterval, evolutionParameters.OneFifthRuleScalingFactor));
default:
throw new ArgumentOutOfRangeException();
}
}
public PopulationGeneratorBase Create(EvolutionParameters evolutionParameters)
{
var typeOfMutation = (MutationType)evolutionParameters.TypeOfMutation;
switch (typeOfMutation)
{
case MutationType.UncorrelatedOneStep:
return(new OsmPopulationRandomGenerator(_solutionsFactory));
case MutationType.UncorrelatedNSteps:
return(new NsmPopulationRandomGenerator(_solutionsFactory));
case MutationType.Correlated:
return(new CmPopulationRandomGenerator(_solutionsFactory));
default:
throw new ArgumentOutOfRangeException();
}
}
public MutatorBase Create(EvolutionParameters evolutionParameters)
{
var typeOfMutation = (MutationType)evolutionParameters.TypeOfMutation;
switch (typeOfMutation)
{
case MutationType.UncorrelatedOneStep:
return(new OsmObjectMutator());
case MutationType.UncorrelatedNSteps:
return(new NsmObjectMutator());
case MutationType.Correlated:
return(new CmObjectMutator(evolutionParameters));
default:
throw new ArgumentOutOfRangeException();
}
}
public Solution Create(EvolutionParameters evolutionParameters)
{
var typeOfmutation = (MutationType)evolutionParameters.TypeOfMutation;
var objectVectorSize = evolutionParameters.ObjectVectorSize;
switch (typeOfmutation)
{
case MutationType.UncorrelatedOneStep:
return(new Solution(objectVectorSize));
case MutationType.UncorrelatedNSteps:
return(new NsmSolution(objectVectorSize));
case MutationType.Correlated:
return(new CmSolution(objectVectorSize));
default:
throw new ArgumentOutOfRangeException();
}
}
/// <summary>
/// Localises evolutionary parameters related to score boundaries for candidates.
/// </summary>
/// <param name="parameters">Evolution parameters.</param>
private static void SetupScoreParameters(EvolutionParameters parameters)
{
_scoreConnectTwoMin = parameters.GetCandidateScoreParameterMin(CandidateScoreTypes.ScoreConnectTwo);
_scoreConnectTwoMax = parameters.GetCandidateScoreParameterMax(CandidateScoreTypes.ScoreConnectTwo);
_scoreConnectThreeMin = parameters.GetCandidateScoreParameterMin(CandidateScoreTypes.ScoreConnectThree);
_scoreConnectThreeMax = parameters.GetCandidateScoreParameterMax(CandidateScoreTypes.ScoreConnectThree);
_scoreConnectFourMin = parameters.GetCandidateScoreParameterMin(CandidateScoreTypes.ScoreConnectFour);
_scoreConnectFourMax = parameters.GetCandidateScoreParameterMax(CandidateScoreTypes.ScoreConnectFour);
_scoreGivingConnectTwoMin = parameters.GetCandidateScoreParameterMin(CandidateScoreTypes.GiveConnectTwo);
_scoreGivingConnectTwoMax = parameters.GetCandidateScoreParameterMax(CandidateScoreTypes.GiveConnectTwo);
_scoreGivingConnectThreeMin = parameters.GetCandidateScoreParameterMin(CandidateScoreTypes.GiveConnectThree);
_scoreGivingConnectThreeMax = parameters.GetCandidateScoreParameterMax(CandidateScoreTypes.GiveConnectThree);
_scoreGivingConnectFourMin = parameters.GetCandidateScoreParameterMin(CandidateScoreTypes.GiveConnectFour);
_scoreGivingConnectFourMax = parameters.GetCandidateScoreParameterMax(CandidateScoreTypes.GiveConnectThree);
}
void Initialize()
{
if (_population.Length > 0)
{
for (int i = 0; i < PopulationSize; i++)
{
Destroy(((RobotIndividual)_population[i]).Robot.gameObject);
}
}
_population = new Individual[PopulationSize];
List <NeatGenome> genomeList = _genomeFactory.CreateGenomeList(PopulationSize, 0);
for (int i = 0; i < PopulationSize; i++)
{
Robot robot = Instantiate(Robot).GetComponent <Robot>();
robot.Initialize(genomeList[i]);
RobotIndividual individual = new RobotIndividual(robot, null);
_population[i] = individual;
}
if (_epoch >= _parameters.Length)
{
_experiment++;
_epoch = 0;
}
EvolutionParameters parameters = _parameters[_epoch];
_selection = parameters.Selection;
_container = parameters.Container;
_container.Clear();
_variations = parameters.Variations;
DataCollection.NewExperiment(parameters);
_best = 0;
}
public ExperimentParameters(int numberOfDimensions, int maximumNumberOfConstraints, int numberOfConstraintsCoefficients, EvolutionParameters evolutionParameters, int seed, bool trackEvolutionSteps, bool useRedundantConstraintsRemoving, bool useDataNormalization, bool allowQuadraticTerms, bool useSeeding, BenchmarkType typeOfBenchmark, double ballnBoundaryValue, double cubenBoundaryValue, double simplexnBoundaryValue, long numberOfDomainSamples, int numberOfTestPoints, int numberOfPositivePoints, int numberOfNegativePoints, double defaultDomainLowerLimit, double defaultDomainUpperLimit, int maxNumberOfPointsInSingleArray)
{
NumberOfDimensions = numberOfDimensions;
MaximumNumberOfConstraints = maximumNumberOfConstraints;
NumberOfConstraintsCoefficients = numberOfConstraintsCoefficients;
EvolutionParameters = evolutionParameters;
Seed = seed;
TrackEvolutionSteps = trackEvolutionSteps;
UseRedundantConstraintsRemoving = useRedundantConstraintsRemoving;
UseDataNormalization = useDataNormalization;
AllowQuadraticTerms = allowQuadraticTerms;
UseSeeding = useSeeding;
TypeOfBenchmark = typeOfBenchmark;
BallnBoundaryValue = ballnBoundaryValue;
CubenBoundaryValue = cubenBoundaryValue;
SimplexnBoundaryValue = simplexnBoundaryValue;
NumberOfDomainSamples = numberOfDomainSamples;
NumberOfTestPoints = numberOfTestPoints;
NumberOfPositivePoints = numberOfPositivePoints;
NumberOfNegativePoints = numberOfNegativePoints;
DefaultDomainLowerLimit = defaultDomainLowerLimit;
DefaultDomainUpperLimit = defaultDomainUpperLimit;
MaxNumberOfPointsInSingleArray = maxNumberOfPointsInSingleArray;
}
public CmObjectMutator(EvolutionParameters evolutionParameters)
{
_zeroMeans = new double[evolutionParameters.ObjectVectorSize];
}
public void Insert(EvolutionParameters evolutionParameters)
{
Insert(evolutionParameters, _experiments, _evolutionParameters);
}
public ExperimentParameters(
int numberOfDimensions,
int basePopulationSize,
int offspringPopulationSize,
int numberOfGenerations,
int seed = EvolutionDefaults.Seed,
bool trackEvolutionSteps = EvolutionDefaults.TrackEvolutionSteps,
bool useRedundantConstraintsRemoving = Defaults.UseRedundantConstraintsRemoving,
bool useDataNormalization = Defaults.UseDataNormalization,
bool allowQuadraticTerms = Defaults.AllowQuadraticTerms,
bool useSeeding = Defaults.UseSeeding,
ISet <TermType> allowedTermsTypes = default(ISet <TermType>),
BenchmarkType typeOfBenchmark = Defaults.TypeOfBenchmark,
double ballnBoundaryValue = Defaults.BallnBoundaryValue,
double cubenBoundaryValue = Defaults.CubenBoundaryValue,
double simplexnBoundaryValue = Defaults.SimplexnBoundaryValue,
IList <Constraint> referenceConstraints = default(IList <Constraint>),
long numberOfDomainSamples = Defaults.NumberOfDomainSamples,
int numberOfTestPoints = Defaults.NumberOfTestPoints,
int numberOfPositivePoints = Defaults.NumberOfPositivePoints,
int numberOfNegativePoints = Defaults.NumberOfNegativePoints,
double defaultDomainLowerLimit = Defaults.DefaultDomainLowerLimit,
double defaultDomainUpperLimit = Defaults.DefaultDomainUpperLimit,
int maxNumberOfPointsInSingleArray = Defaults.MaxNumberOfPointsInSingleArray,
double globalLearningRate = double.NaN,
double individualLearningRate = double.NaN,
double stepThreshold = EvolutionDefaults.StepThreshold,
double rotationAngle = EvolutionDefaults.RotationAngle,
MutationType typeOfMutation = EvolutionDefaults.TypeOfMutation,
int numberOfParentsSolutionsToSelect = EvolutionDefaults.NumberOfParentsSolutionsToSelect,
ParentsSelectionType typeOfParentsSelection = EvolutionDefaults.TypeOfParentsSelection,
SurvivorsSelectionType typeOfSurvivorsSelection = EvolutionDefaults.TypeOfSurvivorsSelection,
int oneFifthRuleCheckInterval = EvolutionDefaults.OneFifthRuleCheckInterval,
double oneFifthRuleScalingFactor = EvolutionDefaults.OneFifthRuleScalingFactor,
bool useRecombination = EvolutionDefaults.UseRecombination,
RecombinationType typeOfObjectsRecombination = EvolutionDefaults.TypeOfObjectsRecombination,
RecombinationType typeOfStdDeviationsRecombination = EvolutionDefaults.TypeOfStdDeviationsRecombination,
RecombinationType typeOfRotationsRecombination = EvolutionDefaults.TypeOfRotationsRecombination)
{
if (typeOfBenchmark == BenchmarkType.Other && referenceConstraints == default(IList <Constraint>))
{
throw new ArgumentException("In case of choosing BenchmarkType = Other, it is obligatory to provide reference constraints.");
}
AllowedTermsTypes = allowedTermsTypes == default(ISet <TermType>)
? Defaults.AllowedTermsTypes
: allowedTermsTypes;
//HACK
//AllowedTermsTypes = new HashSet<TermType>
//{
// TermType.Linear,
// TermType.Quadratic
//};
//NumberOfConstraintsCoefficients = numberOfDimensions * AllowedTermsTypes.Count + 1;
NumberOfConstraintsCoefficients = typeOfBenchmark == BenchmarkType.Balln && allowQuadraticTerms
? numberOfDimensions * 2 + 1
: numberOfDimensions + 1;
//MaximumNumberOfConstraints = typeOfBenchmark == BenchmarkType.Other
// // ReSharper disable once PossibleNullReferenceException : It is checked before
// ? referenceConstraints.Count
// : GetMaximumNumberOfConstraints(numberOfDimensions, typeOfBenchmark, allowQuadraticTerms);
//MaximumNumberOfConstraints = GetMaximumNumberOfConstraints(numberOfDimensions, typeOfBenchmark,
// allowQuadraticTerms);
MaximumNumberOfConstraints = numberOfDimensions * numberOfDimensions;
var objectVectorSize = NumberOfConstraintsCoefficients * MaximumNumberOfConstraints;
NumberOfDimensions = numberOfDimensions;
EvolutionParameters = new EvolutionParameters(
objectVectorSize, basePopulationSize, offspringPopulationSize, numberOfGenerations, seed, trackEvolutionSteps,
oneFifthRuleCheckInterval, oneFifthRuleScalingFactor, numberOfParentsSolutionsToSelect, (int)typeOfParentsSelection, (int)typeOfSurvivorsSelection,
globalLearningRate, individualLearningRate, stepThreshold, rotationAngle, (int)typeOfMutation,
useRecombination, (int)typeOfObjectsRecombination, (int)typeOfStdDeviationsRecombination, (int)typeOfRotationsRecombination);
Seed = seed;
TrackEvolutionSteps = trackEvolutionSteps;
UseRedundantConstraintsRemoving = useRedundantConstraintsRemoving;
UseDataNormalization = useDataNormalization;
AllowQuadraticTerms = allowQuadraticTerms;
UseSeeding = useSeeding;
TypeOfBenchmark = typeOfBenchmark;
BallnBoundaryValue = ballnBoundaryValue;
CubenBoundaryValue = cubenBoundaryValue;
SimplexnBoundaryValue = simplexnBoundaryValue;
ReferenceConstraints = referenceConstraints;
NumberOfDomainSamples = numberOfDomainSamples;
NumberOfTestPoints = numberOfTestPoints;
NumberOfPositivePoints = numberOfPositivePoints;
NumberOfNegativePoints = numberOfNegativePoints;
DefaultDomainLowerLimit = defaultDomainLowerLimit;
DefaultDomainUpperLimit = defaultDomainUpperLimit;
MaxNumberOfPointsInSingleArray = maxNumberOfPointsInSingleArray;
}
public SurvivorsUnionSelector(EvolutionParameters evolutionParameters)
{
_basePopulationSize = evolutionParameters.BasePopulationSize;
}
public RotationsMutator(EvolutionParameters evolutionParameters)
{
_rotationsAngle = evolutionParameters.RotationAngle;
_randomGenerator = MersenneTwister.Instance;
}
public abstract Solution[] GeneratePopulation(EvolutionParameters evolutionParameters);
public CmEngineWithoutRecombination(EvolutionParameters evolutionParameters, IGenericFactory <Solution> solutionsFactory, PopulationGeneratorBase populationGenerator, MutatorBase objectMutator, MutatorBase stdDeviationsMutator, MutationRuleSupervisorBase mutationRuleSupervisor, ParentsSelectorBase parentsSelector, SurvivorsSelectorBase survivorsSelector, Statistics statistics, Stopwatch stoper, MutatorBase rotationsMutator) : base(evolutionParameters, solutionsFactory, populationGenerator, objectMutator, stdDeviationsMutator, mutationRuleSupervisor, parentsSelector, survivorsSelector, statistics, stoper)
{
RotationsMutator = rotationsMutator;
}
