//-----------------------------------Epoch()-----------------------------
//
// takes a population of chromosones and runs the algorithm through one
// cycle.
// Returns a new population of chromosones.
//-----------------------------------------------------------------------
vector<SGenome> CGenAlg::Epoch(vector<SGenome> &old_pop)
{
//assign the given population to the classes population
m_vecPop = old_pop;
//reset the appropriate variables
Reset();
//create a temporary vector to store new chromosones
vector <SGenome> vecNewPop;
CalculateBestWorstAvTot();
//sort the population (for scaling and elitism)
sort(m_vecPop.begin(), m_vecPop.end());
//Now to add a little elitism we shall add in some copies of the
//fittest genomes. Make sure we add an EVEN number or the roulette
//wheel sampling will crash
if (!(CParams::iNumCopiesElite * CParams::iNumElite % 2))
{
GrabNBest(CParams::iNumElite, CParams::iNumCopiesElite, vecNewPop);
}
//--------------now to enter the GA loop
//repeat until a new population is generated
while (vecNewPop.size() < m_iPopSize)
{
//select using tournament selection for a change
SGenome mum = TournamentSelection(CParams::iTournamentCompetitors);
SGenome dad = TournamentSelection(CParams::iTournamentCompetitors);
//create some offspring via crossover
vector<double> baby1, baby2;
CrossoverAtSplits(mum.vecWeights, dad.vecWeights, baby1, baby2);
//now we mutate
Mutate(baby1);
Mutate(baby2);
//now copy into vecNewPop population
vecNewPop.push_back( SGenome(baby1, 0) );
vecNewPop.push_back( SGenome(baby2, 0) );
}
//finished so assign new pop back into m_vecPop
m_vecPop = vecNewPop;
return m_vecPop;
}
//-----------------------------------Epoch()-----------------------------
//
// takes a population of chromosones and runs the algorithm through one
// cycle.
// Returns a new population of chromosones.
//
//-----------------------------------------------------------------------
vector<Genome> GenAlg::Epoch(vector<Genome> &old_pop)
{
//assign the given population to the classes population
mPop = old_pop;
//reset the appropriate variables
Reset();
//sort the population (for scaling and elitism)
sort(mPop.begin(), mPop.end());
//calculate best, worst, average and total fitness
CalculateBestWorstAvTot();
//create a temporary vector to store new chromosones
vector <Genome> vecNewPop;
//Now to add a little elitism we shall add in some copies of the
//fittest genomes. Make sure we add an EVEN number or the roulette
//wheel sampling will crash
if (!(NUM_COPIES_ELITE * NUM_ELITE % 2))
{
GrabNBest(NUM_ELITE, NUM_COPIES_ELITE, vecNewPop);
}
//now we enter the GA loop
//repeat until a new population is generated
while (vecNewPop.size() < mPopSize)
{
//grab two chromosones
Genome mum = GetChromoRoulette();
Genome dad = GetChromoRoulette();
//create some offspring via crossover
vector<double> baby1, baby2;
Crossover(mum.weights, dad.weights, baby1, baby2);
//now we mutate
Mutate(baby1);
Mutate(baby2);
//now copy into vecNewPop population
vecNewPop.push_back(Genome(baby1, 0));
vecNewPop.push_back(Genome(baby2, 0));
}
//finished so assign new pop back into m_vecPop
mPop = vecNewPop;
return mPop;
}
//--------------------------------Epoch---------------------------------
//
// This is the workhorse of the GA. It first updates the fitness
// scores of the population then creates a new population of
// genomes using the Selection, Croosover and Mutation operators
// we have discussed
//----------------------------------------------------------------------
void Cga::Epoch()
{
//Now to create a new population
int NewBabies = 0;
CalculateTotalFitness();
//create some storage for the baby genomes
vector<SGenome> vecBabyGenomes;
//Now to add a little elitism we shall add in some copies of the
//fittest genomes
//make sure we add an EVEN number or the roulette wheel
//sampling will crash
if (!(NUM_COPIES_ELITE * NUM_ELITE % 2))
{
GrabNBest(NUM_ELITE, NUM_COPIES_ELITE, vecBabyGenomes);
}
while (vecBabyGenomes.size() < m_iPopSize)
{
//select 2 parents
SGenome mum = RouletteWheelSelection();
SGenome dad = RouletteWheelSelection();
//operator - crossover
SGenome baby1, baby2;
Crossover(mum.vecBits, dad.vecBits, baby1.vecBits, baby2.vecBits);
//operator - mutate
Mutate(baby1.vecBits);
Mutate(baby2.vecBits);
//add to new population
vecBabyGenomes.push_back(baby1);
vecBabyGenomes.push_back(baby2);
NewBabies += 2;
}
//copy babies back into starter population
m_vecGenomes = vecBabyGenomes;
//increment the generation counter
++m_iGeneration;
}
TArray<FGenome> GeneticAlg::Epoch(TArray<FGenome> &OldPop)
{
PopArray = OldPop;
Reset();
PopArray.Sort(); //sorts Fgenomes by fitness
CalculateBestWorstAvTot();
TArray<FGenome> NewPop;
if (!(NumCopiesElite * NumElites % 2))
{
GrabNBest(NumElites, NumCopiesElite, NewPop);
}
while (NewPop.Num() < PopulationSize)
{
//grab two chromosones
FGenome mum = GetChromoRoulette();
FGenome dad = GetChromoRoulette();
//create some offspring via crossover
TArray<float> baby1, baby2;
CrossOver(mum.WeightsArray, dad.WeightsArray, baby1, baby2);
//now we mutate
Mutate(baby1);
Mutate(baby2);
//now copy into vecNewPop population
NewPop.Add(FGenome(baby1, 0));
NewPop.Add(FGenome(baby2, 0));
}
//finished so assign new pop back into m_vecPop
PopArray = NewPop;
return PopArray;
}
//------------------------Epoch-------------------------------
//
// creates a new population of genomes using the selection,
// mutation and crossover operators
//------------------------------------------------------------
void CgaTSP::Epoch()
{
//first we reset variables and calculate the fitness of each genome
Reset();
CalculatePopulationsFitness();
//if we have found a solution exit
if ((m_dShortestRoute <= m_pMap->BestPossibleRoute()))
{
m_bStarted = false;
return;
}
//perform the appropriate fitness scaling
FitnessScaleSwitch();
//if sigma is zero (either set in sigma scaling or in CalculateBestWorstAv
//then the population are identical and we should stop the run
if (m_dSigma == 0)
{
m_bStarted = false;
return;
}
//create a temporary vector for the new population
vector<SGenome> vecNewPop;
if (m_bElitism)
{
//Now to add a little elitism we shall add in some copies of the
//fittest genomes
const int CopiesToAdd = 2;
const int NBest = 4;
//make sure we add an EVEN number or the roulette wheel
//sampling will crash
if (!(CopiesToAdd * NBest % 2))
{
GrabNBest(NBest, CopiesToAdd, vecNewPop);
}
}
//SUS selection selects the entire population all at once so we have to
//handle the epoch slightly differently if SUS is chosen
if(m_SelectionType != SUS)
{
//now create the remainder of the population
while (vecNewPop.size() != m_iPopSize)
{
SGenome mum, dad;
//switch on selection method
switch(m_SelectionType)
{
case ROULETTE:
//grab two parents dependent on the selection method
mum = RouletteWheelSelection();
dad = RouletteWheelSelection();
break;
case TOURNAMENT:
mum = TournamentSelection(NUM_TO_COMPARE);
dad = TournamentSelection(NUM_TO_COMPARE);
break;
case ALT_TOURNAMENT:
mum = AlternativeTournamentSelection();
dad = AlternativeTournamentSelection();
break;
}
//create 2 children
SGenome baby1, baby2;
//Breed them
Crossover(mum.vecCities,
dad.vecCities,
baby1.vecCities,
baby2.vecCities,
m_CrossoverType);
//and mutate them
Mutate(baby1.vecCities, m_MutationType);
Mutate(baby2.vecCities, m_MutationType);
//add them to new population
vecNewPop.push_back(baby1);
vecNewPop.push_back(baby2);
}
}
//SUS selection
else
{
//select all the individuals
vector<SGenome> vecSampledPop;
SUSSelection(vecSampledPop);
//step through the newly sampled population and apply crossover
//and mutation operators
for (int gen=0; gen<vecSampledPop.size(); gen+=2)
{
SGenome baby1, baby2;
Crossover(vecSampledPop[gen].vecCities,
vecSampledPop[gen+1].vecCities,
baby1.vecCities,
baby2.vecCities,
m_CrossoverType);
Mutate(baby1.vecCities, m_MutationType);
Mutate(baby2.vecCities, m_MutationType);
vecNewPop.push_back(baby1);
vecNewPop.push_back(baby2);
}
}
//copy into next generation
m_vecPopulation = vecNewPop;
//increment generation counter
++m_iGeneration;
}
