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; }