public override void Evolve()
{
int individualsToEliminate = (int)(_generationGap * _populationSize);
// A single generation is when GenerationGap % of population is eliminated and replaced
IList <T> offspringPopulation = new List <T>();
while (offspringPopulation.Count < individualsToEliminate)
{
IList <T> matingPool = new List <T>(CrossoverOperator.NumberOfParents);
for (int j = 0; j < CrossoverOperator.NumberOfParents; j++)
{
T mate = SelectionOperator.Execute(_population);
matingPool.Add(mate);
}
IList <T> children = CrossoverOperator.Execute(matingPool);
for (int j = 0; j < children.Count; j++)
{
MutationOperator.Execute(children[j]);
_problem.Evaluate(children[j]);
offspringPopulation.Add(children[j]);
}
}
offspringPopulation = offspringPopulation.Take(individualsToEliminate).ToList();
_population = ReplacementOperator.Execute(_population, offspringPopulation);
UpdateState();
}
/// <summary>
/// Runs a random walk of n steps along a landscape defined by a crossover operator and returns its results.
/// </summary>
/// <param name="steps">Number of steps.</param>
/// <param name="searchOperator">Operator defining a neighbourhood.</param>
/// <returns></returns>
public RandomWalk RandomWalk(int steps, CrossoverOperator searchOperator)
{
RandomWalk statistics = new RandomWalk(steps);
Chromosome parent1 = ChromosomeFactory.RandomSolution(Problem.GeneCount(), Problem);
Chromosome parent2 = ChromosomeFactory.RandomSolution(Problem.GeneCount(), Problem);
bool firstParent = RandomGeneratorThreadSafe.NextBool();
Chromosome parent = (firstParent ? parent1 : parent2), child;
GatherData(parent, 0, statistics);
const int minPopSize = 8, maxPopSize = 15;
int popSize = RandomGeneratorThreadSafe.NextInt(minPopSize, maxPopSize);
Chromosome[] supportPopulation = new Chromosome[popSize];
for (int i = 0; i < popSize; ++i)
{
supportPopulation[i] = ChromosomeFactory.RandomSolution(Problem.GeneCount(), Problem);
}
IGene[] childGenes1, childGenes2;
for (int i = 0; i < steps; ++i)
{
searchOperator.Run(parent1.Genes, parent2.Genes, out childGenes1, out childGenes2);
child = ChromosomeFactory.MakeChromosome(Problem, RandomGeneratorThreadSafe.NextBool() ? childGenes1 : childGenes2);
GatherData(child, i, statistics);
parent1 = child;
parent2 = supportPopulation[RandomGeneratorThreadSafe.NextInt(popSize)];
}
return(statistics);
}
public static async Task <Chromosome> DoMa(string filename, CrossoverOperator crossOp, MutationOperator mutOp)
{
var problem = new VrptwProblemReader().ReadFromFile(filename);
var parameters = new Parameters()
{
ChromosomeFactory = new SolutionFactory(),
ConvergenceLimit = 0.15f,
CrossoverOperators = new List <CrossoverOperator> {
crossOp
},
CrossoverProbability = 0.9f,
EliteChildrenCount = 4,
Fitness = new FitnessFunction(200000, 1),
FitnessStrategy = FitnessStrategy.MINIMIZE,
GeneCount = problem.GeneCount(),
Heuristics = new SimulatedAnnealing(),
HeuristicsParameters = new float[] { 100, 0.90f, 50 },
MaxIterations = 300,
MutationOperators = new List <MutationOperator> {
mutOp
},
MutationProbability = 0.15f,
PopulationSize = 200,
PreservedChromosomesNumber = 4,
Selection = new TournamentSelection()
};
MemeticAlgorithm ma = new MemeticAlgorithm();
Chromosome sol = await ma.Run(problem, parameters, CallBackMa, crossOp.GetId() + "-" + mutOp.GetId());
return(sol);
}
protected virtual IEnumerable <IDeploymentChromosome> Cross(IEnumerable <IDeploymentChromosome> parents)
{
var crossoverParents = new IDeploymentChromosome[CrossoverOperator.ParentsNumber];
var i = 0;
List <IDeploymentChromosome> offspring = new List <IDeploymentChromosome>();
foreach (var parent in parents)
{
crossoverParents[i] = parent;
i++;
if (i == CrossoverOperator.ParentsNumber)
{
if (RandomProvider.GetRandom() <= CrossoverProbability)
{
offspring.AddRange(CrossoverOperator.Cross(crossoverParents));
}
else
{
offspring.AddRange(crossoverParents);
}
i = 0;
}
}
if (i != 0)
{
offspring.AddRange(crossoverParents.Take(i));
}
return(offspring);
}
static GeneticAlgorithm()
{
Input = null;
TournamentSize = 3;
MutationRate = 0.5;
Generations = 0;
CrossoverOperator = CrossoverOperator.Default;
}
private void CreateNextGeneration()
{
var startingIndex = UsingElitism ? NumberOfElite : 0;
if (UsingElitism)
{
Population.SortByFitness();
for (int i = 0; i < NumberOfElite; i++)
{
Population.AddChromosome(i, Population.Chromosomes[i]);
}
startingIndex = NumberOfElite;
}
var populationSize = Population.PopulationSize;
for (int i = startingIndex; i < populationSize; i++)
{
// TODO -> Should I make sure that both parents are different ??
// selection operation
var fatherChromosome = SelectionOperator.PopulationSelection(Population);
var motherChromosome = SelectionOperator.PopulationSelection(Population);
// TODO -> return more than one child always!!!
// crossover operation
var childChromosome = CrossoverOperator.Crossover(fatherChromosome, motherChromosome); // TODO -> some crossovers can return more than one child
// mutate operation
MutationOperator.Mutate(childChromosome);
// add child chromsome to the next generation population
CalculateFitness(childChromosome);
Population.AddChromosome(i, childChromosome);
}
// prepare for next evolution
Population.SetNextGeneration();
SelectionOperator.SetNextGeneration();
Generation++;
}
public GeneticAlgorithm(
int populationSize, int paramsCount, double generationGapPart,
ISelection selection,
CrossoverOperator crossoverOperator,
MutationOperator mutationOperator,
IFitnessFunc fitnessFunc,
FloatRange range)
{
chromosomes = new List <IntChromosome>(populationSize);
this.generationGapPart = generationGapPart;
this.selection = selection;
this.crossoverOperator = crossoverOperator;
this.mutationOperator = mutationOperator;
this.fitnessFunc = fitnessFunc;
this.paramsCount = paramsCount;
this.range = range;
generatePopulationInt = new GeneratePopulationInt();
random = new Random();
bitCountForIntCoding = Coder.BitCountForIntCoding(range);
GeneratePopulation();
}
public override void Evolve()
{
IList <T> offspringPopulation = new List <T>();
// Let elites survive to next generation
int numberOfElites = (int)(_elitismRate * _populationSize);
IList <T> elites = _population
.OrderByDescending(c => c, _problem.FitnessComparer)
.Take(numberOfElites).ToList();
foreach (T individual in elites)
{
offspringPopulation.Add(individual);
}
while (offspringPopulation.Count < _populationSize)
{
IList <T> matingPool = new List <T>(CrossoverOperator.NumberOfParents);
for (int i = 0; i < CrossoverOperator.NumberOfParents; i++)
{
matingPool.Add(SelectionOperator.Execute(_population));
}
IList <T> children = CrossoverOperator.Execute(matingPool);
for (int i = 0; i < children.Count; i++)
{
MutationOperator.Execute(children[i]);
_problem.Evaluate(children[i]);
offspringPopulation.Add(children[i]);
}
}
// When there is some excess chromosomes, discard them by taking only the needed ones
_population = offspringPopulation.Take(_populationSize).ToList();
UpdateState();
}
/// <summary>
/// Sets the options and other configuration used in the GA.
/// </summary>
private void ApplyOptions()
{
/*** setting the selection operator to the specified type ***/
var selectionType = GaOptions.SelectionType;
if (selectionType == SelectionType.None)
{
throw new Exception("Selection method cannot be none when setting the method.");
}
var populationSize = Population.PopulationSize;
switch (selectionType)
{
case SelectionType.Rws:
SelectionOperator = new RouletteWheelSelection <T>(populationSize, Random);
break;
case SelectionType.Tos:
// the tournamnet selection percentage is hardcoded for now to 2%, TODO => this must be passed in the GA Options
SelectionOperator = new TournamentSelection <T>(populationSize, Random, 0.02);
break;
}
/*** setting the selection operator to the specified type ***/
/*** setting the crossover operator to the specified type ***/
var crossoverType = GaOptions.CrossoverType;
if (crossoverType == CrossoverType.None)
{
throw new Exception("Crossover method cannot be none when setting the method.");
}
switch (crossoverType)
{
case CrossoverType.OrderOne:
CrossoverOperator = new OrderOne <T>(Random);
break;
case CrossoverType.Cycle:
CrossoverOperator = new CycleCrossover <T>(Random);
break;
}
/*** setting the crossover operator to the specified type ***/
/*** setting the mutation operator to the specified type ***/
var mutationType = GaOptions.MutationType;
if (mutationType == MutationType.None)
{
throw new Exception("Mutation method cannot be none when setting the method.");
}
switch (mutationType)
{
case MutationType.SingleSwap:
MutationOperator = new SingleSwapMutation <T>(Random);
break;
case MutationType.InversionMutation:
MutationOperator = new InversionMutation <T>(Random, GaOptions.MutationRate);
break;
}
/*** setting the mutation operator to the specified type ***/
/*** setting the stopping criteria for the algorithm ***/
var stoppingCriteriaOptions = GaOptions.StoppingCriteriaOptions;
var stoppingCriteriaType = stoppingCriteriaOptions.StoppingCriteriaType;
switch (stoppingCriteriaType)
{
case StoppingCriteriaType.TimeBased:
var minutesPassed = stoppingCriteriaOptions.MinutesPassed;
if (minutesPassed <= 0)
{
throw new Exception($"When using {stoppingCriteriaType}, the minutes passed must be larger than 0.");
}
StoppingCriteria = new TimeBaseStoppingCriteria(minutesPassed);
break;
case StoppingCriteriaType.SpecifiedIterations:
var maximumIterations = stoppingCriteriaOptions.MaximumIterations;
if (maximumIterations <= 0)
{
throw new Exception($"When using {stoppingCriteriaType}, the max iterations must be larger than 0.");
}
StoppingCriteria = new IterationStoppingCriteria(maximumIterations);
break;
}
/*** setting the stopping criteria for the algorithm ***/
}
public AirfoilCrossover(CrossoverOperator crossoverOperator)
{
this.crossoverOperator = crossoverOperator;
}
private void Crossover(Individual[] generation, Individual[] extendedGeneration, int[] probabilities)
{
Random random = new Random(Guid.NewGuid().GetHashCode());
for (int i = 0; i < extendedGeneration.Length; i += 2)
{
CrossoverOperator(SelectParents(), (extendedGeneration[i], extendedGeneration[i + 1]));
}
(Individual FirstParent, Individual SecondParent) SelectParents()
{
Individual first = generation[probabilities[random.Next(0, probabilities.Length)]];
Individual second = first;
while (first == second)
{
second = generation[probabilities[random.Next(0, probabilities.Length)]];
}
return(first, second);
}
void CrossoverOperator((Individual FirstParent, Individual SecondParent) parents, (Individual FirstChild, Individual SecondChild) childs)
{
Individual firstParent = parents.FirstParent;
Individual secondParent = parents.SecondParent;
double firstParentFitness = firstParent.Fitness;
double secondParentFitness = secondParent.Fitness;
Individual better;
Individual worse;
if (firstParentFitness < secondParentFitness)
{
better = firstParent;
worse = secondParent;
}
else
{
better = secondParent;
worse = firstParent;
}
double chanceToSelectBetter = worse.Fitness / (firstParentFitness + secondParentFitness);
byte[] firstKey = childs.FirstChild.Key;
byte[] secondKey = childs.SecondChild.Key;
HashSet <byte> left = CloneByteAlphabet;
var used = _marksArrayPool.Rent(_alphabetLength);
FillKey(firstKey);
left = CloneByteAlphabet;
for (int i = 0; i < used.Length; i++)
{
used[i] = false;
}
FillKey(secondKey);
_marksArrayPool.Return(used, true);
void FillKey(byte[] key)
{
for (int i = 0; i < _alphabetLength; i++)
{
bool u_1 = used[better.Key[i]];
bool u_2 = used[worse.Key[i]];
byte value;
if ((u_1 && !u_2) || (u_2 && !u_1))
{
value = u_2 ? better.Key[i] : worse.Key[i];
}
else if (!u_1 && !u_2)
{
value = random.NextDouble() < chanceToSelectBetter ? better.Key[i] : worse.Key[i];
}
else
{
value = left.ElementAt(random.Next(0, left.Count));
}
key[i] = value;
used[value] = true;
left.Remove(value);
}
}
}
}
public void SetUp()
{
singlePointCrossover = new SinglePointCrossover<int> ();
mockNumberStream = new MockNumberStream ();
}
public void Test1()
{
AbstractChromosomeFactory factory = new SolutionFactory();
int[] routeWeights = new int[]
{
20000, 50000, 120000, 200000, 350000
};
int distanceWeight = 1;
string[] customerTypes = new string[] { "C1", "C2", "R1", "R2", "RC1", "RC2" };
Dictionary <string, int> customerNumbers = new Dictionary <string, int>()
{
{ "2", 20000 }, { "4", 50000 }, { "6", 120000 }, { "8", 200000 }, { "10", 350000 }
};
string[] customerInstances = new string[] { "1", "2", "3", "4", "5", "6", "7", "8", "9", "10" };
CrossoverOperator[] crossoverOps = new CrossoverOperator[]
{
new OrderCrossover(), new PartiallyMatchedCrossover(), new CycleCrossover(), new UniformBasedOrderCrossover()
};
MutationOperator[] mutationOps = new MutationOperator[]
{
new SwapOperator(), new InsertionOperator(), new InversionOperator(), new DisplacementOperator()
};
int randomWalkNumber = 2000, randomWalkSteps = 5000;
string floatPattern = "0.000", separator = ",";
float epsilon = 0.05f;
foreach (var type in customerTypes)
{
foreach (var number in customerNumbers)
{
foreach (var instance in customerInstances)
{
string instanceId = type + '_' + number.Key + '_' + instance;
VrptwProblem problem = reader.ReadFromFile(FILE_PATH + @"\" + instanceId + ".txt");
FitnessFunction ff = new FitnessFunction(number.Value, distanceWeight);
Landscape landscape = new Landscape(problem, factory, ff);
foreach (var op in crossoverOps)
{
string path = RESULT_PATH + @"\" + instanceId + "_" + op.GetId() + ".csv";
if (!File.Exists(path))
{
File.Create(path).Close();
File.ReadAllText(path);
using (TextWriter tw = new StreamWriter(path))
{
tw.WriteLine("AC, IC, PIC, DBI");
for (int i = 0; i < randomWalkNumber; ++i)
{
var rwResult = landscape.RandomWalk(randomWalkSteps, op);
float ac = Autocorrelation.Run(rwResult);
float ic = InformationContent.Run(rwResult, epsilon);
float pic = PartialInformationContent.Run(rwResult, epsilon);
float dbi = DensityBasinInformation.Run(rwResult, epsilon);
string line =
ac.ToString(floatPattern) + separator +
ic.ToString(floatPattern) + separator +
pic.ToString(floatPattern) + separator +
dbi.ToString(floatPattern);
tw.WriteLine(line);
}
}
}
}
}
}
}
}
