/// <summary>
/// Creates a new <see cref="Population{TProgram,TOutput}" /> with the given arguments.
/// </summary>
/// <param name="maxSize">The maximum size of the population.</param>
/// <param name="primitives">The primitive set used to generate new programs.</param>
/// <param name="programGenerator">The generator of new programs.</param>
/// <param name="programComparer">The function used to compare programs and select the best program.</param>
/// <param name="selectionOperator">The operator to perform selection.</param>
/// <param name="crossoverOperator">The operator to crossover programs. </param>
/// <param name="mutationOperator">The operator to mutate programs.</param>
/// <param name="maxGenerationDepth">The maximum depth of elements generated during GP.</param>
/// <param name="maxElementLength">The maximum length of elements generated during GP.</param>
/// <param name="crossoverPercent">The percentage of a population used for the crossover operator during GP.</param>
/// <param name="mutationPercent">The percentage of a population used for the mutation operator during GP.</param>
/// <param name="elitismPercent">The percentage of a population used for elite selection during GP.</param>
public Population(
uint maxSize,
PrimitiveSet <TProgram> primitives,
IProgramGenerator <TProgram, TOutput> programGenerator,
IComparer <TProgram> programComparer,
ISelectionOperator <TProgram> selectionOperator,
ICrossoverOperator <TProgram> crossoverOperator,
IMutationOperator <TProgram> mutationOperator,
uint maxGenerationDepth = 4,
uint maxElementLength = 20,
double crossoverPercent = 0.65d,
double mutationPercent = 0.2d,
double elitismPercent = 0.1d)
{
this._maxSize = maxSize;
this._primitives = primitives;
this._programGenerator = programGenerator;
this._maxGenerationDepth = maxGenerationDepth;
this._maxElementLength = maxElementLength;
this._programComparer = programComparer;
this._selectionOperator = selectionOperator;
this._mutationOperator = mutationOperator;
this._crossoverOperator = crossoverOperator;
this.ElitismPercent = elitismPercent;
this.MutationPercent = mutationPercent;
this.CrossoverPercent = crossoverPercent;
}
private void InitializeGeneticAlgorithm()
{
fitnessFunction = new FitnessFunction(inventory);
selectionOperator = new RouletteWheelSelection();
elitistSelection = new ElitistSelection();
crossoverOperator = new ContinuousUniformCrossover();
mutationOperator = new WeightsMutation();
initialPopulationProvider = new InitialPopulationProvider();
settings = new Settings
{
Inventory = inventory,
NumberOfCriterias = 3,
NumberOfElites = Convert.ToInt32(inputElites.Value),
PopulationSize = Convert.ToInt32(inputMaxPopulation.Value),
CrossoverRate = Convert.ToDouble(inputCrossoverRate.Value),
MutationRate = Convert.ToDouble(inputMutationRate.Value)
};
selectionOperator = new TournamentSelection(Convert.ToInt32(inputTournamentSize.Value));
geneticAlgorithm = new GeneticAlgorithm(settings, initialPopulationProvider, fitnessFunction, selectionOperator, elitistSelection, crossoverOperator, mutationOperator);
generationsPlotData = new List <double>();
averageScorePlotData = new List <double>();
bestScorePlotData = new List <double>();
UpdatePlotData();
Plot();
buttonNextGeneration.Enabled = true;
buttonRun.Enabled = true;
buttonReset.Enabled = true;
}
private void InitializeGeneticAlgorithm()
{
fitnessFunction = new FitnessFunction(cities);
selectionOperator = new TournamentSelection(Convert.ToInt32(inputTournamentSize.Value));
elitistSelection = new ElitistSelection();
crossoverOperator = GetSelectedCrossoverOperator();
mutationOperator = GetSelectedMutationOperator();
initialPopulationProvider = new InitialPopulationProvider();
settings = new Settings
{
Cities = cities,
NumberOfElites = Convert.ToInt32(inputElites.Value),
PopulationSize = Convert.ToInt32(inputMaxPopulation.Value),
CrossoverRate = Convert.ToDouble(inputCrossoverRate.Value),
MutationRate = Convert.ToDouble(inputMutationRate.Value)
};
selectionOperator = new TournamentSelection(Convert.ToInt32(inputTournamentSize.Value));
geneticAlgorithm = new GeneticAlgorithm(settings, initialPopulationProvider, fitnessFunction, selectionOperator, elitistSelection, crossoverOperator, mutationOperator);
generationsPlotData = new List <double>();
averageScorePlotData = new List <double>();
bestScorePlotData = new List <double>();
UpdatePlotData();
Plot();
DrawSolution(geneticAlgorithm.CurrentBestSolution, panelBestSolution, bestSolutionGraphics);
buttonNextGeneration.Enabled = true;
buttonRun.Enabled = true;
buttonReset.Enabled = true;
}
static SelectionOperator()
{
//selectionOperator = new SelectionOperatorTheBestK();
//selectionOperator = new SelectionOperatorTournamentWithRandomAlphaForOneFit();
//selectionOperator = new SelectionOperatorWheelOneFit();
selectionOperator = new SelectionOperatorBestPlusRouletteWheel();
//selectionOperator = new SelectionOperatorTournament();
//selectionOperator = new SelectionOperatorMySelection();
Coefficient = 5;
}
/// <summary>
/// Creates a new GA solver.
/// </summary>
public GASolver(TObjective objective, ISolver <TWeight, TProblem, TObjective, TSolution, TFitness> generator,
ICrossOverOperator <TWeight, TProblem, TObjective, TSolution, TFitness> crossOver, ISelectionOperator <TProblem, TSolution, TObjective, TFitness> selection,
IOperator <TWeight, TProblem, TObjective, TSolution, TFitness> mutation, GASettings settings)
{
_generator = generator;
_crossOver = crossOver;
_mutation = mutation;
_selection = selection;
_settings = settings;
_random = new System.Random();
}
private void Benchmark()
{
fitnessFunction = new FitnessFunction(cities);
selectionOperator = new TournamentSelection(Convert.ToInt32(inputTournamentSize.Value));
elitistSelection = new ElitistSelection();
initialPopulationProvider = new InitialPopulationProvider();
selectionOperator = new TournamentSelection(Convert.ToInt32(inputTournamentSize.Value));
var csv = "Crossover Operator,Mutation Operator,Avg. Best Score,Avg. Computation Time";
var result = RunBenchmark(new CycleCrossover(), new InsertMutation());
csv += $"\nCycle,Insert,{result.Item1},{result.Item2}";
result = RunBenchmark(new CycleCrossover(), new InversionMutation());
csv += $"\nCycle,Inversion,{result.Item1},{result.Item2}";
result = RunBenchmark(new CycleCrossover(), new ScrambleMutation());
csv += $"\nCycle,Scramble,{result.Item1},{result.Item2}";
result = RunBenchmark(new CycleCrossover(), new SwapMutation());
csv += $"\nCycle,Swap,{result.Item1},{result.Item2}";
result = RunBenchmark(new OrderOneCrossover(), new InsertMutation());
csv += $"\nOrder1,Insert,{result.Item1},{result.Item2}";
result = RunBenchmark(new OrderOneCrossover(), new InversionMutation());
csv += $"\nOrder1,Inversion,{result.Item1},{result.Item2}";
result = RunBenchmark(new OrderOneCrossover(), new ScrambleMutation());
csv += $"\nOrder1,Scramble,{result.Item1},{result.Item2}";
result = RunBenchmark(new OrderOneCrossover(), new SwapMutation());
csv += $"\nOrder1,Swap,{result.Item1},{result.Item2}";
result = RunBenchmark(new PMXCrossover(), new InsertMutation());
csv += $"\nPMX,Insert,{result.Item1},{result.Item2}";
result = RunBenchmark(new CycleCrossover(), new InversionMutation());
csv += $"\nPMX,Inversion,{result.Item1},{result.Item2}";
result = RunBenchmark(new CycleCrossover(), new ScrambleMutation());
csv += $"\nPMX,Scramble,{result.Item1},{result.Item2}";
result = RunBenchmark(new CycleCrossover(), new SwapMutation());
csv += $"\nPMX,Swap,{result.Item1},{result.Item2}";
File.WriteAllText("simulations.csv", csv);
}
public Population(
ISelectionOperator selectionOperator,
ICrossoverOperator crossoverOperator,
IMutationOperator mutationOperator,
int maxPopulationSize)
{
this.selectionOperator = selectionOperator ?? throw new ArgumentNullException(nameof(selectionOperator));
this.crossoverOperator = crossoverOperator ?? throw new ArgumentNullException(nameof(crossoverOperator));
this.mutationOperator = mutationOperator ?? throw new ArgumentNullException(nameof(mutationOperator));
this.size = maxPopulationSize;
this.individuals = new List <IIndividual>();
this.isSorted = false;
}
public GenerationalGeneticAlgorithm(
IProblem <T> problem,
int populationSize,
ISelectionOperator <T> selectionOperator,
ICrossoverOperator <T> crossoverOperator,
IMutationOperator <T> mutationOperator,
ITerminationCondition terminationCondition,
double elitismRate)
: base(problem, populationSize, selectionOperator,
crossoverOperator, mutationOperator, terminationCondition)
{
_elitismRate = elitismRate;
}
protected EvolutionaryAlgorithmBase(ISelectionOperator <TChromosome, TGene> parentSelection,
ICrossoverOperator <TChromosome, TGene> crossover, IEnumerable <IMutationOperator <TChromosome, TGene> > mutations,
ISelectionOperator <TChromosome, TGene> chromosomeSelection,
IFitnessFunction <TChromosome, TGene> fitnessFunction,
IEnumerable <ITerminationPredicate> terminationPredicates)
{
this._parentSelection = parentSelection;
this._crossover = crossover;
this._mutations = mutations;
this._chromosomeSelection = chromosomeSelection;
this._fitnessFunction = fitnessFunction;
this._terminationPredicates = terminationPredicates;
this.State = EvolutionaryAlgorithmState.NotStarted;
this.GenerationCount = 0;
}
public GeneticAlgorithm(int numberOfIndividuals, int chromosomeSize,
ICrossOperator crossOperator,
IMutationOperator mutationOperator,
ISelectionOperator selectionOperator,
Func <double, double> fitnessFunction)
{
_numberOfIndividuals = numberOfIndividuals;
_chromosomeSize = chromosomeSize;
_crossOperator = crossOperator;
_mutationOperator = mutationOperator;
_selectionOperator = selectionOperator;
_fitnessFunction = fitnessFunction;
CrossoverProbability = 0.90;
MutationProbability = 0.05;
}
public SteadyStateGeneticAlgorithm(
IProblem <T> problem,
int populationSize,
ISelectionOperator <T> selectionOperator,
ICrossoverOperator <T> crossoverOperator,
IMutationOperator <T> mutationOperator,
ITerminationCondition terminationCondition,
double generationGap,
IReplacementOperator <T> replacementOperator) :
base(problem, populationSize, selectionOperator,
crossoverOperator, mutationOperator, terminationCondition)
{
_generationGap = generationGap;
_replacementOperator = replacementOperator;
}
public GeneticAlgorithmBuilder(
IProblem <T> problem,
ICrossoverOperator <T> crossoverOperator,
IMutationOperator <T> mutationOperator)
{
_problem = problem;
_crossoverOperator = crossoverOperator;
_mutationOperator = mutationOperator;
_selectionOperator = new TournamentSelectionOperator <T>(3, problem);
_replacementOperator = new WorstFitnessReplacementOperator <T>(problem);
_populationSize = 1000;
_maxGenerations = 1000;
_maxEvaluations = 100000;
_fitnessValue = 10e-6;
_elitismRate = 1.0 / _populationSize;
_generationGap = 0.4;
_variant = GeneticAlgorithmVariant.SteadyState;
}
public GeneticAlgorithm(Settings settings,
IInitialPopulationProvider initialPopulationProvider,
IFitnessFunction fitnessFunction,
ISelectionOperator selectionOperator,
IElitistSelection elitistSelection,
ICrossoverOperator crossoverOperator,
IMutationOperator mutationOperator)
{
this.settings = settings;
this.fitnessFunction = fitnessFunction;
this.selectionOperator = selectionOperator;
this.elitistSelection = elitistSelection;
this.crossoverOperator = crossoverOperator;
this.mutationOperator = mutationOperator;
currentPopulation = initialPopulationProvider.GetInitialPopulation(settings.PopulationSize, settings.NumberOfCriterias);
ComputeCurrentGenerationData();
}
protected AbstractGeneticAlgorithm(
IProblem <T> problem,
int populationSize,
ISelectionOperator <T> selectionOperator,
ICrossoverOperator <T> crossoverOperator,
IMutationOperator <T> mutationOperator,
ITerminationCondition terminationCondition)
{
_problem = problem;
_populationSize = populationSize;
_selectionOperator = selectionOperator;
_crossoverOperator = crossoverOperator;
_mutationOperator = mutationOperator;
_terminationCondition = terminationCondition;
CurrentGeneration = 1;
EvolutionTime = TimeSpan.Zero;
_population = CreateInitialPopulation();
_population = EvaluatePopulation(_population);
}
public Population(PopulationSettings settings, ICrossoverOperator crossoverOperator, ISelectionOperator selectionOperator, IMutationOperator mutationOperator, Func <Individual> createIndividualDelegate)
{
_ = settings ?? throw new ArgumentNullException(nameof(settings));
_mutationRate = settings.MutationRate;
_matingPoolSize = settings.MatingPoolSize;
_populationSize = settings.PopulationSize;
_offspringSize = settings.OffspringSize;
_generationsCount = settings.GenerationsCount;
_crossoverOperator = crossoverOperator;
_selectionOperator = selectionOperator;
_mutationOperator = mutationOperator;
MatingPool = new List <Individual>();
Individuals = new List <Individual>();
for (int i = 0; i < _populationSize; i++)
{
var individual = createIndividualDelegate.Invoke();
Individuals.Add(individual);
}
}
public static IEnumerable <TChromosome> Select <TChromosome, TGene>(this IEnumerable <TChromosome> chromosomes,
ISelectionOperator <TChromosome, TGene> selectionOperator, int number)
where TChromosome : IChromosome <TChromosome, TGene> where TGene : IGene <TGene>
{
return(selectionOperator.Apply(number, chromosomes));
}
/// <summary>
/// Creates a new GA solver.
/// </summary>
public GASolver(TObjective objective, ISolver <TWeight, TProblem, TObjective, TSolution, TFitness> generator,
ICrossOverOperator <TWeight, TProblem, TObjective, TSolution, TFitness> crossOver, ISelectionOperator <TProblem, TSolution, TObjective, TFitness> selection,
IOperator <TWeight, TProblem, TObjective, TSolution, TFitness> mutation)
: this(objective, generator, crossOver, selection, mutation, GASettings.Default)
{
}
public GeneticAlgorithmBuilder <T> SetSelectionOperator(ISelectionOperator <T> selectionOperator)
{
_selectionOperator = selectionOperator;
return(this);
}
