/*!
* \return Return selection probability of breeder operator.
* \param inChild Child node in the breeder tree.
*/
double InvalidateFitnessOp::getBreedingProba(BreederNode::Handle inChild)
{
Beagle_StackTraceBeginM();
Beagle_NonNullPointerAssertM(inChild);
Beagle_NonNullPointerAssertM(inChild->getBreederOp());
return inChild->getBreederOp()->getBreedingProba(inChild->getFirstChild());
Beagle_StackTraceEndM();
}
/*!
* \return Return selection probability of breeder operator.
* \param inChild Child node in the breeder tree.
*/
double ES::AdaptOneFifthRuleOp::getBreedingProba(BreederNode::Handle inChild)
{
Beagle_StackTraceBeginM();
Beagle_NonNullPointerAssertM(inChild);
Beagle_NonNullPointerAssertM(inChild->getBreederOp());
return inChild->getBreederOp()->getBreedingProba(inChild->getFirstChild());
Beagle_StackTraceEndM();
}
/*!
* \brief Apply the fitness invalidation operation on a breeding pool, returning a bred individual.
* \param inBreedingPool Breeding pool to use for the breeding operation.
* \param inChild Node handle associated to child node in the breeder tree.
* \param ioContext Evolutionary context of the breeding operation.
* \return Invalidated bred individual.
*/
Individual::Handle InvalidateFitnessOp::breed(Individual::Bag& inBreedingPool,
BreederNode::Handle inChild,
Context& ioContext)
{
Beagle_StackTraceBeginM();
Beagle_NonNullPointerAssertM(inChild);
Beagle_NonNullPointerAssertM(inChild->getBreederOp());
Individual::Handle lBredIndividual =
inChild->getBreederOp()->breed(inBreedingPool, inChild->getFirstChild(), ioContext);
if((lBredIndividual->getFitness()!=NULL) && (lBredIndividual->getFitness()->isValid())) {
Beagle_LogDebugM(
ioContext.getSystem().getLogger(),
"Invalidating the fitness of the following bred individual"
);
Beagle_LogDebugM(ioContext.getSystem().getLogger(), *lBredIndividual);
lBredIndividual->getFitness()->setInvalid();
}
return lBredIndividual;
Beagle_StackTraceEndM();
}
/*!
* \brief Apply the crossover operation on a breeding pool, returning a mated individual.
* \param inBreedingPool Breeding pool to use for the crossover operation.
* \param inChild Node handle associated to child node in the breeder tree.
* \param ioContext Evolutionary context of the crossover operation.
* \return Mated individual.
*/
Individual::Handle CrossoverOp::breed(Individual::Bag& inBreedingPool,
BreederNode::Handle inChild,
Context& ioContext)
{
Beagle_StackTraceBeginM();
Context::Alloc::Handle lContextAlloc =
castHandleT<Context::Alloc>(ioContext.getSystem().getFactory().getConceptAllocator("Context"));
Context::Handle lContext2 = castHandleT<Context>(lContextAlloc->clone(ioContext));
Beagle_NonNullPointerAssertM(inChild);
Beagle_NonNullPointerAssertM(inChild->getBreederOp());
Individual::Handle lIndiv1 = inChild->getBreederOp()->breed(inBreedingPool,
inChild->getFirstChild(),
ioContext);
Beagle_NonNullPointerAssertM(inChild->getNextSibling());
Beagle_NonNullPointerAssertM(inChild->getNextSibling()->getBreederOp());
Individual::Handle lIndiv2 =
inChild->getNextSibling()->getBreederOp()->breed(inBreedingPool,
inChild->getNextSibling()->getFirstChild(),
*lContext2);
Beagle_LogVerboseM(
ioContext.getSystem().getLogger(),
std::string("Mating the ")+uint2ordinal(ioContext.getIndividualIndex()+1)+
std::string(" individual with the ")+uint2ordinal(lContext2->getIndividualIndex()+1)+
" individual"
);
if((lIndiv1 != NULL) && (lIndiv2 != NULL)) {
bool lMated = mate(*lIndiv1, ioContext, *lIndiv2, *lContext2);
if(lMated) {
if(lIndiv1->getFitness() != NULL) lIndiv1->getFitness()->setInvalid();
if(lIndiv2->getFitness() != NULL) lIndiv2->getFitness()->setInvalid();
History::Handle lHistory = castHandleT<History>(ioContext.getSystem().haveComponent("History"));
if(lHistory != NULL) {
std::vector<HistoryID> lParents;
HistoryID::Handle lHID1 = castHandleT<HistoryID>(lIndiv1->getMember("HistoryID"));
if(lHID1 != NULL) lParents.push_back(*lHID1);
HistoryID::Handle lHID2 = castHandleT<HistoryID>(lIndiv2->getMember("HistoryID"));
if(lHID2 != NULL) lParents.push_back(*lHID2);
lHistory->incrementHistoryVar(*lIndiv1);
lHistory->trace(ioContext, lParents, lIndiv1, getName(), "crossover");
}
}
}
return lIndiv1;
Beagle_StackTraceEndM();
}
/*!
* \brief Configure evolver with anisotropic (\mu,\lambda) self-adaptive evolution strategy algorithm.
* \param ioEvolver Evolver modified by setting the algorithm.
* \param ioSystem Evolutionary system.
*/
void SAES::Algorithm::configure(Evolver& ioEvolver, System& ioSystem)
{
Beagle_StackTraceBeginM();
// Get reference to the factory
const Factory& lFactory = ioSystem.getFactory();
// Get name and allocator of used operators
std::string lEvalOpName = lFactory.getConceptTypeName("EvaluationOp");
EvaluationOp::Alloc::Handle lEvalOpAlloc =
castHandleT<EvaluationOp::Alloc>(lFactory.getAllocator(lEvalOpName));
std::string lSelectOpName = "SelectRandomOp";
EC::SelectionOp::Alloc::Handle lSelectOpAlloc =
castHandleT<EC::SelectionOp::Alloc>(lFactory.getAllocator(lSelectOpName));
std::string lInitOpName = lFactory.getConceptTypeName("InitializationOp");
EC::InitializationOp::Alloc::Handle lInitOpAlloc =
castHandleT<EC::InitializationOp::Alloc>(lFactory.getAllocator(lInitOpName));
std::string lMutOpName = "SAES-MutationOp";
EC::MutationOp::Alloc::Handle lMutOpAlloc =
castHandleT<EC::MutationOp::Alloc>(lFactory.getAllocator(lMutOpName));
std::string lMigOpName = lFactory.getConceptTypeName("MigrationOp");
EC::MigrationOp::Alloc::Handle lMigOpAlloc =
castHandleT<EC::MigrationOp::Alloc>(lFactory.getAllocator(lMigOpName));
std::string lStatsCalcOpName = lFactory.getConceptTypeName("StatsCalculateOp");
EC::StatsCalculateOp::Alloc::Handle lStatsCalcOpAlloc =
castHandleT<EC::StatsCalculateOp::Alloc>(lFactory.getAllocator(lStatsCalcOpName));
std::string lTermOpName = lFactory.getConceptTypeName("TerminationOp");
EC::TerminationOp::Alloc::Handle lTermOpAlloc =
castHandleT<EC::TerminationOp::Alloc>(lFactory.getAllocator(lTermOpName));
std::string lMsWriteOpName = "MilestoneWriteOp";
EC::MilestoneWriteOp::Alloc::Handle lMsWriteOpAlloc =
castHandleT<EC::MilestoneWriteOp::Alloc>(lFactory.getAllocator(lMsWriteOpName));
std::string lMCLOpName = "EC-MuCommaLambdaOp";
EC::MuCommaLambdaOp::Alloc::Handle lMCLOpAlloc =
castHandleT<EC::MuCommaLambdaOp::Alloc>(lFactory.getAllocator(lMCLOpName));
// Clear bootstrap and mainloop sets
ioEvolver.getBootStrapSet().clear();
ioEvolver.getMainLoopSet().clear();
// Set the boostrap operator set
EC::InitializationOp::Handle lInitOpBS = castHandleT<EC::InitializationOp>(lInitOpAlloc->allocate());
lInitOpBS->setName(lInitOpName);
ioEvolver.getBootStrapSet().push_back(lInitOpBS);
EvaluationOp::Handle lEvalOpBS = castHandleT<EvaluationOp>(lEvalOpAlloc->allocate());
lEvalOpBS->setName(lEvalOpName);
ioEvolver.getBootStrapSet().push_back(lEvalOpBS);
EC::StatsCalculateOp::Handle lStatsCalcOpBS = castHandleT<EC::StatsCalculateOp>(lStatsCalcOpAlloc->allocate());
lStatsCalcOpBS->setName(lStatsCalcOpName);
ioEvolver.getBootStrapSet().push_back(lStatsCalcOpBS);
EC::TerminationOp::Handle lTermOpBS = castHandleT<EC::TerminationOp>(lTermOpAlloc->allocate());
lTermOpBS->setName(lTermOpName);
ioEvolver.getBootStrapSet().push_back(lTermOpBS);
EC::MilestoneWriteOp::Handle lMsWriteOpBS = castHandleT<EC::MilestoneWriteOp>(lMsWriteOpAlloc->allocate());
lMsWriteOpBS->setName(lMsWriteOpName);
ioEvolver.getBootStrapSet().push_back(lMsWriteOpBS);
// Set the mainloop operator set
EC::MuCommaLambdaOp::Handle lMCLOp = castHandleT<EC::MuCommaLambdaOp>(lMCLOpAlloc->allocate());
lMCLOp->setName(lMCLOpName);
// Set breeder tree
BreederNode::Handle lEvalNode = new BreederNode;
lMCLOp->setRootNode(lEvalNode);
lEvalNode->setBreederOp(castHandleT<EvaluationOp>(lEvalOpAlloc->allocate()));
lEvalNode->getBreederOp()->setName(lEvalOpName);
BreederNode::Handle lMutNode = new BreederNode;
lEvalNode->setFirstChild(lMutNode);
lMutNode->setBreederOp(castHandleT<EC::MutationOp>(lMutOpAlloc->allocate()));
lMutNode->getBreederOp()->setName(lMutOpName);
BreederNode::Handle lSelectMutNode = new BreederNode;
lMutNode->setFirstChild(lSelectMutNode);
lSelectMutNode->setBreederOp(castHandleT<EC::SelectionOp>(lSelectOpAlloc->allocate()));
lSelectMutNode->getBreederOp()->setName(lSelectOpName);
// Set remaining operators of mainloop
EC::MigrationOp::Handle lMigOpML = castHandleT<EC::MigrationOp>(lMigOpAlloc->allocate());
lMigOpML->setName(lMigOpName);
ioEvolver.getMainLoopSet().push_back(lMigOpML);
EC::StatsCalculateOp::Handle lStatsCalcOpML =
castHandleT<EC::StatsCalculateOp>(lStatsCalcOpAlloc->allocate());
lStatsCalcOpML->setName(lStatsCalcOpName);
ioEvolver.getMainLoopSet().push_back(lStatsCalcOpML);
EC::TerminationOp::Handle lTermOpML = castHandleT<EC::TerminationOp>(lTermOpAlloc->allocate());
lTermOpML->setName(lTermOpName);
ioEvolver.getMainLoopSet().push_back(lTermOpML);
EC::MilestoneWriteOp::Handle lMsWriteOpML =
castHandleT<EC::MilestoneWriteOp>(lMsWriteOpAlloc->allocate());
lMsWriteOpML->setName(lMsWriteOpName);
ioEvolver.getMainLoopSet().push_back(lMsWriteOpML);
Beagle_StackTraceEndM();
}
/*!
* \brief Configure steady-state evolutionary algorithm in evolver.
* \param ioEvolver Evolver modified by setting the algorithm.
* \param ioSystem Evolutionary system.
*
*/
void AlgoSteadyState::configure(Evolver& ioEvolver, System& ioSystem)
{
Beagle_StackTraceBeginM();
// Get reference to the factory
const Factory& lFactory = ioSystem.getFactory();
// Get name and allocator of used operators
std::string lEvalOpName = lFactory.getConceptTypeName("EvaluationOp");
EvaluationOp::Alloc::Handle lEvalOpAlloc =
castHandleT<EvaluationOp::Alloc>(lFactory.getAllocator(lEvalOpName));
std::string lSelectOpName = lFactory.getConceptTypeName("SelectionOp");
SelectionOp::Alloc::Handle lSelectOpAlloc =
castHandleT<SelectionOp::Alloc>(lFactory.getAllocator(lSelectOpName));
std::string lInitOpName = lFactory.getConceptTypeName("InitializationOp");
InitializationOp::Alloc::Handle lInitOpAlloc =
castHandleT<InitializationOp::Alloc>(lFactory.getAllocator(lInitOpName));
std::string lCxOpName = lFactory.getConceptTypeName("CrossoverOp");
CrossoverOp::Alloc::Handle lCxOpAlloc =
castHandleT<CrossoverOp::Alloc>(lFactory.getAllocator(lCxOpName));
std::string lMutOpName = lFactory.getConceptTypeName("MutationOp");
MutationOp::Alloc::Handle lMutOpAlloc =
castHandleT<MutationOp::Alloc>(lFactory.getAllocator(lMutOpName));
std::string lMigOpName = lFactory.getConceptTypeName("MigrationOp");
MigrationOp::Alloc::Handle lMigOpAlloc =
castHandleT<MigrationOp::Alloc>(lFactory.getAllocator(lMigOpName));
std::string lStatsCalcOpName = lFactory.getConceptTypeName("StatsCalculateOp");
StatsCalculateOp::Alloc::Handle lStatsCalcOpAlloc =
castHandleT<StatsCalculateOp::Alloc>(lFactory.getAllocator(lStatsCalcOpName));
std::string lTermOpName = lFactory.getConceptTypeName("TerminationOp");
TerminationOp::Alloc::Handle lTermOpAlloc =
castHandleT<TerminationOp::Alloc>(lFactory.getAllocator(lTermOpName));
std::string lMsWriteOpName = "MilestoneWriteOp";
MilestoneWriteOp::Alloc::Handle lMsWriteOpAlloc =
castHandleT<MilestoneWriteOp::Alloc>(lFactory.getAllocator(lMsWriteOpName));
std::string lSSOpName = "SteadyStateOp";
SteadyStateOp::Alloc::Handle lSSOpAlloc =
castHandleT<SteadyStateOp::Alloc>(lFactory.getAllocator(lSSOpName));
// Clear bootstrap and mainloop sets
ioEvolver.getBootStrapSet().clear();
ioEvolver.getMainLoopSet().clear();
// Set the boostrap operator set
InitializationOp::Handle lInitOpBS = castHandleT<InitializationOp>(lInitOpAlloc->allocate());
lInitOpBS->setName(lInitOpName);
ioEvolver.getBootStrapSet().push_back(lInitOpBS);
EvaluationOp::Handle lEvalOpBS = castHandleT<EvaluationOp>(lEvalOpAlloc->allocate());
lEvalOpBS->setName(lEvalOpName);
ioEvolver.getBootStrapSet().push_back(lEvalOpBS);
StatsCalculateOp::Handle lStatsCalcOpBS = castHandleT<StatsCalculateOp>(lStatsCalcOpAlloc->allocate());
lStatsCalcOpBS->setName(lStatsCalcOpName);
ioEvolver.getBootStrapSet().push_back(lStatsCalcOpBS);
TerminationOp::Handle lTermOpBS = castHandleT<TerminationOp>(lTermOpAlloc->allocate());
lTermOpBS->setName(lTermOpName);
ioEvolver.getBootStrapSet().push_back(lTermOpBS);
MilestoneWriteOp::Handle lMsWriteOpBS = castHandleT<MilestoneWriteOp>(lMsWriteOpAlloc->allocate());
lMsWriteOpBS->setName(lMsWriteOpName);
ioEvolver.getBootStrapSet().push_back(lMsWriteOpBS);
// Set the mainloop operator set
SteadyStateOp::Handle lSSOp = castHandleT<SteadyStateOp>(lSSOpAlloc->allocate());
lSSOp->setName(lSSOpName);
// Set crossover branch
BreederNode::Handle lCxBranchNode = new BreederNode;
lSSOp->setRootNode(lCxBranchNode);
lCxBranchNode->setBreederOp(castHandleT<EvaluationOp>(lEvalOpAlloc->allocate()));
lCxBranchNode->getBreederOp()->setName(lEvalOpName);
BreederNode::Handle lCxNode = new BreederNode;
lCxBranchNode->setFirstChild(lCxNode);
lCxNode->setBreederOp(castHandleT<CrossoverOp>(lCxOpAlloc->allocate()));
lCxNode->getBreederOp()->setName(lCxOpName);
BreederNode::Handle lSelectCxNode1 = new BreederNode;
lCxNode->setFirstChild(lSelectCxNode1);
lSelectCxNode1->setBreederOp(castHandleT<SelectionOp>(lSelectOpAlloc->allocate()));
lSelectCxNode1->getBreederOp()->setName(lSelectOpName);
BreederNode::Handle lSelectCxNode2 = new BreederNode;
lSelectCxNode1->setNextSibling(lSelectCxNode2);
lSelectCxNode2->setBreederOp(castHandleT<SelectionOp>(lSelectOpAlloc->allocate()));
lSelectCxNode2->getBreederOp()->setName(lSelectOpName);
// Set mutation branch
BreederNode::Handle lMutBranchNode = new BreederNode;
lCxBranchNode->setNextSibling(lMutBranchNode);
lMutBranchNode->setBreederOp(castHandleT<EvaluationOp>(lEvalOpAlloc->allocate()));
lMutBranchNode->getBreederOp()->setName(lEvalOpName);
BreederNode::Handle lMutNode = new BreederNode;
lMutBranchNode->setFirstChild(lMutNode);
lMutNode->setBreederOp(castHandleT<MutationOp>(lMutOpAlloc->allocate()));
lMutNode->getBreederOp()->setName(lMutOpName);
BreederNode::Handle lSelectMutNode = new BreederNode;
lMutNode->setFirstChild(lSelectMutNode);
lSelectMutNode->setBreederOp(castHandleT<SelectionOp>(lSelectOpAlloc->allocate()));
lSelectMutNode->getBreederOp()->setName(lSelectOpName);
// Set reproduction branch
BreederNode::Handle lReproBranchNode = new BreederNode;
lMutBranchNode->setNextSibling(lReproBranchNode);
lReproBranchNode->setBreederOp(castHandleT<SelectionOp>(lSelectOpAlloc->allocate()));
lReproBranchNode->getBreederOp()->setName(lSelectOpName);
// Set remaining operators of mainloop
MigrationOp::Handle lMigOpML = castHandleT<MigrationOp>(lMigOpAlloc->allocate());
lMigOpML->setName(lMigOpName);
ioEvolver.getMainLoopSet().push_back(lMigOpML);
StatsCalculateOp::Handle lStatsCalcOpML =
castHandleT<StatsCalculateOp>(lStatsCalcOpAlloc->allocate());
lStatsCalcOpML->setName(lStatsCalcOpName);
ioEvolver.getMainLoopSet().push_back(lStatsCalcOpML);
TerminationOp::Handle lTermOpML = castHandleT<TerminationOp>(lTermOpAlloc->allocate());
lTermOpML->setName(lTermOpName);
ioEvolver.getMainLoopSet().push_back(lTermOpML);
MilestoneWriteOp::Handle lMsWriteOpML =
castHandleT<MilestoneWriteOp>(lMsWriteOpAlloc->allocate());
lMsWriteOpML->setName(lMsWriteOpName);
ioEvolver.getMainLoopSet().push_back(lMsWriteOpML);
Beagle_StackTraceEndM("void AlgoSteadyState::configure(Evolver&,System&)");
}
/*!
* \brief Apply the adaptation operation on a breeding pool.
* \param inBreedingPool Breeding pool to give to the underlying breeding tree.
* \param inChild Node handle associated to child node in the breeder tree.
* \param ioContext Evolutionary context of the mutation operation.
* \return Mutated individual.
*/
Individual::Handle ES::AdaptOneFifthRuleOp::breed(Individual::Bag& inBreedingPool,
BreederNode::Handle inChild,
Context& ioContext)
{
Beagle_StackTraceBeginM();
Beagle_NonNullPointerAssertM(inChild);
Beagle_NonNullPointerAssertM(inChild->getBreederOp());
Individual::Handle lIndiv =
inChild->getBreederOp()->breed(inBreedingPool, inChild->getFirstChild(), ioContext);
// Look whether the mutation is successful.
Fitness::Handle lFitParent = inBreedingPool[ioContext.getIndividualIndex()]->getFitness();
Fitness::Handle lFitChild = lIndiv->getFitness();
if(lFitChild != NULL) {
// Check whether the mutation is successful or not.
const bool lSuccessful = (*lFitChild) > (*lFitParent);
if(lSuccessful) {
++mSuccessCount->getWrappedValue();
Beagle_LogVerboseM(
ioContext.getSystem().getLogger(),
"Successful mutation"
);
} else {
Beagle_LogVerboseM(
ioContext.getSystem().getLogger(),
"The mutation is not successful"
);
}
++mMutationsCount->getWrappedValue();
// Adapt the sigma if the necessary number of observed mutations is reached.
if(lSuccessful && (mMutationsCount->getWrappedValue()>=mAdaptationPeriod->getWrappedValue())) {
const double lSuccessRate = double(mSuccessCount->getWrappedValue()) /
double(mMutationsCount->getWrappedValue());
if(lSuccessRate > 0.2) {
for(unsigned int i=0; i<mMutateGaussSigma->size(); ++i) {
(*mMutateGaussSigma)[i] /= mSigmaAdaptFactor->getWrappedValue();
}
Beagle_LogDetailedM(
ioContext.getSystem().getLogger(),
string("Increasing the sigma value by a factor ")+
dbl2str(1./mSigmaAdaptFactor->getWrappedValue())
);
Beagle_LogVerboseM(
ioContext.getSystem().getLogger(),
string("Sigma value after the increase: ")+mMutateGaussSigma->serialize()
);
} else if(lSuccessRate < 0.2) {
for(unsigned int i=0; i<mMutateGaussSigma->size(); ++i) {
(*mMutateGaussSigma)[i] *= mSigmaAdaptFactor->getWrappedValue();
}
Beagle_LogDetailedM(
ioContext.getSystem().getLogger(),
string("Reducing the sigma value by a factor ")+
dbl2str(mSigmaAdaptFactor->getWrappedValue())
);
Beagle_LogVerboseM(
ioContext.getSystem().getLogger(),
string("Sigma value after the reduction: ")+mMutateGaussSigma->serialize()
);
} else {
Beagle_LogDetailedM(
ioContext.getSystem().getLogger(),
"Sigma value unchanged"
);
}
}
}
return lIndiv;
Beagle_StackTraceEndM();
}
/*!
* \brief Apply the recombination operation on a breeding pool, returning a recombined individual.
* \param inBreedingPool Breeding pool to use for the recombination operation.
* \param inChild Node handle associated to child node in the breeder tree.
* \param ioContext Evolutionary context of the recombination operation.
* \return Recombined individual.
*/
Individual::Handle RecombinationOp::breed(Individual::Bag& inBreedingPool,
BreederNode::Handle inChild,
Context& ioContext)
{
Beagle_StackTraceBeginM();
// Generate parents for recombination.
Individual::Bag::Handle lParents = new Individual::Bag;
if(inChild == NULL) {
const unsigned int lNbGenerated =
(mNumberRecomb->getWrappedValue()==0) ? inBreedingPool.size() :
minOf<unsigned int>(inBreedingPool.size(), mNumberRecomb->getWrappedValue());
if(lNbGenerated == inBreedingPool.size()) (*lParents) = inBreedingPool;
else {
std::vector<unsigned int> lIndices(inBreedingPool.size());
for(unsigned int i=0; i<lIndices.size(); ++i) lIndices[i] = i;
std::random_shuffle(lIndices.begin(), lIndices.end(),
ioContext.getSystem().getRandomizer());
for(unsigned int i=0; i<lNbGenerated; ++i) {
lParents->push_back(inBreedingPool[lIndices[i]]);
}
}
} else {
Beagle_NonNullPointerAssertM(inChild->getBreederOp());
const unsigned int lNbGenerated =
(mNumberRecomb->getWrappedValue()==0) ? inBreedingPool.size() :
minOf<unsigned int>(inBreedingPool.size(), mNumberRecomb->getWrappedValue());
for(unsigned int i=0; i<lNbGenerated; ++i) {
Individual::Handle lIndiv = inChild->getBreederOp()->breed(inBreedingPool,
inChild->getFirstChild(),
ioContext);
lParents->push_back(lIndiv);
}
}
// Log parents selected for recombination.
Beagle_LogVerboseM(
ioContext.getSystem().getLogger(),
std::string("Recombining ")+uint2str(lParents->size())+std::string(" individuals together")
);
// Do recombination operation on parent and get the resulting child.
Individual::Handle lChildIndiv = recombine(*lParents, ioContext);
if(lChildIndiv->getFitness() != NULL) {
lChildIndiv->getFitness()->setInvalid();
}
// Log information to history, if it is used.
History::Handle lHistory = castHandleT<History>(ioContext.getSystem().haveComponent("History"));
if(lHistory != NULL) {
std::vector<HistoryID> lParentNames;
for(unsigned int i=0; i<lParents->size(); ++i) {
HistoryID::Handle lHID = castHandleT<HistoryID>(lParents->at(i)->getMember("HistoryID"));
if(lHID != NULL) lParentNames.push_back(*lHID);
}
lHistory->incrementHistoryVar(*lChildIndiv);
lHistory->trace(ioContext, lParentNames, lChildIndiv, getName(), "recombination");
}
return lChildIndiv;
Beagle_StackTraceEndM();
}
/*!
* \brief Apply the evaluation operation on a breeding pool, returning a evaluated bred individual.
* \param inBreedingPool Breeding pool to use for the breeding operation.
* \param inChild Node handle associated to child node in the breeder tree.
* \param ioContext Evolutionary context of the breeding operation.
* \return Evaluated bred individual.
*/
Individual::Handle Beagle::MPI::EvaluationOp::breed(Individual::Bag& inBreedingPool,
BreederNode::Handle inChild,
Context& ioContext)
{
Beagle_NonNullPointerAssertM(inChild);
Deme& lDeme = *ioContext.getDemeHandle();
if(lDeme.getStats()->isValid()) {
ioContext.setProcessedDeme(0);
if((ioContext.getGeneration()!=0) && (lDeme.getStats()->existItem("total-processed"))) {
ioContext.setTotalProcessedDeme((unsigned int)lDeme.getStats()->getItem("total-processed"));
}
else ioContext.setTotalProcessedDeme(0);
lDeme.getStats()->setInvalid();
if(ioContext.getDemeIndex()==0) {
Stats& lVivaStats = *ioContext.getVivarium().getStats();
ioContext.setProcessedVivarium(0);
if((ioContext.getGeneration()!=0) && (lVivaStats.existItem("total-processed"))) {
ioContext.setTotalProcessedVivarium((unsigned int)lVivaStats.getItem("total-processed"));
}
else ioContext.setTotalProcessedVivarium(0);
lVivaStats.setInvalid();
}
}
Beagle_NonNullPointerAssertM(inChild);
Beagle_NonNullPointerAssertM(inChild->getBreederOp());
Individual::Handle lBredIndividual =
inChild->getBreederOp()->breed(inBreedingPool, inChild->getFirstChild(), ioContext);
if((lBredIndividual->getFitness()==NULL) || (lBredIndividual->getFitness()->isValid()==false)) {
Beagle_LogVerboseM(
ioContext.getSystem().getLogger(),
"evaluation", "Beagle::MPIEvaluationOp",
"Evaluating the fitness of a new bred individual"
);
individualEvaluation(*lBredIndividual, ioContext);
// lBredIndividual->setFitness(evaluate(*lBredIndividual, ioContext));
// lBredIndividual->getFitness()->setValid();
ioContext.setProcessedDeme(ioContext.getProcessedDeme()+1);
ioContext.setTotalProcessedDeme(ioContext.getTotalProcessedDeme()+1);
ioContext.setProcessedVivarium(ioContext.getProcessedVivarium()+1);
ioContext.setTotalProcessedVivarium(ioContext.getTotalProcessedVivarium()+1);
Beagle_LogVerboseM(
ioContext.getSystem().getLogger(),
"evaluation", "Beagle::MPIEvaluationOp",
std::string("The individual fitness value is: ")+
lBredIndividual->getFitness()->serialize()
);
if(mDemeHOFSize->getWrappedValue() > 0) {
Beagle_LogVerboseM(
ioContext.getSystem().getLogger(),
"evaluation", "Beagle::MPIEvaluationOp",
"Updating the deme hall-of-fame"
);
lDeme.getHallOfFame().updateWithIndividual(mDemeHOFSize->getWrappedValue(),
*lBredIndividual, ioContext);
}
if(mVivaHOFSize->getWrappedValue() > 0) {
Beagle_LogVerboseM(
ioContext.getSystem().getLogger(),
"evaluation", "Beagle::MPIEvaluationOp",
"Updating the vivarium hall-of-fame"
);
ioContext.getVivarium().getHallOfFame().updateWithIndividual(mVivaHOFSize->getWrappedValue(),
*lBredIndividual, ioContext);
}
}
return lBredIndividual;
}
/*!
* \return Return selection probability of breeder operator.
* \param inChild Child node in the breeder tree.
*/
float Beagle::MPI::EvaluationOp::getBreedingProba(BreederNode::Handle inChild)
{
Beagle_NonNullPointerAssertM(inChild);
Beagle_NonNullPointerAssertM(inChild->getBreederOp());
return inChild->getBreederOp()->getBreedingProba(inChild->getFirstChild());
}
