public Plant(int X, int Y)
{
Livelong = PropertyEndLivelong;
IndexGenocode = Genomes.AddGenocode();
AddNewBlockPlant(X, Y);
AddListNewBlocksPlant();
}
/// <summary>
/// Запустить генетическую программу
/// </summary>
private void GeneticProgram()
{
foreach (BlockPlant OneBlockPlant in ListBlocksPlant)
{
OneBlockPlant.Activate();
///rand = MainWorld.GlobalRand.Next(ActionsOfPlants.LengthActionsOfPlants);
switch (Genomes.GetGeneCommand(IndexGenocode, 0, OneBlockPlant.GoActiveGene()))
{
case (int)TypeActionsOfPlants.GrowUp:
AddNewBlockPlant(OneBlockPlant.X, OneBlockPlant.Y + 1, OneBlockPlant);
break;
case (int)TypeActionsOfPlants.GrowLeft:
AddNewBlockPlant(OneBlockPlant.X - 1, OneBlockPlant.Y, OneBlockPlant);
break;
case (int)TypeActionsOfPlants.GrowRight:
AddNewBlockPlant(OneBlockPlant.X + 1, OneBlockPlant.Y, OneBlockPlant);
break;
case (int)TypeActionsOfPlants.GrowDown:
AddNewBlockPlant(OneBlockPlant.X, OneBlockPlant.Y - 1, OneBlockPlant);
break;
default:
break;
}
OneBlockPlant.NextActiveGene();
}
if (StackBlocksPlant.Count > 0)
{
AddListNewBlocksPlant();
}
}
public void Reset(Random r)
{
Genome = Genomes[r.Next(Genomes.Count)];
Genomes.Clear();
FitnessPop.Clear();
TotalAdjustedFitness = 0f;
}
public void NextGeneration()
{
FitnessStats.SaveCurrentToHistory();
Generation++;
var newGenomes = new List <Genome>();
if (_genetics.EliteCount > 0)
{
var elites = Genomes.OrderByDescending(x => x.Fitness).Take(_genetics.EliteCount);
newGenomes.AddRange(elites);
}
while (newGenomes.Count < Genomes.Count())
{
var mother = getGenomeByRoulette();
var father = getGenomeByRoulette();
var children = _genetics.Crossover(mother, father);
foreach (var child in children)
{
_genetics.Mutate(child);
newGenomes.Add(child);
}
}
newGenomes.ForEach(x => x.ResetFitness());
Genomes = newGenomes.Take(Genomes.Count()).ToList();
}
/// <summary>
/// Create a population with random genomes.
/// </summary>
private void Populate()
{
for (int i = 0; i < GenomeCount; i++)
{
Genomes.Add(new Genome(InputCount, OutputCount, Config.weightInitRandomValue));
}
}
/// <summary>
/// Get N genomes from this species.
/// The best genome is simply copied.
/// A part of the genomes are soft copied. Soft, means that the mutation
/// is less than normal.
/// The rest, are a result of a crossover between weighted random chosen
/// genomes. The random is weighted, based on the fitness. The parents can't
/// be the same.
/// </summary>
public Genome[] GetNGenomesForNextGeneration(NEATConfig config, int n)
{
var result = new Genome[n];
Genomes = Genomes.OrderByDescending(x => x.Fitness).ToList();
for (int i = 0; i < n; i++)
{
if (i == 0)
{
result[i] = new Genome(Genomes[0]);
}
else if (i <= config.partOfGenomesToCopyForNextGenerations * n || Genomes.Count == 1)
{
result[i] = new Genome(FitnessWeightedRandomChoice(Genomes)).Mutate(config, 0.8f);
}
else
{
var parent1 = FitnessWeightedRandomChoice(Genomes, config.weightedRandomGradient);
var parent2 = FitnessWeightedRandomChoice(Genomes.Where(x => x != parent1), config.weightedRandomGradient);
result[i] = Genome.Crossover(config, parent1, parent2).Mutate(config);
}
}
return(result);
}
public void Speciate()
{
Genomes.ToList().ForEach(genome => Speciate(genome));
// Clean up any Species with no Genomes
Species = Species.Where(s => s.Genomes.Any()).ToList();
}
//Factory en fonction des différent animaux
public Species ChimeraReproduction(Genomes gene)
{
ChimeraAnt child = null;
switch (gene)
{
case Genomes.Tree: {
child = SpawnChildren();
int randX = Random.Range(-10, 10);
int randY = Random.Range(-10, 10);
print("nAISSANCE mode arbre");
child.transform.position = transform.position + new Vector3(randX, 0, randY);
}
break;
case Genomes.Wolf:
{
if (state != State.Leader && isInReproductionTime == false)
{
return(null);
}
child = SpawnChildren();
}
break;
default:
{
child = SpawnChildren();
} break;
}
return(child);
}
public IList <Genome> GetMostFitGenomes()
{
var averageFitness = AverageFitness;
var sortedGenomes = Genomes.OrderByDescending(g => g.Fitness).Take((Genomes.Count + 1) / 2).ToList();
var mostFitGenomeFitnessInSpecie = sortedGenomes[0].Fitness;
return(sortedGenomes);
}
public Plant(int X, int Y, int ParentsIndex)
{
//IndexGenocode = ParentsIndex;
Livelong = PropertyEndLivelong;
IndexGenocode = Genomes.AddGenocode(ParentsIndex);
AddNewBlockPlant(X, Y);
AddListNewBlocksPlant();
}
public void createStartPopulation()
{
genomes.Clear();
for (int i = 0; i < populationSize; i++)
{
Genomes child = new Genomes(chromosoneLength);
genomes.Add(child);
}
}
private void CalculateTotalFitness()
{
Genomes.ForEach(g =>
{
g.RebuildModelFollowingGenes();
g.UpdateFitnessScore();
});
TotalFitnessScore = Genomes.Max(g => g.Fitness);
}
/// <summary>
/// Finishes Generation, by ordering Genomes by Fitness descending and
/// setting the BestGenome Property.
/// </summary>
public void FinishGeneration()
{
Genomes = Genomes
.OrderByDescending(c => c.Fitness.Value)
.ToList();
// TODO: Write AnalyseData
BestGenome = Genomes.First();
}
//constructor
public Population(int size, int inputDims)
{
_inputDims = inputDims;
AddedConnections = new Dictionary <string, int>();
for (int i = 0; i < size; i++)
{
Genomes.Add(new Genome(inputDims));
}
}
/// <summary>
/// Calculates the next best generation
/// </summary>
public void NextGeneration()
{
// increment the generation;
Generation++;
// check who can die
for (int i = 0; i < Genomes.Count; i++)
{
if (((Genome)Genomes[i]).CanDie(kDeathFitness))
{
Genomes.RemoveAt(i);
i--;
}
}
// determine who can reproduce
GenomeReproducers.Clear();
GenomeResults.Clear();
for (int i = 0; i < Genomes.Count; i++)
{
if (((Genome)Genomes[i]).CanReproduce(kReproductionFitness))
{
GenomeReproducers.Add(Genomes[i]);
}
}
// do the crossover of the genes and add them to the population
DoCrossover(GenomeReproducers);
Genomes = (ArrayList)GenomeResults.Clone();
// mutate a few genes in the new population
for (int i = 0; i < Genomes.Count; i++)
{
Mutate((Genome)Genomes[i]);
}
// calculate fitness of all the genes
for (int i = 0; i < Genomes.Count; i++)
{
((Genome)Genomes[i]).CalculateFitness();
}
// Genomes.Sort();
// kill all the genes above the population limit
if (Genomes.Count > kPopulationLimit)
{
Genomes.RemoveRange(kPopulationLimit, Genomes.Count - kPopulationLimit);
}
CurrentPopulation = Genomes.Count;
}
/// <summary>
/// Generates the next generation of the population.
/// </summary>
public void NextGeneration()
{
var avgDamage = Genomes.Average(g => g.DamageDealt);
var avgSurvivalTime = Genomes.Average(g => g.SurvivalTime);
// make a copy of the genomes and sort by fitness (high to low)
var orderedGenomes = Genomes.ToList();
orderedGenomes.Sort((a, b) =>
{
var aFitness = a.GetFitness(avgDamage, avgSurvivalTime);
var bFitness = b.GetFitness(avgDamage, avgSurvivalTime);
if (aFitness > bFitness)
{
return(1);
}
if (aFitness < bFitness)
{
return(-1);
}
return(0);
});
// trim out the worst genomes
var toRemove = (int)Math.Floor(ReplacementPercent * Size);
orderedGenomes.RemoveRange(Size - toRemove, toRemove);
for (var i = 0; i < Size; i++)
{
if (i < NumClones)
{
m_genomes[i] = orderedGenomes[i];
orderedGenomes[i].Id = i;
orderedGenomes[i].GenomeType = GenomeType.Clone;
orderedGenomes[i].ResetStats();
}
else
{
var genome = DoCrossover(orderedGenomes);
genome.Id = i;
if (Random.NextDouble() < MutationRate)
{
genome.Mutate();
}
m_genomes[i] = genome;
}
}
Generation++;
}
public MasterMindPopulation(int numberOfGenomes)
{
Genomes.Clear();
for (int i = 0; i < numberOfGenomes; i++)
{
MastermindGenome aGenome = new MastermindGenome(kLength, 1, 9);
aGenome.SetCrossoverPoint(kCrossover);
aGenome.CalculateFitness();
Genomes.Add(aGenome);
}
}
/// <summary>
/// Create a population of a set number of genes, with a crossover type, and the ideal path ends
/// </summary>
/// <param name="numberOfGenomes"></param>
/// <param name="crossOver"></param>
/// <param name="originPosition"></param>
/// <param name="destinationPosition"></param>
public Population(int numberOfGenomes, CrossOver crossOver, Coordinate originPosition, Coordinate destinationPosition, float mutationStrength)
{
NumberOfGenomes = numberOfGenomes;
CrossOver = crossOver;
OriginPosition = originPosition;
DestinationPosition = destinationPosition;
MutationStrength = (int)(mutationStrength * 100);
for (int i = 0; i < NumberOfGenomes; i++)
{
Genomes.Add(new Genome(OriginPosition));
}
}
/// <summary>
/// If the minimum fitness is less than 0, the absolute value of
/// it is added to every genome, so that they all have positive fitness.
/// It may be useful in some computations and it doesn't affect anything.
/// </summary>
private void MakeGenomesHaveOnlyPositiveFitnesses()
{
var minFitness = Genomes.Min(x => x.Fitness);
if (minFitness > 0)
{
return;
}
var absMinFitness = Mathf.Abs(minFitness);
Genomes.ForEach(x => x.Fitness += absMinFitness);
}
private Genome Crossover()
{
var mother = Genomes.GetRandomElement();
var father = Genomes.GetRandomElement();
while (father == mother)
{
father = Genomes.GetRandomElement();
}
if (mother.Fitness < father.Fitness)
{
var tmp = father;
father = mother;
mother = tmp;
}
var childGenome = new Genome();
foreach (var node in mother.NodeGenes.Values)
{
childGenome.AddNodeGene(new NodeGene(node));
}
foreach (var motherConnectionGene in mother.ConnectionGenes)
{
ConnectionGene newChildConnection;
var coinToss = RandomGenerator.GetCoinToss();
var connectionGeneId = motherConnectionGene.Key;
if (father.ConnectionGenes.ContainsKey(connectionGeneId))
{
if (coinToss)
{
newChildConnection = new ConnectionGene(motherConnectionGene.Value);
}
else
{
newChildConnection = new ConnectionGene(father.ConnectionGenes[connectionGeneId]);
}
}
else
{
newChildConnection = new ConnectionGene(motherConnectionGene.Value);
}
childGenome.AddConnectionGene(newChildConnection, connectionGeneId);
}
return(childGenome);
}
public void Evolve()
{
int prevPoplLen;
prevPoplLen = Genomes.Count();
Genomes = GenerationGenerator.Generate(Genomes);
if (!Genomes.Any())
{
Populate(prevPoplLen);
}
Generation++;
}
/// <summary>
/// Ends the generation.
/// </summary>
/// <param name="genomesNumber">Genomes number to keep on generation.</param>
public void End(int genomesNumber)
{
Genomes = Genomes
.Where(ValidateChromosome)
.OrderByDescending(c => c.Fitness.Value)
.ToList();
if (Genomes.Count > genomesNumber)
{
Genomes = Genomes.Take(genomesNumber).ToList();
}
BestGenome = Genomes.First();
}
private void GrabNBest(int nBest, int numCopies, List <TGenome> newPopulation)
{
//sort(m_vecGenomes.begin(), m_vecGenomes.end());
Genomes = Genomes.OrderByDescending(g => g.Fitness).ToList();
//now add the required amount of copies of the n most fittest
//to the supplied vector
while (nBest-- > 0)
{
for (int i = 0; i < numCopies; ++i)
{
newPopulation.Add(Genomes[nBest]);
}
}
}
/// <summary>
/// Create a new generation of genomes based on the previous
/// </summary>
public void CreateNewGeneration() //when mutate? before, after, new percentage set?
{
int topTenPercent = (int)(((double)NumberOfGenomes / 100) * 25);
IOrderedEnumerable <Genome> genomesByFitness = Genomes.OrderBy(g => GetFitness(g));
int requiredRemaining = NumberOfGenomes - topTenPercent;
Genomes = new List <Genome>(genomesByFitness
.Take(topTenPercent)
.ToList());
List <Genome> offspring = GetCrossOverGenomes(Genomes, requiredRemaining);
Genomes.AddRange(offspring);
MutateGenomes(Genomes);
}
private void CreateStartPopulation(int genomes, int numChromosoneBits, int numGeneBits)
{
//clear existing population
Genomes.Clear();
for (int i = 0; i < genomes; i++)
{
var genome = new TGenome();
genome.Initialize(numChromosoneBits, numGeneBits);
Genomes.Add(genome);
}
//reset all variables
Generation = 0;
TotalFitnessScore = 0;
}
public Genome Breed()
{
Genome childGenome;
if (Genomes.Count > 1 && RandomGenerator.GetRandomResult(Config.CrossoverChance))
{
childGenome = Crossover();
}
else
{
childGenome = new Genome(Genomes.GetRandomElement());
}
childGenome.TryMutate();
return(childGenome);
}
/// <summary>
///
/// </summary>
/// <param name="IndexGenome"></param>
/// <returns></returns>
public static string GetGenomeProgram(int IndexGenome)
{
string str = "";
//
IndexGenome = Genomes.GetLastGenocodeIndex();
//
foreach (Chromosome Chomo in Genomes.GetGenocode(IndexGenome))
{
str += "Chromo:\n";
foreach (Gene Gen in Chomo)
{
str += (TypeActionsOfPlants)Gen.GetGeneCommand() + "\n";
}
}
return(str);
}
public virtual Genome <T>[] Epoch(Genome <T>[] oldGenomes = null)
{
Genomes = oldGenomes ?? Genomes;
// Sort for the roulette
Array.Sort(Genomes, Comparer);
ResetRemarkableValues();
CalculateRemarkableValues();
// Copy the genomes
Genomes = Genomes.Select(g => new Genome <T>(g)).ToArray();
List <Genome <T> > population;
if (IsElitist)
{
population = GetBests(Math.Min(NbEliteMax, PopulationSize), NbEliteCopies);
}
else
{
population = new List <Genome <T> >();
}
while (population.Count < PopulationSize)
{
Genome <T> parent1 = TriggerRoulette();
Genome <T> parent2 = TriggerRoulette();
T[] child1, child2;
Crossover(parent1.Values, parent2.Values, out child1, out child2);
Mutate(child1, MutationRate);
Mutate(child2, MutationRate);
population.Add(new Genome <T>(child1, 0));
population.Add(new Genome <T>(child2, 0));
}
Genomes = population.ToArray();
return(Genomes);
}
private void CreateStartPopulation(int genomes, Action <TGenome> genomeCreationMethod)
{
//clear existing population
Genomes.Clear();
for (int i = 0; i < genomes; i++)
{
var genome = new TGenome();
genomeCreationMethod(genome);
Genomes.Add(genome);
}
//reset all variables
Generation = 0;
TotalFitnessScore = 0;
GeneLength = -1;
ChromosoneLength = Genomes.First().Genes.Sum(g => g.Length);
}
private Genome getGenomeByRoulette()
{
var chosen = default(Genome);
var slice = _rand.NextDouble() * FitnessStats.Total;
var cumulativeFitness = 0.0;
foreach (var genome in Genomes)
{
cumulativeFitness += genome.Fitness;
if (cumulativeFitness >= slice)
{
chosen = genome;
break;
}
}
chosen = chosen ?? Genomes.OrderBy(x => _rand.Next()).First();
return(chosen);
}
