public static AbstractMutation ChosenMutationMethod(MutationMethod mutationMethod, double MutationProbability, int pointMutation)
{
AbstractMutation mutation = null;
switch (mutationMethod)
{
case MutationMethod.InversionMutation:
mutation = new InversionMutation(MutationProbability, pointMutation);
break;
case MutationMethod.ReplaceMutation:
mutation = new ReplaceMutaion(MutationProbability, pointMutation);
break;
case MutationMethod.SwapMutation:
mutation = new SwapMutation(MutationProbability, pointMutation);
break;
case MutationMethod.TranslocationMutation:
mutation = new TranslocationMutation(MutationProbability, pointMutation);
break;
case MutationMethod.NonMutation:
mutation = null;
break;
}
return(mutation);
}
/// <summary>
/// Конструктор с параметрами.
/// </summary>
/// <param name="IterationSize">Количество итераций ГА.</param>
/// <param name="PopulationSize">Размер популяции.</param>
/// <param name="crossoverMethod">Оператор кроссовера.</param>
/// <param name="CrossoverProbability">Вероятность кроссовера.</param>
public CHCGA(int IterationSize, int PopulationSize,
double CrossoverProbability,
MutationMethod mutationMethod, int dotMutation,
int minHemmingDistance)
: base(IterationSize, PopulationSize)
{
this.CrossoverProbability = CrossoverProbability;
this.mutationMethod = mutationMethod;
this.minHemmingDistance = minHemmingDistance;
this.dotMutation = dotMutation;
}
public ClassicGA(int IterationSize, int PopulationSize,
CrossoverMethod crossoverMethod, double CrossoverProbability, int dotCrossover,
MutationMethod mutationMethod, double MutationProbability, int dotMutation, SelectionMethod selectionMethod,
int CountSelected, int CountTour)
: base(IterationSize, PopulationSize)
{
this.crossoverMethod = crossoverMethod;
this.CrossoverProbability = CrossoverProbability;
this.mutationMethod = mutationMethod;
this.MutationProbability = MutationProbability;
this.dotCrossover = dotCrossover;
this.dotMutation = dotMutation;
this.selectionMethod = selectionMethod;
this.CountSelected = CountSelected;
this.CountTour = CountTour;
}
private IMutation GetMutationMethod(MutationMethod mutationMethod)
{
switch (mutationMethod)
{
case (MutationMethod.Edge):
return(new EdgeMutation());
case (MutationMethod.OnePoint):
return(new OnePointMutation());
case (MutationMethod.TwoPoints):
return(new TwoPointMutation());
default:
throw new ArgumentException("Mutation method was not foud.");
}
}
public GeneticAlgorithm(int genomsInGeneration, int generationCount, double mutProb, FirstGenerationGenerator _fgg, CrossoverMethod _cm,
MutationMethod _mm, SelectionMethod _sm, FitnessFunction ff)
{
this.genomLength = ff.GetArity();
this.genomsInGeneration = genomsInGeneration;
this.fgg = _fgg;
this.mutationProbability = mutProb;
this.generationCount = generationCount;
Generation = new List <Path>();
Child = new List <Path>();
Buffer = new List <Path>();
solution = new Path(genomLength);
FitFunc = ff;
this.cm = _cm;
this.mm = _mm;
this.sm = _sm;
}
public static Mutation CreateMutation(MutationMethod mutationMethod, MutationMethod[] mutationMethods,
int[][] population, double mutationProbability, Random random)
{
Mutation mutation = mutationMethod switch
{
MutationMethod.RSM => new RSMutation(mutationProbability, population, random),
MutationMethod.TWORS => new TWORSMutation(mutationProbability, population, random),
MutationMethod.CIM => new CIMutation(mutationProbability, population, random),
MutationMethod.THROAS => new THROASMutation(mutationProbability, population, random),
MutationMethod.THRORS => new THRORSMutation(mutationProbability, population, random),
MutationMethod.MAM => new MAMutation(mutationMethods, mutationProbability, population, random),
MutationMethod.MRM => new MRMutation(mutationMethods, mutationProbability, population, random),
_ => throw new AggregateException("Wrong mutation method name")
};
return(mutation);
}
}
private Individual Mutuj(MutationMethod mutationMethod, List <Individual> population, int a, int b)
{
var randomIndividual = GetRandomIndividual(population);
switch (mutationMethod)
{
case MutationMethod.ONE_POINT:
return(_mutacjaJednopunktowa.Mutuj(randomIndividual));
case MutationMethod.TWO_POINT:
return(_mutacjaDwupunktowa.Mutuj(randomIndividual));
case MutationMethod.BRZEGOWA:
return(_mutacjaBrzegowa.Mutuj(randomIndividual));
default:
throw new NotImplementedException();
}
}
public void Run()
{
Console.WriteLine("GA is running...");
for (var i = 0; i < _iterations; i++)
{
CalculateFitness(_populations[i]);
BestEntities.Add(_populations[i].GetBestEntity().Fitness);
BestHistoryEntities.Add(BestEntities.Max());
MeanPopulation.Add(_populations[i].Entities.Select(x => x.Fitness).Sum() / _populations[i].Entities.Count);
var newPopulation = SelectionMethod.ConductSelection(_populations[i]);
newPopulation = CrossoverMethod.Crossover(newPopulation);
newPopulation = MutationMethod.Mutate(newPopulation);
_populations.Add(newPopulation);
}
Console.WriteLine("Finished");
}
static void Main(string[] args)
{
FirstGenerationGenerator FGG = new FirstGenerationGenerator();
CrossoverMethod CM = new CrossoverMethod();
MutationMethod MM = new MutationMethod();
SelectionMethod SM = new SelectionMethod();
double mutationProbability = 0;
int genomsInGeneration = 0;
int generationCount = 0;
int option = 0;
System.Console.WriteLine("Enter count of genoms");
genomsInGeneration = Convert.ToInt32(Console.ReadLine());
System.Console.WriteLine("Enter count of generations");
generationCount = Convert.ToInt32(Console.ReadLine());
System.Console.WriteLine("Enter mutation probability");
mutationProbability = Convert.ToDouble(Console.ReadLine());
System.Console.WriteLine("Choose first generatioh generator: 1-Random 2-Nearest neighbor");
option = Convert.ToInt32(Console.ReadLine());
if (option == 1)
{
FGG = FirstGenerationGenerator.Rand;
}
else
if (option == 2)
{
FGG = FirstGenerationGenerator.NearestNeighbor;
}
System.Console.WriteLine("Choose crossover method: 1-OX 2-PMX");
option = Convert.ToInt32(Console.ReadLine());
if (option == 1)
{
CM = CrossoverMethod.OX;
}
else
if (option == 2)
{
CM = CrossoverMethod.PMX;
}
System.Console.WriteLine("Choose mutation method: 1-Inversion 2-Saltation");
option = Convert.ToInt32(Console.ReadLine());
if (option == 1)
{
MM = MutationMethod.Inversion;
}
else
if (option == 2)
{
MM = MutationMethod.Saltation;
}
System.Console.WriteLine("Choose selection method: 1-Tourney 2-Roulette wheel");
option = Convert.ToInt32(Console.ReadLine());
if (option == 1)
{
SM = SelectionMethod.Tourney;
}
else
if (option == 2)
{
SM = SelectionMethod.RouletteWheel;
}
FitnessFunction ff = new FitnessFunction(new Matrix("C:/Users/Ильяс/source/repos/EGA/EGA/m1.txt"));
GeneticAlgorithm ga = new GeneticAlgorithm(genomsInGeneration, generationCount, mutationProbability, FGG, CM, MM, SM, ff);
ga.Run();
System.Console.ReadKey();
}
public List <Individual> Execute(int a, int b, int populationAmount, int numberOfBits, int epochsAmount, double bestAndTournamentChomosomeAmount, double eliteStrategyAmount, double crossProbability, double mutationProbability, double inversionProbability, SelectionMethod selectionMethod, CrossMethod crossMethod, MutationMethod mutationMethod, bool maximization)
{
//Poczatkowa populacja
var population = _individualGenerator.GenerateList(populationAmount, numberOfBits, a, b);
DataSaver dataSaver = new DataSaver();
dataSaver.createFile();
var bestIndividuals = new List <Individual>();
for (int i = 0; i < epochsAmount; i++)
{
//Selekcja
var afterSelection = Wyselekcjuj(selectionMethod, population, bestAndTournamentChomosomeAmount, maximization);
var newPopulation = new List <Individual>();
// strategia elitarna - wez X procent najlepszych do nowej populacji
newPopulation.AddRange(_selekcjaNajlepszych.Select(afterSelection, eliteStrategyAmount, maximization));
//Mutacja, krzyzowanie i inwersja
while (newPopulation.Count < population.Count)
{
if (ShouldPerformAction(crossProbability) && newPopulation.Count + 1 < population.Count)
{
newPopulation.AddRange(Krzyzuj(crossMethod, afterSelection, a, b));
}
if (ShouldPerformAction(mutationProbability) && newPopulation.Count < population.Count)
{
newPopulation.Add(Mutuj(mutationMethod, afterSelection, a, b));
}
if (ShouldPerformAction(inversionProbability) && newPopulation.Count < population.Count)
{
newPopulation.Add(Inwersuj(afterSelection, a, b));
}
}
bestIndividuals.AddRange(_selekcjaNajlepszych.Select(newPopulation, 1.0 / (newPopulation.Count), maximization)); // dodanie najlepszego do listy
dataSaver.saveIndividualsFromEpoche(i, population);
population = newPopulation;
}
dataSaver.saveChart(bestIndividuals);
return(population);
}
/// <summary>
/// Runs the genetic algorithm for the specified number of generations
/// </summary>
/// <param name="numGenerations">The number of generations</param>
/// <returns></returns>
public void Run()
{
ICollection <IGenotype> nextPopulation;
List <IGenotype> parents;
Gene[][] children;
IGenotype child;
double fitness;
bool mutated, solutionFound;
ParameterCheck();
if (Population == null)
{
InitializePopulation();
}
if (AllowDuplicates)
{
nextPopulation = new List <IGenotype>(PopulationSize);
}
else
{
nextPopulation = new SafeHashSet <IGenotype>(MaxRetriesForDuplicates);
}
solutionFound = false;
if (PreserveElitePercent > 0)
{
foreach (IGenotype individual in Population.Take((int)(PreserveElitePercent * PopulationSize)).ToList())
{
nextPopulation.Add(individual);
}
}
SelectionMethod.Initialize(Population);
while (nextPopulation.Count < PopulationSize)
{
try
{
parents = SelectionMethod.DoSelection();
}
catch (SafeHashSetException)
{
Converged = true;
break;
}
// Perform crossover
children = CrossoverMethod.DoCrossover <Gene>(parents);
// Iterate through each child produced by crossover
for (int i = 0; i < children.Length; i++)
{
// Calculate fitness of child
fitness = FitnessFunction(children[i], out solutionFound);
// Perform mutation (but skip if solution has been found)
mutated = solutionFound ? false : MutationMethod.DoMutation <Gene>(ref children[i]); // TODO return mutation and use only if better fitness??? Make a parameter to turn on/off
// Recalculate fitness if mutation occurred
if (mutated)
{
fitness = FitnessFunction(children[i], out solutionFound);
}
// Instantiate child
child = CreateMethod(children[i], fitness);
try
{
nextPopulation.Add(child);
if (solutionFound)
{
break;
}
}
catch (SafeHashSetException)
{
Converged = true;
break;
}
}
if (solutionFound || Converged)
{
break;
}
}
GenerationNumber++;
SolutionFound = solutionFound;
Population = nextPopulation.OrderByDescending(x => x.Fitness).ToList();
BestCurrent = Population.First();
FinishedGeneration?.Invoke();
foreach (Termination.TerminationMethod t in TerminationMethods)
{
if (t.CheckTermination(this))
{
Terminated = true;
TerminationReached?.Invoke();
}
}
}
