protected void noClonesAroundTest(IPopulation population)
{
foreach (IEvolvable evolvable in population.Individuals)
{
Assert.IsNotNull(evolvable);
}
for (int i = 0; i < population.Individuals.Count - 1; i++)
{
for (int j = i + 1; j < population.Individuals.Count; j++)
{
if (population.Individuals[i].Equals(population.Individuals[j]))
{
throw new Exception("Clones!! " + i + " and " + j);
}
}
}
foreach (var individual in population.Individuals)
{
if (individual is IPopulation)
{
noClonesAroundTest(individual as IPopulation);
}
}
}
public IList <IChromosome> Cross(IPopulation population, ICrossover crossover, float crossoverProbability, IList <IChromosome> parents)
{
var minSize = population.MinSize;
var offspring = new List <IChromosome>(minSize);
for (int i = 0; i < minSize; i += crossover.ParentsNumber)
{
var selectedParents = parents.Skip(i).Take(crossover.ParentsNumber).ToList();
// If match the probability cross is made, otherwise the offspring is an exact copy of the parents.
// Checks if the number of selected parents is equal which the crossover expect, because the in the end of the list we can
// have some rest chromosomes.
if (selectedParents.Count == crossover.ParentsNumber && RandomizationProvider.Current.GetDouble() <= crossoverProbability)
{
offspring.AddRange(crossover.Cross(selectedParents));
}
else
{
var left = crossover.ParentsNumber - selectedParents.Count;
for (int j = 0; j < left; j++)
{
offspring.Add(parents[RandomizationProvider.Current.GetInt(0, parents.Count)].Clone());
}
}
}
return(offspring);
}
public void InitGA()
{
System.Random rand;
rand = (seedRandom) ? new System.Random(1) : new System.Random();
var randGenomGenerator = new RandNeuralGenomeGeneratorBase(
rand,
new Sigmoid(),
weightRange,
inputCount,
outputCount,
hiddenLayers,
createBias);
var reinsertion = new ReinsertBest <Synapse>(
(int)(poplLne * reinsertPart));
var breeding = NewBreeding(rand);
var generationGenerator = new GenerationGeneratorBase <Synapse>(
poplLne,
reinsertion,
breeding);
population = new PopulationBase <Synapse>(
poplLne,
randGenomGenerator,
generationGenerator);
}
public IPopulation EvolvePopulation(IPopulation oldPopulation)
{
var newPopulation = _populationFactory.CreatePopulation(oldPopulation.Size);
var individualIndexOffset = 0;
if (_elitism)
{
newPopulation.SetIndividual(0, oldPopulation.MostSuitableIndividualToProblem);
individualIndexOffset = 1;
}
// Populate 'newPopulation' with children from the parents in 'oldPopulation' to exploit the current knowledge.
for (var individualIndex = individualIndexOffset; individualIndex < newPopulation.Size; individualIndex++)
{
var resultingIndividualFromCrossoverOperation =
_crossoverOperator.PerformCrossover(oldPopulation);
_problemService.MakeSolutionValid(resultingIndividualFromCrossoverOperation);
newPopulation.SetIndividual(individualIndex, resultingIndividualFromCrossoverOperation);
}
// Mutate each individual in the new population to explore the problem domain.
for (var individualIndex = individualIndexOffset; individualIndex < oldPopulation.Size; individualIndex++)
{
// TODO: Refactor the 'currentIndividual.Chromosome' - shouldn't be able to view Chromosome.
var currentIndividual = newPopulation.GetIndividual(individualIndex);
_mutationOperator.PerformMutation(currentIndividual);
}
return(newPopulation);
}
/// <summary>
/// Construct an innovation list.
/// </summary>
///
/// <param name="population_0">The population.</param>
/// <param name="links">The links.</param>
/// <param name="neurons">THe neurons.</param>
public NEATInnovationList(IPopulation population_0,
Chromosome links, Chromosome neurons)
{
nextNeuronID = 0;
population = population_0;
foreach (IGene gene in neurons.Genes)
{
var neuronGene = (NEATNeuronGene)gene;
var innovation = new NEATInnovation(neuronGene,
population_0.AssignInnovationID(), AssignNeuronID());
Add(innovation);
}
foreach (IGene gene_1 in links.Genes)
{
var linkGene = (NEATLinkGene)gene_1;
var innovation_2 = new NEATInnovation(
linkGene.FromNeuronID, linkGene.ToNeuronID,
NEATInnovationType.NewLink,
population.AssignInnovationID());
Add(innovation_2);
}
}
public Generation(IPopulation population)
{
Population = population;
// Perform initial speciation
Population.Speciate();
}
/// <summary>
/// Evolved one generation.
/// </summary>
/// <param name="population">Curr. pop</param>
/// <returns>New generation</returns>
protected override IPopulation EvolvedOneGeneration(IPopulation population)
{
List <IIndividual> newGeneration = new List <IIndividual>();
foreach (var orginal in population.Individuals)
{
// generate unique random numbers
var randomValues = FastRandom.GetUniqueInts(3, 0, population.Size);
int a = randomValues[0];
int b = randomValues[1];
int c = randomValues[2];
// choose random individuals (agents) from population
IIndividual individual1 = population.Individuals[a];
IIndividual individual2 = population.Individuals[b];
IIndividual individual3 = population.Individuals[c];
int i = 0;
int R = FastRandom.GetInt(0, population.Size);
var candidate = population.CreateEmptyIndividual();
foreach (var orginalElement in orginal.GetGenes())
{
double probXover = FastRandom.GetDouble();
if (probXover < XoverProbability || i == R)
{
// simple mutation
double newElement = individual1.GetGene(i) + F * (individual2.GetGene(i) - individual3.GetGene(i));
candidate.ReplaceGene(i, newElement);
}
else
{
candidate.ReplaceGene(i, orginalElement);
}
i++;
}
var fit = fitness.Evaluate(candidate);
if (fit < orginal.Fitness)
{
newGeneration.Add(candidate);
}
else
{
newGeneration.Add(orginal);
}
}
CurrentGenerationsNumber++;
population.Individuals = newGeneration;
return(population);
}
public IList <IChromosome> Cross(IPopulation population, ICrossover crossover, float crossoverProbability, IList <IChromosome> parents)
{
var offspring = new List <IChromosome>();
var clonedParents = parents.Select(x => x.Clone()).ToList();
for (int i = 0; i < population.MaxSize; i += crossover.ParentsNumber)
{
var selectedParents = clonedParents.Skip(i).Take(crossover.ParentsNumber).ToList();
// If match the probability cross is made, otherwise the offspring is an exact copy of the parents.
// Checks if the number of selected parents is equal which the crossover expect, because in the end of the list we can
// have some rest chromosomes.
if (selectedParents.Count == crossover.ParentsNumber)
{
bool shouldCrossover = RandomizationProvider.Current.GetDouble() <= crossoverProbability;
offspring.AddRange(shouldCrossover ?
crossover.Cross(selectedParents) : selectedParents);
}
else
{
offspring.AddRange(selectedParents);
int leftToAdd = crossover.ParentsNumber - selectedParents.Count;
for (int j = 0; j < leftToAdd; j++)
{
offspring.Add(clonedParents[RandomizationProvider.Current.GetInt(0, clonedParents.Count)].Clone());
}
}
}
return(offspring);
}
public override bool TravelerReceptionDecision(IPopulation population)
{
var receptionRate = Parameters.GetValue(ParameterNames.MigrationReceptionRate);
var receptionDecision = Random.GetDouble(0, 1) < receptionRate;
return(receptionDecision);
}
protected virtual void basicTest(IPopulation population)
{
Assert.AreEqual(population.Fitness, population.Best.Fitness);
AssertEx.IsGreaterThanOrEqualTo(population.Individuals.Count, 1);
AssertEx.IsGreaterThanOrEqualTo(population.FoodConsumedInLifetime, 1);
AssertEx.IsGreaterThanOrEqualTo(population.FitnessEvaluations, 1);
AssertEx.IsGreaterThanOrEqualTo(population.Generations, 1);
AssertEx.IsGreaterThanOrEqualTo(population.Mutations, 1);
AssertEx.IsGreaterThanOrEqualTo(population.Crossovers, 1);
Assert.IsNotInstanceOfType(population.BestOfAllTime, typeof(IPopulation));
Assert.IsNotInstanceOfType(population.BestOfAllTime, typeof(IEvolver));
if (population is EvolvablePopulation)
{
AssertEx.IsGreaterThanOrEqualTo((population as EvolvablePopulation).FullPopulation, population.Individuals.Count);
}
foreach (IEvolvable evolvable in population.Individuals)
{
Assert.IsNotNull(evolvable);
}
foreach (var individual in population.Individuals)
{
if (individual is IPopulation)
{
basicTest(individual as IPopulation);
}
}
}
/// <inheritdoc />
public void Generate(EncogRandom rnd, IPopulation pop)
{
// prepare population
_contents.Clear();
pop.Species.Clear();
ISpecies defaultSpecies = pop.CreateSpecies();
if (Score.RequireSingleThreaded || ThreadCount == 1)
{
for (int i = 0; i < pop.PopulationSize; i++)
{
EncogProgram prg = AttemptCreateGenome(rnd, pop);
AddPopulationMember(pop, prg);
}
}
else
{
Parallel.For(0, pop.PopulationSize, i =>
{
EncogProgram prg = AttemptCreateGenome(rnd, pop);
AddPopulationMember(pop, prg);
});
}
// just pick a leader, for the default species.
defaultSpecies.Leader = defaultSpecies.Members[0];
}
/// <summary>Initializes a new instance of the <see cref="GeneticAlgorithm"/> class.</summary>
/// <param name="population">The chromosomes population.</param>
/// <param name="selection">The selection operator.</param>
/// <param name="crossover">The crossover operator.</param>
/// <param name="mutation">The mutation operator.</param>
/// <param name="reinsertion">The reinsertion operator.</param>
/// <param name="termination">The termination operator.</param>
public DynamoGeneticAlgorithm(
IPopulation population,
ISelection selection,
ICrossover crossover,
IMutation mutation,
IReinsertion reinsertion,
ITermination termination)
{
ExceptionHelper.ThrowIfNull("population", population);
ExceptionHelper.ThrowIfNull("selection", selection);
ExceptionHelper.ThrowIfNull("crossover", crossover);
ExceptionHelper.ThrowIfNull("mutation", mutation);
ExceptionHelper.ThrowIfNull("reinsertion", reinsertion);
ExceptionHelper.ThrowIfNull("termination", termination);
Population = population;
Selection = selection;
Crossover = crossover;
Mutation = mutation;
Reinsertion = reinsertion;
Termination = termination;
SelectionSize = 0;
CrossoverProbability = (float)DefaultCrossoverProbability;
MutationProbability = (float)DefaultMutationProbability;
TimeEvolving = TimeSpan.Zero;
OperatorsStrategy = new DefaultOperatorsStrategy();
State = GeneticAlgorithmState.NotStarted;
}
public StringGenerator(IPopulation <char> population, IWriter writer)
: base(population, writer)
{
FittestIndividual = new Individual(population.Chromosome);
SecondFittestIndividual = new Individual(population.Chromosome);
FittestIndividualForAllTime = new Individual(population.Chromosome);
}
/// <summary>
/// Initializes a new instance of the <see cref="GeneticSharp.Domain.GeneticAlgorithm"/> class.
/// </summary>
/// <param name="population">The chromosomes population.</param>
/// <param name="fitness">The fitness evaluation function.</param>
/// <param name="selection">The selection operator.</param>
/// <param name="crossover">The crossover operator.</param>
/// <param name="mutation">The mutation operator.</param>
public GeneticAlgorithm(
IPopulation population,
IFitness fitness,
ISelection selection,
ICrossover crossover,
IMutation mutation)
{
ExceptionHelper.ThrowIfNull("population", population);
ExceptionHelper.ThrowIfNull("fitness", fitness);
ExceptionHelper.ThrowIfNull("selection", selection);
ExceptionHelper.ThrowIfNull("crossover", crossover);
ExceptionHelper.ThrowIfNull("mutation", mutation);
Population = population;
Fitness = fitness;
Selection = selection;
Crossover = crossover;
Mutation = mutation;
Reinsertion = new ElitistReinsertion();
Termination = new GenerationNumberTermination(1);
CrossoverProbability = DefaultCrossoverProbability;
MutationProbability = DefaultMutationProbability;
TimeEvolving = TimeSpan.Zero;
State = GeneticAlgorithmState.NotStarted;
TaskExecutor = new LinearTaskExecutor();
}
public IntegersImplementationCommand(IReader reader, IWriter writer)
{
this.reader = reader;
this.writer = writer;
population = new Population(this.reader, this.writer);
generator = new IntegersGenerator(population, writer);
}
/// <summary>
/// Constructor for genetic algorithm.
/// Genetic algorithms imitate natural biological processes,
/// </summary>
/// <param name="population">Init population. </param>
/// <param name="fitness">Fitness.</param>
/// <param name="selection">Selection operator.</param>
/// <param name="xover">Xover operator.</param>
/// <param name="mutation">Mutation operator.</param>
/// <param name="elitizmus">Elitizmus.</param>
/// <param name="termination">Termination GA.</param>
/// <param name="executor">Executor.</param>
/// <param name="mutationProbability">Mutation probability.</param>
/// <param name="xoverProbability">Xover probability.</param>
public GeneticAlgorithm(IPopulation population,
IFitness fitness,
ISelection selection,
IXover xover,
IMutation mutation,
IElite elitizmus,
ITermination termination,
IExecutor executor,
float mutationProbability,
float xoverProbability)
{
Population = population;
this.fitness = fitness;
this.selection = selection;
this.xover = xover;
this.mutation = mutation;
this.elitizmus = elitizmus;
this.executor = executor;
this.termination = termination;
// base probability
this.xoverProbability = xoverProbability;
this.mutationProbability = mutationProbability;
TimeEvolving = TimeSpan.Zero;
CurrentGenerationsNumber = 1;
}
/// <summary>
/// Construct an innovation list.
/// </summary>
///
/// <param name="population_0">The population.</param>
/// <param name="links">The links.</param>
/// <param name="neurons">THe neurons.</param>
public NEATInnovationList(IPopulation population_0,
Chromosome links, Chromosome neurons)
{
nextNeuronID = 0;
population = population_0;
foreach (IGene gene in neurons.Genes)
{
var neuronGene = (NEATNeuronGene) gene;
var innovation = new NEATInnovation(neuronGene,
population_0.AssignInnovationID(), AssignNeuronID());
Add(innovation);
}
foreach (IGene gene_1 in links.Genes)
{
var linkGene = (NEATLinkGene) gene_1;
var innovation_2 = new NEATInnovation(
linkGene.FromNeuronID, linkGene.ToNeuronID,
NEATInnovationType.NewLink,
population.AssignInnovationID());
Add(innovation_2);
}
}
private IPopulation GetNextPopulation(IPopulation currentPopulation)
{
var breedingSeason = breedingSeasonFactory.Build(currentPopulation);
breedingSeason.ResolveConfrontations();
return(breedingSeason.GetNewPopulation());
}
/// <summary>
/// Linear xover executor.
/// </summary>
/// <param name="population">Input population.</param>
/// <param name="xover">Xover operator.</param>
/// <param name="xoverProbability">Xover probability</param>
/// <param name="parents">Parents list</param>
/// <returns>Childten(individuals)</returns>
public virtual IList <IIndividual> Cross(IPopulation population, IXover xover, float xoverProbability, IList <IIndividual> parents)
{
var size = population.Size;
var offspring = new List <IIndividual>(size);
for (int i = 0; i < size; i += xover.ChildrenNumber)
{
// selected parents from population
var selectedParents = parents.Skip(i).Take(xover.ParentsNumber).ToList();
// If match the probability cross is made, otherwise the offspring is an exact copy of the parents.
// Checks if the number of selected parents is equal which the crossover expect, because the in the end of the list we can
// have some rest individual
if (selectedParents.Count == xover.ParentsNumber && FastRandom.GetDouble() <= xoverProbability)
{
offspring.AddRange(xover.Cross(selectedParents));
}
else
{
offspring.AddRange(selectedParents);
}
}
return(offspring);
}
public IntegersGenerator(IPopulation <int> population, IWriter writer)
: base(population, writer)
{
FittestIndividual = new Individual(population.GeneLength);
SecondFittestIndividual = new Individual(population.GeneLength);
FittestIndividualForAllTime = new Individual(population.GeneLength);
}
public T Select <T>(IPopulation <T> population) where T : IBreedingCandidate
{
if (population.Size <= 0)
{
throw new ArgumentException("The population cannot be empty");
}
var selected = default(T);
var spin = _randomNumberGenerator.NextDouble() * population.TotalFitness;
var currentFitness = 0.0;
foreach (var candidate in population.GetCandidates())
{
currentFitness += candidate.Fitness;
if (spin <= currentFitness)
{
selected = candidate;
break;
}
}
return(selected);
}
private AgentOrderbookLoader MakeAgentOrderbookLoader(string PATH)
{
int dim = 0;
string [] names = new string [0];
double [] mins = new double [0];
double [] maxs = new double [0];
IBlauSpace s = BlauSpace.create(dim, names, mins, maxs);
IBlauPoint mean = new BlauPoint(s);
IBlauPoint std = new BlauPoint(s);
IDistribution d = new Distribution_Gaussian(s, mean, std);
IAgentFactory afact = new AgentOrderbookLoader_Factory(PATH, d);
IPopulation pop = PopulationFactory.Instance().create(afact, 1);
AgentOrderbookLoader loader = null;
foreach (IAgent ag in pop)
{
loader = (AgentOrderbookLoader)ag;
break;
}
return(loader);
}
public virtual void AddEntitiesToPopulation(IPopulation population, IEntityList entities)
{
for (int i = 0; i < entities.Count; i++)
{
population.Add(entities[i]);
}
}
/// <summary>
/// Construct an innovation list.
/// </summary>
/// <param name="population">The population.</param>
/// <param name="links">The links.</param>
/// <param name="neurons">The neurons.</param>
public NEATInnovationList(IPopulation population, Chromosome links, Chromosome neurons)
{
this.population = population;
foreach (IGene gene in neurons.Genes)
{
NEATNeuronGene neuronGene = (NEATNeuronGene)gene;
NEATInnovation innovation = new NEATInnovation(neuronGene,
population.AssignInnovationID(), AssignNeuronID());
Innovations.Add(innovation);
}
foreach (IGene gene in links.Genes)
{
NEATLinkGene linkGene = (NEATLinkGene)gene;
NEATInnovation innovation = new NEATInnovation(linkGene
.FromNeuronID, linkGene.ToNeuronID,
NEATInnovationType.NewLink, this.population.AssignInnovationID());
Innovations.Add(innovation);
}
}
private void Window_Loaded_1(object sender, RoutedEventArgs e)
{
pop = InitPopulation();
score = new PlantScore();
this.genetic = new BasicEA(pop, score);
//this.genetic.Speciation = new ArraySpeciation<DoubleArrayGenome>();
genetic.AddOperation(0.9, new Splice(PlantUniverse.GenomeSize / 3));
genetic.AddOperation(0.1, new MutatePerturb(0.1));
// Display
this.universe = new PlantUniverse();
this.universe.Reset();
DoubleArrayGenome bestGenome = (DoubleArrayGenome)genetic.BestGenome;
PlantPhysics physics = new PlantPhysics();
PlantGrowth growth = new PlantGrowth();
for (int i = 0; i < 100; i++)
{
physics.RunPhysics(universe);
growth.RunGrowth(universe, bestGenome.Data);
}
this.display = new DisplayPlant(CanvasOutput);
this.display.Universe = this.universe;
Thread t = new Thread(DoWork);
t.Start();
}
public virtual void RemoveEntitiesFromPopulation(IPopulation population, IEntityList entities)
{
for (int i = 0; i < entities.Count; i++)
{
population.Remove(entities[i]);
}
}
/// <summary>
/// Evolved one generation.
/// </summary>
/// <param name="population">Current population.</param>
/// <returns>New generation.</returns>
protected override IPopulation EvolvedOneGeneration(IPopulation population)
{
List <Tuple <Vector <double>, double> > solutions = new List <Tuple <Vector <double>, double> >();
for (int i = 0; i < cma.PopSize; i++)
{
var x = cma.Ask();
var currInd = population.CreateEmptyIndividual();
currInd.ReplaceGenes(x.ToArray());
var value = fitness.Evaluate(currInd);
solutions.Add(new Tuple <Vector <double>, double>(x, value));
}
cma.Tell(solutions);
double yCurrentBest = solutions.Min(x => x.Item2);
var xCurrentBest = solutions.Where(x => x.Item2 == yCurrentBest).FirstOrDefault().Item1;
IIndividual bestInd = population.CreateEmptyIndividual();
bestInd.ReplaceGenes(xCurrentBest.ToArray());
fitness.Evaluate(bestInd);
BestIndividual = bestInd;
// Console.WriteLine(j + " - " + yCurrentBest);
CurrentGenerationsNumber++;
population.Individuals = new List <IIndividual>();
population.Individuals.Add(bestInd);
return(population);
}
static public AgentOrderbookLoader MakeAgentOrderbookLoader(string path)
{
string [] names = new string [1] {
"x"
};
double [] mins = new double [1] {
0.00
};
double [] maxs = new double [1] {
100.0
};
IBlauSpace s = BlauSpace.create(1, names, mins, maxs);
IDistribution d = new Distribution_Gaussian(s, 0.0, 0.0);
IAgentFactory afact = new AgentOrderbookLoader_Factory(path, d);
IPopulation pop = PopulationFactory.Instance().create(afact, 1);
AgentOrderbookLoader loader = null;
foreach (IAgent ag in pop)
{
loader = (AgentOrderbookLoader)ag;
break;
}
return(loader);
}
/// <summary>
/// Selects two individuals from the population and performs the crossover operation on them.
/// </summary>
/// <param name="population">The population to select from</param>
/// <returns></returns>
public IIndividual PerformCrossover(IPopulation population)
{
var individual1 = _selectionStrategy.SelectIndividualFromPopulation(population);
var individual2 = _selectionStrategy.SelectIndividualFromPopulation(population);
return(PerformCrossover(individual1, individual2));
}
public override IEntityList Replace(IPopulation targetPopulation, IEntityList offspring, IEntityList parents, IPopulation sourcePopulation)
{
var inserted = new EntityList(1);
var populationSize = Parameters.GetValue(Algorithm.ParameterNames.PopulationSize);
//TODO: FitnessComparer.SelectWorst, SelectBest
if (offspring.Count == 0)
{
return(inserted);
}
var entityToRemove = FitnessComparer.Dominates(parents[0].Fitness, parents[1].Fitness) ? parents[0] : parents[1];
var entityToAdd = (offspring.Count > 1 && FitnessComparer.Dominates(offspring[0].Fitness, offspring[1].Fitness)) ? offspring[1] : offspring[0];
if (FitnessComparer.Dominates(entityToRemove.Fitness, entityToAdd.Fitness))
{
targetPopulation.Add(entityToAdd);
inserted.Add(entityToAdd);
if (sourcePopulation.Count > populationSize)
{
sourcePopulation.Remove(entityToRemove);
}
}
return(inserted);
}
public StringImplementationCommand(IReader reader, IWriter writer)
{
this.reader = reader;
this.writer = writer;
population = new Population(this.reader, this.writer);
generator = new StringGenerator(population, writer);
}
public OptimizationResult Optimize()
{
_selection = new EliteSelection();
_crossover = new UniformCrossover();
_mutation = new TworsMutation();
_chromosome = new BlockedTestcasesChromosome(_dataset.Blockers.Count);
_fitness = new WeightedMaximizeSolvedTestcasesFitness(_resolver);
_population = new Population(20, 40, _chromosome);
_ga = new GeneticAlgorithm(_population, _fitness, _selection, _crossover, _mutation);
_ga.Termination = new OrTermination(new FitnessStagnationTermination(100),
new GenerationNumberTermination(10000),
new TimeEvolvingTermination(TimeSpan.FromMinutes(5)));
//_ga.GenerationRan += Ga_GenerationRan;
//_fitness.Evaluated += Fitness_Evaluated;
_ga.Start();
var resolvedBlockers = GetBlockersToResolve(_ga.BestChromosome);
var resolution = _resolver.Resolve(resolvedBlockers);
var resolvedTestcases = resolution.ResolvedTestcases;
var resolvedTestcasesIncludingUnblocked = resolution.ResolvedDataset.Testcases.Where(x => x.BlockerIds.Count <= 0).ToList();// GetResolvedTestcasesIncludingUnblocked(resolvedBlockers);
var cost = _dataset.GetCostForBlockers(resolvedBlockers);
var value = _dataset.GetValueForTestcases(resolvedTestcases);
var valueIncludingUnblocked = _dataset.GetValueForTestcases(resolvedTestcasesIncludingUnblocked);
var optimizationResult = new OptimizationResult(_ga.BestChromosome.Fitness.Value, value, valueIncludingUnblocked, cost, resolvedBlockers, resolvedTestcases, resolvedTestcasesIncludingUnblocked);
return(optimizationResult);
}
public Citizen(IPopulation population, IInsuranceSocialSystem iss)
{
State = CitizenState.Premature;
Age = new Age();
DeathAge = RollDeathAge();
Laziness = StatisticHelper.RollLaziness();
Population = population;
ISS = iss;
}
/// <summary>
/// Selects the chromosomes which will be reinserted.
/// </summary>
/// <returns>The chromosomes to be reinserted in next generation..</returns>
/// <param name="population">The population.</param>
/// <param name="offspring">The offspring.</param>
/// <param name="parents">The parents.</param>
protected override IList<IChromosome> PerformSelectChromosomes(IPopulation population, IList<IChromosome> offspring, IList<IChromosome> parents)
{
if (offspring.Count > population.MaxSize)
{
return offspring.OrderByDescending(o => o.Fitness).Take(population.MaxSize).ToList();
}
return offspring;
}
/// <summary>
/// Register that a new generation has been created.
/// </summary>
/// <param name="population">The population where the new generation has been created.</param>
public void RegisterNewGeneration(IPopulation population)
{
ExceptionHelper.ThrowIfNull("population", population);
if (population.Generations.Count > GenerationsNumber)
{
population.Generations.RemoveAt(0);
}
}
/// <summary>
/// Construct a species.
/// </summary>
/// <param name="thePopulation">The population the species belongs to.</param>
/// <param name="theFirst">The first genome in the species.</param>
public BasicSpecies(IPopulation thePopulation, IGenome theFirst)
{
Population = thePopulation;
BestScore = theFirst.Score;
GensNoImprovement = 0;
Age = 0;
Leader = theFirst;
_members.Add(theFirst);
}
public override IOrganism Execute(IPopulation population)
{
var target = Randomizer.NextDouble();
foreach (var organism in population)
if (organism.Metrics.Value.ProportionSumInPopulation > target)
return organism;
return population.Last();
}
/// <summary>
/// Select one genome of population
/// </summary>
/// <param name="population">Population with genomes</param>
/// <returns>The genome chosen</returns>
public IGenome Select(IPopulation population)
{
int genome1 = Helper.Random.Next(0, population.Length);
int genome2 = Helper.Random.Next(0, population.Length);
if (population[genome1].CompareTo(population[genome2]) < 0)
return population[genome2];
else
return population[genome1];
}
public World(IPopulation pop, IPersonFactory pf, IRandomGenerator random, IMortalityCurve mc)
{
_mortalityCurve = mc;
_registeredGenes = new GeneBank(this);
WorldSeeds.BaseGenes(_registeredGenes, this);
_population = pop;
_personFactory = pf;
_random = random;
SeedWorld(1001);
}
public void Add(IPopulation population)
{
Contract.Requires(population != null);
lock (populationSync)
{
populations.Add(population);
AddHandlers(population);
}
}
internal BestBodyArrivedToPopulationEventArgs(IPopulation population, IGroup group, IBody body)
{
Contract.Requires(population != null);
Contract.Requires(group != null);
Contract.Requires(body != null);
Population = population;
Group = group;
Body = body;
}
/// <summary>
/// Construct the parallel score calculation object.
/// </summary>
/// <param name="thePopulation">The population to score.</param>
/// <param name="theCODEC">The CODEC to use.</param>
/// <param name="theAdjusters">The score adjusters to use.</param>
/// <param name="theScoreFunction">The score function.</param>
/// <param name="theThreadCount">The requested thread count.</param>
public ParallelScore(IPopulation thePopulation, IGeneticCODEC theCODEC,
IList<IAdjustScore> theAdjusters, ICalculateScore theScoreFunction,
int theThreadCount)
{
_codec = theCODEC;
_population = thePopulation;
_scoreFunction = theScoreFunction;
_adjusters = theAdjusters;
ThreadCount = theThreadCount;
}
public World(IPopulation pop, IPersonFactory pf, IMortalityCurve mortalityCurve, IRandomGenerator random)
{
if (pop?.Populus?.Count > 0) pop.Populus.Clear();
_random = random;
_population = pop;
_registeredGenes = new GeneBank(this);
_personFactory = pf;
_mortalityCurve = mortalityCurve;
WorldSeeds.BaseGenes(_registeredGenes, this);
SeedWorld(1000);
_population?.UpdatePopulus();
}
public override IOrganism Execute(IPopulation population)
{
/*Selection pressure is easily adjusted by changing the tournament size.
* If the tournament size is larger, weak individuals have a smaller chance to be selected.*/
// As the generations go up, the tournament should be more pressured
var fighterOne = population.RandomElement();
var fighterTwo = population.RandomElement();
return population.ParentIEnvironment.OrganismValueComparer.Compare(fighterOne, fighterTwo) > 0 ? fighterOne : fighterTwo;
}
public void Remove(IPopulation population)
{
Contract.Requires(population != null);
lock (populationSync)
{
int idx = populations.IndexOf(population);
if (idx != -1)
{
populations.RemoveAt(idx);
RemoveHandlers(population);
}
}
}
/// <summary>
/// Record each genome of population and some other parameters
/// </summary>
/// <param name="population">Population to be record</param>
/// <param name="generation">Number of generation</param>
/// <param name="avarageFitness">Avarage fitness of population</param>
public void setPopulationLog(IPopulation population, int generation, double avarageFitness)
{
xtw.WriteStartElement("Population");
xtw.WriteAttributeString("Generation", generation.ToString());
xtw.WriteAttributeString("AvarageFitness", avarageFitness.ToString());
for (int i = 0; i < population.Length; i++)
{
xtw.WriteStartElement("Genome");
xtw.WriteAttributeString("Value", population[i].ToString());
xtw.WriteAttributeString("Fitness", population[i].Evaluate().ToString());
xtw.WriteEndElement();
}
xtw.WriteEndElement();
}
/// <summary>
/// Selects the chromosomes which will be reinserted.
/// </summary>
/// <returns>The chromosomes to be reinserted in next generation..</returns>
/// <param name="population">The population.</param>
/// <param name="offspring">The offspring.</param>
/// <param name="parents">The parents.</param>
protected override IList<IChromosome> PerformSelectChromosomes(IPopulation population, IList<IChromosome> offspring, IList<IChromosome> parents)
{
if (offspring.Count == 0)
{
throw new ReinsertionException(this, "The minimum size of the offspring is 1.");
}
var rnd = RandomizationProvider.Current;
while (offspring.Count < population.MinSize)
{
offspring.Add(offspring[rnd.GetInt(0, offspring.Count)]);
}
return offspring;
}
/// <summary>
/// Selects the chromosomes which will be reinserted.
/// </summary>
/// <returns>The chromosomes to be reinserted in next generation..</returns>
/// <param name="population">The population.</param>
/// <param name="offspring">The offspring.</param>
/// <param name="parents">The parents.</param>
protected override IList<IChromosome> PerformSelectChromosomes(IPopulation population, IList<IChromosome> offspring, IList<IChromosome> parents)
{
var diff = population.MinSize - offspring.Count;
if (diff > 0)
{
var bestParents = parents.OrderByDescending(p => p.Fitness).Take(diff);
foreach (var p in bestParents)
{
offspring.Add(p);
}
}
return offspring;
}
public void calculatePopulate()
{
DateTime startDate = DateTime.Now;
if (_option.typeAlgoritme == staticConst.DIFFERENCIAL_GENETIC_ALGORITME)
{
populate = new DEGenetic(_option.countPopulate, _option.countValueVariable, _option.turnInteger, _containerFunction, _option.сhanceMutation, _option.valueMutation);
}
else if (_option.typeAlgoritme == staticConst.CLASSIC_ALGORITME)
{
populate = new ClassicGenetic(_option.countPopulate, _option.countValueVariable, _option.turnInteger, _containerFunction, _option.сhanceMutation, _option.valueMutation);
}
else if (_option.typeAlgoritme == staticConst.CLASSIC_ALGORITME2)
{
populate = new ClassicGenetic2(_option.countPopulate, _option.countValueVariable, _option.turnInteger, _containerFunction, _option.сhanceMutation, _option.valueMutation, _option.B);
}
else if (_option.typeAlgoritme == staticConst.DOUBLE_ALGORITM)
{
populate = new DoubleGenetic(_option.countPopulate, _option.countValueVariable, _option.turnInteger, _containerFunction, _option.сhanceMutation, _option.valueMutation);
}
populate.init();
_intermediateResult = populate.bestChromosome();
ProgressBarEventArgs eventsArg = new ProgressBarEventArgs(_option.countGeneration);
for (int i = 1; i <= _option.countGeneration; i++)
{
populate.nextGeneration();
if (showProgress != null)
{
eventsArg.step = i;
showProgress(this, eventsArg);
}
}
DateTime stopDate = DateTime.Now;
TimeSpan interval = stopDate - startDate;
_result = populate.bestChromosome();
_result.time = interval.Milliseconds;
}
/// <summary>
/// Construct an EA.
/// </summary>
/// <param name="thePopulation">The population.</param>
/// <param name="theScoreFunction">The score function.</param>
public BasicEA(IPopulation thePopulation,
ICalculateScore theScoreFunction)
{
RandomNumberFactory = EncogFramework.Instance.RandomFactory.FactorFactory();
EliteRate = 0.3;
MaxTries = 5;
MaxOperationErrors = 500;
CODEC = new GenomeAsPhenomeCODEC();
Population = thePopulation;
ScoreFunction = theScoreFunction;
Selection = new TournamentSelection(this, 4);
Rules = new BasicRuleHolder();
// set the score compare method
if (theScoreFunction.ShouldMinimize)
{
SelectionComparer = new MinimizeAdjustedScoreComp();
BestComparer = new MinimizeScoreComp();
}
else
{
SelectionComparer = new MaximizeAdjustedScoreComp();
BestComparer = new MaximizeScoreComp();
}
// set the iteration
foreach (ISpecies species in thePopulation.Species)
{
foreach (IGenome genome in species.Members)
{
IterationNumber = Math.Max(IterationNumber,
genome.BirthGeneration);
}
}
// Set a best genome, just so it is not null.
// We won't know the true best genome until the first iteration.
if (Population.Species.Count > 0 && Population.Species[0].Members.Count > 0)
{
BestGenome = Population.Species[0].Members[0];
}
}
public static IList<IIndividual<Wrapper<MyValuableClass>>> SelectionFunc(IPopulation<Wrapper<MyValuableClass>> population, IGAconfiguration gaConfigs)
{
IList<IIndividual<Wrapper<MyValuableClass>>> list = new List<IIndividual<Wrapper<MyValuableClass>>>();
int individualsCountToSelect = population.Individuals.Count;
if (gaConfigs.ElitismPercentage != null)
{
int populationSize = population.Individuals.Count;
int eliteIndCount = (int)(populationSize * gaConfigs.ElitismPercentage);
individualsCountToSelect = populationSize - eliteIndCount;
}
while (list.Count < individualsCountToSelect)
{
var ind = GAUtils.ProvideTournamentSelection(2, population);
list.Add(ind);
}
return list;
}
/// <summary>
/// Selects the chromosomes which will be reinserted.
/// </summary>
/// <returns>The chromosomes to be reinserted in next generation..</returns>
/// <param name="population">The population.</param>
/// <param name="offspring">The offspring.</param>
/// <param name="parents">The parents.</param>
public IList<IChromosome> SelectChromosomes(IPopulation population, IList<IChromosome> offspring, IList<IChromosome> parents)
{
ExceptionHelper.ThrowIfNull("population", population);
ExceptionHelper.ThrowIfNull("offspring", offspring);
ExceptionHelper.ThrowIfNull("parents", parents);
if (!CanExpand && offspring.Count < population.MinSize)
{
throw new ReinsertionException(this, "Cannot expand the number of chromosome in population. Try another reinsertion!");
}
if (!CanCollapse && offspring.Count > population.MaxSize)
{
throw new ReinsertionException(this, "Cannot collapse the number of chromosome in population. Try another reinsertion!");
}
return PerformSelectChromosomes(population, offspring, parents);
}
public NEATInnovationList(IPopulation population_0, Chromosome links, Chromosome neurons)
{
this.nextNeuronID = 0L;
this.population = population_0;
foreach (IGene gene in neurons.Genes)
{
NEATNeuronGene neuronGene = (NEATNeuronGene) gene;
NEATInnovation innovation = new NEATInnovation(neuronGene, population_0.AssignInnovationID(), this.AssignNeuronID());
if (15 == 0)
{
break;
}
base.Add(innovation);
}
foreach (IGene gene3 in links.Genes)
{
NEATLinkGene gene4 = (NEATLinkGene) gene3;
NEATInnovation innovation2 = new NEATInnovation((long) gene4.FromNeuronID, (long) gene4.ToNeuronID, NEATInnovationType.NewLink, this.population.AssignInnovationID());
base.Add(innovation2);
}
}
public BasicSpecies(IPopulation thePopulation, IGenome theFirst, long theSpeciesID)
{
this._members = new List<IGenome>();
this._population = thePopulation;
Label_005F:
this._speciesID = theSpeciesID;
if (0xff != 0)
{
this._bestScore = theFirst.Score;
this._gensNoImprovement = 0;
if (0 != 0)
{
goto Label_005F;
}
this._age = 0;
}
if (((uint) theSpeciesID) >= 0)
{
this._leader = theFirst;
}
this._spawnsRequired = 0.0;
this._members.Add(theFirst);
}
public NEATTraining(ICalculateScore calculateScore, IPopulation population)
{
NEATGenome genome;
this.xd9d3bb742c7a307b = 0.1;
this.x67e8029e782709f0 = 0.07;
this.xe6c7b0462e12d2ff = 0.04;
this.xd3f94467320a5684 = 0.05;
this.x8a503d42183ff26d = 0.26;
this.xa4a074c49c97739c = 0.7;
this.xf52a69d338e65c0f = 0.1;
this.x214332e2bd2e8ae1 = 100.0;
this.x7a6edccccc229234 = 0.5;
this.x68e0847485ce0c21 = 0.2;
this.xd7944ba63721a56b = 5;
this.xfca9d4aed1b3cd4b = 15;
this.xe44426390f1f3741 = 5;
this.x340c2bbd00cd3fa4 = 5;
this.xe5ff50155887c0e7 = 0.1;
goto Label_0102;
if (0 == 0)
{
goto Label_010B;
}
Label_0102:
if (population.Size() < 1)
{
throw new TrainingError("Population can not be empty.");
}
Label_010B:
genome = (NEATGenome) population.Genomes[0];
base.CalculateScore = new GeneticScoreAdapter(calculateScore);
base.Comparator = new GenomeComparator(base.CalculateScore);
base.Population = population;
this.x43f451310e815b76 = genome.InputCount;
this.x98cf41c6b0eaf6ab = genome.OutputCount;
this.xd586e0c16bdae7fc();
}
/// <summary>
/// Create a trainer for training data.
/// </summary>
/// <param name="thePopulation">The population.</param>
/// <param name="trainingData">The training data.</param>
public TrainEA(IPopulation thePopulation, IMLDataSet trainingData)
: base(thePopulation, new TrainingSetScore(trainingData))
{
}
public EvolutionManager(IPopulation population)
{
Population = population;
MutationRate = ConfigManager.Current.MutationRate;
}
/// <summary>
/// Construct neat training with an existing population.
/// </summary>
/// <param name="calculateScore">The score object to use.</param>
/// <param name="population">The population to use.</param>
public NEATTraining(ICalculateScore calculateScore,
IPopulation population)
{
if (population.Size() < 1)
{
throw new TrainingError("Population can not be empty.");
}
var genome = (NEATGenome) population.Genomes[0];
CalculateScore = new GeneticScoreAdapter(calculateScore);
Comparator = new GenomeComparator(CalculateScore);
Population = (population);
inputCount = genome.InputCount;
outputCount = genome.OutputCount;
Init();
}
/// <summary>
/// Create a trainer for a score function.
/// </summary>
/// <param name="thePopulation">The population.</param>
/// <param name="theScoreFunction">The score function.</param>
public TrainEA(IPopulation thePopulation, ICalculateScore theScoreFunction)
: base(thePopulation, theScoreFunction)
{
}
/// <summary>
/// Construct a species.
/// </summary>
///
/// <param name="thePopulation">The population the species belongs to.</param>
/// <param name="theFirst">The first genome in the species.</param>
/// <param name="theSpeciesID">The species id.</param>
public BasicSpecies(IPopulation thePopulation, IGenome theFirst,
long theSpeciesID)
{
_members = new List<IGenome>();
_population = thePopulation;
_speciesID = theSpeciesID;
_bestScore = theFirst.Score;
_gensNoImprovement = 0;
_age = 0;
_leader = theFirst;
_spawnsRequired = 0;
_members.Add(theFirst);
}
