bool initialize(StateP state)
{
voidP lBound = state->getGenotypes()[0]->getParameterValue(state, "lbound");
lbound = *((double*) lBound.get());
voidP uBound = state->getGenotypes()[0]->getParameterValue(state, "ubound");
ubound = *((double*) uBound.get());
voidP dimension_ = state->getGenotypes()[0]->getParameterValue(state, "dimension");
dimension = *((uint*) dimension_.get());
voidP dup_ = getParameterValue(state, "dup");
dup = *((uint*) dup_.get());
if( *((int*) dup_.get()) <= 0 ) {
ECF_LOG(state, 1, "Error: opt-IA requires parameter 'dup' to be an integer greater than 0");
throw "";}
voidP c_ = getParameterValue(state, "c");
c = *((double*) c_.get());
if( c <= 0 ) {
ECF_LOG(state, 1, "Error: opt-IA requires parameter 'c' to be a double greater than 0");
throw "";}
voidP tauB_ = getParameterValue(state, "tauB");
tauB = *((double*) tauB_.get());
if( tauB < 0 ) {
ECF_LOG(state, 1, "Error: opt-IA requires parameter 'tauB' to be a nonnegative double value");
throw "";}
voidP elitism_ = getParameterValue(state, "elitism");
elitism = *((string*) elitism_.get());
if( elitism != "true" && elitism != "false" ) {
ECF_LOG(state, 1, "Error: opt-IA requires parameter 'elitism' to be either 'true' or 'false'");
throw "";}
// algorithm accepts a single FloatingPoint Genotype
FloatingPointP flp (new FloatingPoint::FloatingPoint);
if(state->getGenotypes()[0]->getName() != flp->getName()) {
ECF_LOG_ERROR(state, "Error: opt-IA algorithm accepts only a FloatingPoint genotype!");
throw ("");}
// algorithm adds another FloatingPoint genotype (age)
FloatingPointP flpoint[2];
for(uint iGen = 1; iGen < 2; iGen++) {
flpoint[iGen] = (FloatingPointP) new FloatingPoint::FloatingPoint;
state->setGenotype(flpoint[iGen]);
flpoint[iGen]->setParameterValue(state, "dimension", (voidP) new uint(1));
// initial value of age parameter should be (or as close as possible to) 0
flpoint[iGen]->setParameterValue(state, "lbound", (voidP) new double(0));
flpoint[iGen]->setParameterValue(state, "ubound", (voidP) new double(0.01));
}
ECF_LOG(state, 1, "opt-IA algorithm: added 1 FloatingPoint genotype (antibody age)");
return true;
}
bool ArtificialBeeColony::initialize(StateP state)
{
// initialize all operators
selFitOp->initialize(state);
selFitOp->setSelPressure(2);
selBestOp->initialize(state);
selWorstOp->initialize(state);
selRandomOp->initialize(state);
voidP sptr = state->getRegistry()->getEntry("population.size");
uint size = *((uint*) sptr.get());
probability_.resize(size);
// this algorithm accepts a single FloatingPoint Genotype
FloatingPointP flp (new FloatingPoint::FloatingPoint);
if(state->getGenotypes()[0]->getName() != flp->getName()) {
ECF_LOG_ERROR(state, "Error: ABC algorithm accepts only a single FloatingPoint genotype!");
throw ("");
}
voidP limitp = getParameterValue(state, "limit");
limit_ = *((uint*) limitp.get());
voidP lBound = state->getGenotypes()[0]->getParameterValue(state, "lbound");
lbound_ = *((double*) lBound.get());
voidP uBound = state->getGenotypes()[0]->getParameterValue(state, "ubound");
ubound_ = *((double*) uBound.get());
// batch run check
if(isTrialAdded_)
return true;
FloatingPointP flpoint[2];
for(uint iGen = 1; iGen < 2; iGen++) {
flpoint[iGen] = (FloatingPointP) new FloatingPoint::FloatingPoint;
state->setGenotype(flpoint[iGen]);
flpoint[iGen]->setParameterValue(state, "dimension", (voidP) new uint(1));
// initial value of trial parameter should be (as close as possible to) 0
flpoint[iGen]->setParameterValue(state, "lbound", (voidP) new double(0));
flpoint[iGen]->setParameterValue(state, "ubound", (voidP) new double(0.01));
}
ECF_LOG(state, 1, "ABC algorithm: added 1 FloatingPoint genotype (trial)");
// mark adding of trial genotype
isTrialAdded_ = true;
return true;
}
bool initialize(StateP state)
{
// initialize all operators
selFitOp->initialize(state);
selBestOp->initialize(state);
selRandomOp->initialize(state);
voidP limit_ = getParameterValue(state, "limit");
limit = *((uint*) limit_.get());
voidP lBound = state->getGenotypes()[0]->getParameterValue(state, "lbound");
lbound = *((double*) lBound.get());
voidP uBound = state->getGenotypes()[0]->getParameterValue(state, "ubound");
ubound = *((double*) uBound.get());
// algorithm accepts a single FloatingPoint Genotype
FloatingPointP flp (new FloatingPoint::FloatingPoint);
if(state->getGenotypes()[0]->getName() != flp->getName()) {
ECF_LOG_ERROR(state, "Error: ABC algorithm accepts only a FloatingPoint genotype!");
throw ("");
}
FloatingPointP flpoint[2];
for(uint iGen = 1; iGen < 2; iGen++) {
flpoint[iGen] = (FloatingPointP) new FloatingPoint::FloatingPoint;
state->setGenotype(flpoint[iGen]);
flpoint[iGen]->setParameterValue(state, "dimension", (voidP) new uint(1));
// initial value of trial parameter should be (as close as possible to) 0
flpoint[iGen]->setParameterValue(state, "lbound", (voidP) new double(0));
flpoint[iGen]->setParameterValue(state, "ubound", (voidP) new double(0.01));
}
ECF_LOG(state, 1, "ABC algorithm: added 1 FloatingPoint genotype (trial)");
return true;
}
bool RegEvalOp::initialize(StateP state) {
state->getContext()->environment = this;
voidP sptr = state->getRegistry()->getEntry("classesNum");
classesNum = *((uint *) sptr.get());
std::string outputPath = *((std::string*) state->getRegistry()->getEntry("resultsfile").get());
std::ofstream outfile;
outfile.open(outputPath.c_str());
if (!outfile.is_open()) {
ECF_LOG_ERROR(state, "Error: Can't open output file " + outputPath);
return false;
}
outfile << "Gen_No,Training,Test" << std::endl;
outfile.close();
sptr = state->getRegistry()->getEntry("inputfile");
std::string filePath = *((std::string *) sptr.get());
ifstream file;
file.open(filePath.c_str());
if (!file.is_open()) {
ECF_LOG_ERROR(state, "Error: Can't open input file " + filePath);
return false;
}
parseFile(domain, codomain, file);
file.close();
sptr = state->getRegistry()->getEntry("testfile");
filePath = *((std::string *) sptr.get());
file.open(filePath.c_str());
if (!file.is_open()) {
ECF_LOG_ERROR(state, "Error: Can't open test file " + filePath);
return false;
}
parseFile(testDomain, testCodomain, file);
file.close();
sptr = state->getRegistry()->getEntry("classesfile");
filePath = *((std::string *) sptr.get());
file.open(filePath.c_str());
if (!file.is_open()) {
generateDefaultClasses();
} else {
generateParsedClasses(file);
}
file.close();
for (auto& entry: classes) {
f1Score.insert(std::make_pair(entry.first, std::vector<uint>(3, 0)));
}
return true;
}
/**
* \brief Initialize all mutation operators of all active genotypes
*/
bool Mutation::initialize(StateP state)
{
state_ = state;
protectedGenotypes_.clear();
protectedGenotypes_.insert(protectedGenotypes_.begin(), operators.size(), false);
opProb.clear();
voidP sptr = state->getRegistry()->getEntry("mutation.indprob");
indMutProb_ = *((double*)sptr.get());
sptr = state->getRegistry()->getEntry("mutation.geneprob");
// geneMutProb_ = *((double*)sptr.get());
// if(state->getRegistry()->isModified("mutation.geneprob") == false)
// geneMutProb_ = 0;
sptr = state->getRegistry()->getEntry("mutation.genotypes");
std::string mutGen = *((std::string*)sptr.get());
mutateGenotypes_ = RANDOM_GENOTYPE;
if(mutGen == "random")
mutateGenotypes_ = RANDOM_GENOTYPE;
else if(mutGen == "all")
mutateGenotypes_ = ALL_GENOTYPES;
else
ECF_LOG_ERROR(state, "Warning: invalid parameter value (key: mutation.genotypes)");
// read protected genotypes
std::stringstream ss;
sptr = state->getRegistry()->getEntry("mutation.protected");
ss << *((std::string*) sptr.get());
uint genId;
while(ss >> genId) { // read all the data from string
if(genId >= protectedGenotypes_.size()) {
ECF_LOG_ERROR(state, "Error: invalid genotype index (key: mutation.protected)!");
throw("");
}
protectedGenotypes_[genId] = true;
}
// initialize operators for all genotypes
for(uint gen = 0; gen < operators.size(); gen++) {
uint nOps = (uint) operators[gen].size();
// if the genotype doesn't define mutation operators
if(nOps == 0) {
protectedGenotypes_[gen] = true;
std::vector<double> empty;
opProb.push_back(empty);
break;
}
for(uint i = 0; i < nOps; i++) {
operators[gen][i]->state_ = state;
operators[gen][i]->initialize(state);
}
// calculate cumulative operator probabilities
std::vector<double> probs(nOps);
probs[0] = operators[gen][0]->probability_;
for(uint i = 1; i < nOps; i++) {
probs[i] = probs[i - 1] + operators[gen][i]->probability_;
}
if(probs[nOps - 1] == 0) {
std::vector<double> none(1);
none[0] = -1;
opProb.push_back(none);
} else {
if(probs[nOps - 1] != 1) {
double normal = probs[nOps - 1];
ECF_LOG_ERROR(state, "Warning: " + operators[gen][0]->myGenotype_->getName() +
" mutation operators: cumulative probability not equal to 1 (sum = " + dbl2str(normal) + ")");
for(uint i = 0; i < probs.size(); i++)
probs[i] /= normal;
}
opProb.push_back(probs);
}
}
return true;
}
bool PSOInheritance::initialize(StateP state)
{
// initialize all operators
selBestOp->initialize(state);
voidP weightType = getParameterValue(state, "weightType");
m_weightType = *((InertiaWeightType*) weightType.get());
voidP weight = getParameterValue(state, "weight");
m_weight = *((double*) weight.get());
voidP maxV = getParameterValue(state, "maxVelocity");
m_maxV = *((double*) maxV.get());
// test if inertia weight type is time variant and if so, check if max iterations specified
if(m_weightType == TIME_VARIANT) {
if(state->getRegistry()->isModified("term.maxgen")) {
// read maxgen parameter
m_maxIter = *(boost::static_pointer_cast<int>( state->getRegistry()->getEntry("term.maxgen") ));
}
else {
ECF_LOG_ERROR(state, "Error: term.maxgen has to be specified in order to use time variant inertia eight in PSO algorithm");
throw("");
}
}
// algorithm accepts a single FloatingPoint Genotype
FloatingPointP flp (new FloatingPoint::FloatingPoint);
if(state->getGenotypes()[0]->getName() != flp->getName()) {
ECF_LOG_ERROR(state, "Error: PSO algorithm accepts only a single FloatingPoint genotype!");
throw ("");
}
voidP sptr = state->getGenotypes()[0]->getParameterValue(state, "dimension");
uint numDimension = *((uint*) sptr.get());
voidP bounded = getParameterValue(state, "bounded");
bounded_ = *((bool*) bounded.get());
sptr = state->getGenotypes()[0]->getParameterValue(state, "lbound");
lbound_ = *((double*) sptr.get());
sptr = state->getGenotypes()[0]->getParameterValue(state, "ubound");
ubound_ = *((double*) sptr.get());
// batch run check
if(areGenotypesAdded_)
return true;
FloatingPointP flpoint[4];
for(uint iGen = 1; iGen < 4; iGen++) {
flpoint[iGen] = (FloatingPointP) new FloatingPoint::FloatingPoint;
state->setGenotype(flpoint[iGen]);
if(iGen == 3)
flpoint[iGen]->setParameterValue(state, "dimension", (voidP) new uint(1));
else
flpoint[iGen]->setParameterValue(state, "dimension", (voidP) new uint(numDimension));
// other parameters are proprietary (ignored by the algorithm)
flpoint[iGen]->setParameterValue(state, "lbound", (voidP) new double(0));
flpoint[iGen]->setParameterValue(state, "ubound", (voidP) new double(1));
}
ECF_LOG(state, 1, "PSO algorithm: added 3 FloatingPoint genotypes (particle velocity, best-so-far postition, best-so-far fitness value)");
// mark adding of genotypes
areGenotypesAdded_ = true;
return true;
}
