public GeneticSettings(int populationSize, int geneCount, int selectionSize, double mutationProbabiltyAgents, double mutationProbabilityGenes, IRandomNumberGenerator randomNumberGenerator, IFitnessCalculator fitnessCalculator, IMutator mutator, ISelector selector, ICrossover crossover, IAgentViewer agentViewer, int topKAgentsCount) { if (populationSize < selectionSize) { throw new Exception("The population size has to be greater than the selection size"); } PopulationSize = populationSize; GeneCount = geneCount; SelectionSize = selectionSize; MutationProbabiltyAgents = mutationProbabiltyAgents; MutationProbabilityGenes = mutationProbabilityGenes; RandomNumberGenerator = randomNumberGenerator; FitnessCalculator = fitnessCalculator; Mutator = mutator; Selector = selector; Crossover = crossover; AgentViewer = agentViewer; TopKAgentsCount = topKAgentsCount; }
/// <summary> /// Creates a new fitness operator. /// </summary> /// <param name="solver"></param> /// <param name="op"></param> public FitnessComparer( Solver <GenomeType, ProblemType, WeightType> solver, IFitnessCalculator <GenomeType, ProblemType, WeightType> op) { _op = op; _solver = solver; }
public GeneticAlgorithm(IGeneticAlgorithmHelper helper, IUnitOfWork unitOfWork, IFitnessCalculator fitnessCalculator) { this.fitnessCalculator = fitnessCalculator; this.helper = helper; this.unitOfWork = unitOfWork; Population = new Collection <Schedule>(); }
/// <summary> /// Calculates the fitness for this individual. /// </summary> /// <param name="op"></param> /// <param name="problem"></param> /// <param name="validate"></param> public void CalculateFitness( ProblemType problem, IFitnessCalculator <GenomeType, ProblemType, WeightType> op, bool validate) { _fitness_calculated = true; _fitness = op.Fitness(problem, this, validate); }
public ScheduleDNA(IRandomSlotsGenerator slotsGenerator, IFitnessCalculator fitnessCalculator, Random random, bool shouldInitGenes = true, int slotsCount = 80) { _slotsGenerator = slotsGenerator; _fitnessCalculator = fitnessCalculator; _random = random; _slotsCount = slotsCount; Genes = shouldInitGenes ? _slotsGenerator.GetRandomFilledSlots() : new List <Slot>(slotsCount); }
public OptimiserMock( DecisionVector decisionVector, Population initialPopulation, IFitnessCalculator fitnessCalculator) : base(initialPopulation, fitnessCalculator) { this.decisionVector = decisionVector; updateDecisionVector(false); }
/// <summary> /// Sorts the population according to /// </summary> /// <param name="solver"></param> /// <param name="op"></param> public void Sort( Solver <GenomeType, ProblemType, WeightType> solver, IFitnessCalculator <GenomeType, ProblemType, WeightType> op) { // create comparer. FitnessComparer comparer = new FitnessComparer(solver, op); // sort using comparer. _individuals.Sort(comparer); }
/// <summary> /// Invokes the calculate fitness method on all agents in the population. /// </summary> public void CalculateFitness(IFitnessCalculator fitnessCalculator) { double totalFitness = 0; for (int i = 0; i < Agents.Count; i++) { Agents[i].CalculateFitness(fitnessCalculator); totalFitness += Agents[i].Fitness; } fitnessCalculated = true; AverageFitness = CalculateAverageFitness(totalFitness); }
/// <summary> /// Creates a new solver. /// </summary> /// <param name="settings"></param> /// <param name="selector"></param> /// <param name="combined_operation"></param> /// <param name="problem"></param> /// <param name="fitness_calculator"></param> public Solver( ProblemType problem, SolverSettings settings, ISelector <GenomeType, ProblemType, WeightType> selector, IOperation <GenomeType, ProblemType, WeightType> combined_operation, IFitnessCalculator <GenomeType, ProblemType, WeightType> fitness_calculator) { _problem = problem; _settings = settings; _selector = selector; _mutation_operation = combined_operation; _crossOverOperation = combined_operation; _generation_operation = combined_operation; _fitness_calculator = fitness_calculator; }
/// <summary> /// Constructs a new Nelder-Mead Simplex local search optimiser. /// </summary> /// <param name="fitnessCalculator">A <see cref="FitnessCalculatorSingleObjective"/>. <see cref="Optimiser"/></param> /// <param name="initialLocation">Starting location for the search.</param> /// <param name="hyperParameters"> /// Instance of <see cref="HyperParameterManager"/> containing values for /// all the coefficients required by <see cref="NelderMeadHyperParameters"/>. /// </param> public NelderMead( IFitnessCalculator fitnessCalculator, DecisionVector initialLocation, HyperParameterManager hyperParameters) : base(new Simplex(initialLocation.Count), fitnessCalculator) { // Set up simplex operations OperationsManager = new NelderMeadSimplexOperationsManager(hyperParameters); //Set up simplex InitialVerticesStillUnevaluated = Simplex.CreateInitialVertices( initialLocation, hyperParameters.GetHyperParameterValue <double>(NelderMeadHyperParameters.Simplex_Creation_Step_Size)); //Initialise historian tempProgress.Add(NelderMeadSimplexOperations.R); }
/// <summary> /// Creates an Evolutionary Algorithm. /// </summary> /// <param name="initialPopulation">The initial population (can be empty).</param> /// <param name="fitnessCalculator">A <see cref="FitnessCalculatorSingleObjective"/>. <see cref="Optimiser"/></param> /// <param name="initialIndividualGenerator">Creates new decision vectors to build the first population. <seealso cref="Base.Conversion.IModel"/></param> /// <param name="parentSelector">The <see cref="IParentSelectionOperator"/> to use.</param> /// <param name="recombinationOperator">The <see cref="IRecombinationOperator"/> to use.</param> /// <param name="mutationOperator">The <see cref="IMutationOperator"/> to use.</param> /// <param name="reinsertionOperator">The <see cref="IReinsertionOperator"/> to use.</param> /// <param name="hyperParameters">The <see cref="HyperParameterManager"/> object with relevant settings.</param> public EvolutionaryAlgorithm( Population initialPopulation, IFitnessCalculator fitnessCalculator, Func <DecisionVector> initialIndividualGenerator, IParentSelectionOperator parentSelector, IRecombinationOperator recombinationOperator, IMutationOperator mutationOperator, IReinsertionOperator reinsertionOperator, HyperParameterManager hyperParameters) : base(initialPopulation, fitnessCalculator) { this.initialIndividualGenerator = initialIndividualGenerator; this.parentSelector = parentSelector; numberOfParents = hyperParameters.GetHyperParameterValue <int>(EvolutionaryAlgorithmHyperParameters.Number_Of_Parents); this.recombinationOperator = recombinationOperator; this.mutationOperator = mutationOperator; this.reinsertionOperator = reinsertionOperator; }
/// <summary> /// Creates a new solver. /// </summary> /// <param name="problem"></param> /// <param name="settings"></param> /// <param name="selector"></param> /// <param name="mutation"></param> /// <param name="cross_over"></param> /// <param name="generation"></param> /// <param name="fitness_calculator"></param> /// <param name="accept_only_better_cross_over"></param> /// <param name="accept_only_better_mutation"></param> public Solver( ProblemType problem, SolverSettings settings, ISelector <GenomeType, ProblemType, WeightType> selector, IMutationOperation <GenomeType, ProblemType, WeightType> mutation, ICrossOverOperation <GenomeType, ProblemType, WeightType> cross_over, IGenerationOperation <GenomeType, ProblemType, WeightType> generation, IFitnessCalculator <GenomeType, ProblemType, WeightType> fitness_calculator, bool accept_only_better_cross_over, bool accept_only_better_mutation) { _problem = problem; _settings = settings; _selector = selector; _generation_operation = generation; _mutation_operation = mutation; _crossOverOperation = cross_over; _fitness_calculator = fitness_calculator; _accept_only_better_on_cross_over = accept_only_better_cross_over; _accept_only_better_on_mutation = accept_only_better_mutation; }
public void Simulate(int maxTabuListCount, int boardSize, IChessboardGenerator generator, IFitnessCalculator calculator) { Fitness BestPossibleFitness = calculator.BestFitness; IntelligentRandom random = new IntelligentRandom(); Chessboard currentCentralPoint = random.Generate(boardSize); Chessboard currentBestSolution = currentCentralPoint; HashSet <Chessboard> tabuList = new HashSet <Chessboard>(); Fitness currentBestSolutionFitness = calculator.WorstFitness; while (tabuList.Count < maxTabuListCount && currentBestSolutionFitness.IsWorseThan(BestPossibleFitness)) { Chessboard bestCandidate = currentCentralPoint? .GetNeighbourhoodOf() .Except(tabuList) .OrderBy(ch => calculator.CalculateFitness(ch).Value) .FirstOrDefault(); Fitness bestCandidateFitness = calculator.CalculateFitness(bestCandidate); currentBestSolutionFitness = calculator.CalculateFitness(currentBestSolution); currentCentralPoint = bestCandidate; if (bestCandidateFitness.IsBetterThan(currentBestSolutionFitness)) { currentBestSolution = bestCandidate; } tabuList.Add(bestCandidate); } FinalChessboard = currentBestSolution; Result = $@" -- Tabu Search Result -- Tabu List Count: {tabuList.Count} Fitness: {calculator.CalculateFitness(FinalChessboard).Value} {FinalChessboard.ToString()} "; }
public void Simulate(int startTemperature, int boardSize, IChessboardGenerator generator, IFitnessCalculator calculator) { Fitness BestPossibleFitness = calculator.BestFitness; int tenPercent = startTemperature / 10; Chessboard currentBestChessboard = generator.Generate(boardSize); Temperature currentTemperature = new Temperature(startTemperature); Fitness currentBestFitness = calculator.WorstFitness; while (currentTemperature.IsNotZero && currentBestFitness.IsWorseThan(BestPossibleFitness)) { Chessboard chessboard = generator.Generate(boardSize); Fitness currentFitness = calculator.CalculateFitness(chessboard); if (currentFitness.IsBetterThan(currentBestFitness)) { currentBestFitness = currentFitness; currentBestChessboard = chessboard; currentTemperature.IncreaseBy(tenPercent); } else { currentTemperature.DecreaseBy(1); } } FinalChessboard = currentBestChessboard; Result = $@" -- Simulated Annealing Result -- Current Temperature: {currentTemperature.Value} Fitness: {calculator.CalculateFitness(FinalChessboard).Value} {FinalChessboard.ToString()} "; }
/// <summary> /// Constructs the optimiser. /// </summary> /// <param name="initialPopulation">An initial population (can be empty).</param> /// <param name="fitnessCalculator">Conversion function to assign Fitness to an Individual. <seealso cref="Individual.SetFitness"/></param> protected Optimiser(Population initialPopulation, IFitnessCalculator fitnessCalculator) { Population = initialPopulation; this.fitnessCalculator = fitnessCalculator; }
public SchedulePopulationGenerator(IRandomSlotsGenerator slotsGenerator, IFitnessCalculator fitnessCalculator, Random random) { _slotsGenerator = slotsGenerator; _fitnessCalculator = fitnessCalculator; _random = random; }
/// <summary> /// Calculates the fitness of the agent using the given fitnessCalculator. /// </summary> /// <param name="fitnessCalculator"></param> public void CalculateFitness(IFitnessCalculator fitnessCalculator) { TotalFitnessCalculations++; FitnessInfo = fitnessCalculator.CalculateFitness(Chromosome.ToArray()); Fitness = FitnessInfo.Fitness; // Assign fitness directly also, so direct access from outside. }
public PolygonAdapter(IFitnessCalculator <PolygonIndividual, IPolygonGene> fitnessCalculator) : base(fitnessCalculator) { }
/// <summary> /// Calculates the fitness for this individual. /// </summary> /// <param name="problem"></param> /// <param name="op"></param> public void CalculateFitness( ProblemType problem, IFitnessCalculator <GenomeType, ProblemType, WeightType> op) { this.CalculateFitness(problem, op, true); }
protected GeneticAlgorithmAdapter(IFitnessCalculator <TIndividual, TGene> fitnessCalculator) { FitnessCalculator = fitnessCalculator; }