/*!
* \brief Validate the GP individual.
* \param ioContext Evolutionary context.
* \return True if the GP individual is valid, false if not.
*/
bool GP::Individual::validate(GP::Context& ioContext)
{
Beagle_StackTraceBeginM();
bool lResult = true;
Beagle_LogDetailedM(
ioContext.getSystem().getLogger(),
std::string("Validating ")+uint2ordinal(ioContext.getIndividualIndex()+1)+
std::string(" individual")
);
// Store original values.
GP::Tree::Handle lOldTreeHandle = ioContext.getGenotypeHandle();
unsigned int lOldTreeIndex = ioContext.getGenotypeIndex();
// Loop through each of the trees in the individual
for (unsigned int i=0; i<size(); i++) {
GP::Tree::Handle lTree = (*this)[i];
if (lTree == NULL) {
Beagle_LogVerboseM(
ioContext.getSystem().getLogger(),
std::string("Skipping ")+uint2ordinal(i+1)+std::string(" tree because it's NULL-valued")
);
continue;
}
Beagle_LogVerboseM(
ioContext.getSystem().getLogger(),
std::string("Validating ")+uint2ordinal(i+1)+std::string(" tree")
);
// Store the new values
ioContext.setGenotypeHandle(lTree);
ioContext.setGenotypeIndex(i);
lTree->setContextToNode(0, ioContext);
if(!lTree->validateSubTree(0, ioContext)) {
Beagle_LogVerboseM(
ioContext.getSystem().getLogger(),
std::string("Validation of ")+uint2ordinal(i+1)+std::string(" tree failed.")
);
lResult = false;
break;
}
}
if(lResult) {
Beagle_LogVerboseM(
ioContext.getSystem().getLogger(),
std::string("Individual passed validation testing.")
);
}
// Restore the original values.
ioContext.setGenotypeHandle(lOldTreeHandle);
ioContext.setGenotypeIndex(lOldTreeIndex);
return lResult;
Beagle_StackTraceEndM();
}
void TreeSTag::removeNOP(Individual& inIndividual, GP::Context& ioContext) {
// Beagle_LogDebugM(
// ioContext.getSystem().getLogger(),
// "individual", "TreeSTag",
// std::string("Individual before NOP removal: ")+inIndividual.serialize()
// );
TreeSTag::Handle lTree = castHandleT<TreeSTag>((inIndividual)[0]);
GP::Individual& lIndividual = castObjectT<GP::Individual&>(inIndividual);
GP::Individual::Handle lOldIndividualHandle = ioContext.getIndividualHandle();
unsigned int lOldGenotypeIndex = ioContext.getGenotypeIndex();
GP::Tree::Handle lOldGenotypeHandle = ioContext.getGenotypeHandle();
ioContext.setIndividualHandle(&lIndividual);
ioContext.setGenotypeIndex(0);
ioContext.setGenotypeHandle(lIndividual[0]);
ioContext.getCallStack().clear();
removeNOPLoop(0,ioContext);
ioContext.setIndividualHandle(lOldIndividualHandle);
ioContext.setGenotypeIndex(lOldGenotypeIndex);
ioContext.setGenotypeHandle(lOldGenotypeHandle);
// Beagle_LogDebugM(
// ioContext.getSystem().getLogger(),
// "individual", "TreeSTag",
// std::string("Individual after NOP removal: ")+inIndividual.serialize()
// );
}
/*!
* \brief Invoke GP tree to execute as ADF.
* \param outResult Result of GP tree invocation
* \param ioTree Tree to invoke.
* \param ioContext Evolutionary context.
*/
void GP::Module::invoke(GP::Datum& outResult, GP::Tree::Handle ioTree, GP::Context& ioContext)
{
Beagle_StackTraceBeginM();
GP::Tree::Handle lOldGenotypeHandle = ioContext.getGenotypeHandle();
unsigned int lOldGenotypeIndex = ioContext.getGenotypeIndex();
ioContext.setGenotypeHandle(ioTree);
ioContext.setGenotypeIndex(mIndex);
ioContext.incrementNodesExecuted();
ioContext.pushCallStack(0);
Beagle_LogVerboseM(
ioContext.getSystem().getLogger(),
"EMA", "Beagle::GP::Module",
std::string("Interpreting the ")+uint2ordinal(mIndex+1)+std::string(" module")
);
Beagle_LogObjectDebugM(
ioContext.getSystem().getLogger(),
"EMA", "Beagle::GP::Module",
*ioTree
);
(*ioTree)[0].mPrimitive->execute(outResult, ioContext);
ioContext.popCallStack();
ioContext.checkExecutionTime();
ioContext.setGenotypeHandle(lOldGenotypeHandle);
ioContext.setGenotypeIndex(lOldGenotypeIndex);
Beagle_StackTraceEndM("void GP::Module::invoke(GP::Datum& outResult, GP::Tree::Handle ioTree, GP::Context& ioContext)");
}
/*!
* \brief Interpret the GP individual.
* \param outResult Datum containing the result of the interpretation.
* \param ioContext GP evolutionary context.
* \throw Beagle::ObjectException When individual or tree are empty.
* \throw Beagle::AssertException When context is not correctly set.
* \throw Beagle::GP::MaxNodesExecutionException If number of nodes execution is more than allowed.
* \throw Beagle::GP::MaxTimeExecutionException If elapsed execution time is more than allowed.
*/
void GP::Individual::run(GP::Datum& outResult, GP::Context& ioContext)
{
Beagle_StackTraceBeginM();
if(&ioContext.getIndividual() != this) {
std::ostringstream lOSS;
lOSS << "In GP::Individual::run(): For the given context, ";
lOSS << "getIndividual() did not return the same individual as was passed to this (run) ";
lOSS << "method. Consider setting the context's individual to be the same by using the ";
lOSS << "method Context::setIndividualHandle().";
throw Beagle_RunTimeExceptionM(lOSS.str());
}
if(empty()) throw Beagle_ObjectExceptionM("Could not interpret, individual has no trees!");
if((*this)[0]->empty()) throw Beagle_ObjectExceptionM("Could not interpret, 1st tree is empty!");
Tree::Handle lOldTreeHandle = ioContext.getGenotypeHandle();
unsigned int lOldTreeIndex = ioContext.getGenotypeIndex();
ioContext.setGenotypeIndex(0);
ioContext.setGenotypeHandle((*this)[0]);
Beagle_LogVerboseM(
ioContext.getSystem().getLogger(),
std::string("Running the ")+uint2ordinal(ioContext.getIndividualIndex()+1)+
std::string(" individual")
);
Beagle_LogDebugM(
ioContext.getSystem().getLogger(),
std::string("The individual is: ")
);
Beagle_LogDebugM(
ioContext.getSystem().getLogger(),
(*this)
);
Beagle_LogDebugM(
ioContext.getSystem().getLogger(),
std::string("Executing the first tree root node '")+
(*(*this)[0])[0].mPrimitive->getName()+"'"
);
ioContext.setNodesExecutionCount(0);
ioContext.incrementNodesExecuted();
ioContext.getExecutionTimer().reset();
ioContext.pushCallStack(0);
(*(*this)[0])[0].mPrimitive->execute(outResult, ioContext);
ioContext.popCallStack();
ioContext.checkExecutionTime();
Beagle_LogDebugM(
ioContext.getSystem().getLogger(),
std::string("Result of executing the ")+uint2ordinal(ioContext.getIndividualIndex()+1)+
std::string(" individual: ")+outResult.serialize()
);
ioContext.setGenotypeIndex(lOldTreeIndex);
ioContext.setGenotypeHandle(lOldTreeHandle);
Beagle_StackTraceEndM();
}
/*!
* \brief Invoke GP tree to execute as ADF.
* \param outResult Result of GP tree invocation
* \param ioTree Tree to invoke.
* \param ioContext Evolutionary context.
*/
void GP::ADF::invoke(GP::Datum& outResult, GP::Tree::Handle ioTree, GP::Context& ioContext)
{
Beagle_StackTraceBeginM();
GP::Tree::Handle lOldGenotypeHandle = ioContext.getGenotypeHandle();
unsigned int lOldGenotypeIndex = ioContext.getGenotypeIndex();
ioContext.setGenotypeHandle(ioTree);
ioContext.setGenotypeIndex(mIndex);
ioContext.incrementNodesExecuted();
ioContext.pushCallStack(0);
(*ioTree)[0].mPrimitive->execute(outResult, ioContext);
ioContext.popCallStack();
ioContext.checkExecutionTime();
ioContext.setGenotypeHandle(lOldGenotypeHandle);
ioContext.setGenotypeIndex(lOldGenotypeIndex);
Beagle_StackTraceEndM("void GP::ADF::invoke(GP::Datum& outResult, GP::Tree::Handle ioTree, GP::Context& ioContext)");
}
/*!
* \brief Select a node for mating in the given individual, following the constraints penalties.
* \param outSelectTreeIndex Tree index of the selected node.
* \param outSelectNodeIndex Index of the selected node.
* \param inSelectABranch True if node to select must be a branch, false if it must a leaf.
* \param inNodeReturnType Desired return type for the nodes to be selected.
* \param inPrimitSetIndex Primitive set index to which the tree must be associated.
* \param inMaxSubTreeDepth Maximum sub tree depth allowed of the node to be selected.
* \param inMaxSubTreeSize Maximum sub tree size allowed of the node to be selected.
* \param inIndividual Individual to select the node from.
* \param ioContext Evolutionary context.
* \return True if there was node to select, false if no node respected all constraints.
*/
bool STGP::CrossoverConstrainedOp::selectNodeToMateWithType(unsigned int& outSelectTreeIndex,
unsigned int& outSelectNodeIndex,
bool inSelectABranch,
const std::type_info* inNodeReturnType,
unsigned int inPrimitSetIndex,
unsigned int inMaxSubTreeDepth,
unsigned int inMaxSubTreeSize,
GP::Individual& inIndividual,
GP::Context& ioContext) const
{
Beagle_StackTraceBeginM();
RouletteT< std::pair<unsigned int,unsigned int> > lRoulette;
GP::Tree::Handle lOldTreeHandle = ioContext.getGenotypeHandle();
const unsigned int lOldTreeIndex = ioContext.getGenotypeIndex();
ioContext.emptyCallStack();
for(unsigned int i=0; i<inIndividual.size(); ++i) {
if(inIndividual[i]->getPrimitiveSetIndex() != inPrimitSetIndex) continue;
ioContext.setGenotypeHandle(inIndividual[i]);
ioContext.setGenotypeIndex(i);
buildRouletteWithType(lRoulette,
inSelectABranch,
inNodeReturnType,
inMaxSubTreeDepth,
inMaxSubTreeSize,
0,
*inIndividual[i],
ioContext);
}
ioContext.setGenotypeIndex(lOldTreeIndex);
ioContext.setGenotypeHandle(lOldTreeHandle);
if(lRoulette.size() == 0) return false;
std::pair<unsigned int,unsigned int> lSelectedNode =
lRoulette.select(ioContext.getSystem().getRandomizer());
outSelectTreeIndex = lSelectedNode.first;
outSelectNodeIndex = lSelectedNode.second;
return true;
Beagle_StackTraceEndM();
}