bool ArtificialBeeColony::onlookerBeesPhase(StateP state, DemeP deme) { // jednostavni odabir, uz selFitPropOp /* for( uint i = 0; i < deme->getSize(); i++ ) { // for each food source // choose a food source depending on its fitness value (better individuals are more likely to be chosen) IndividualP food = selFitOp->select(*deme); createNewFoodSource(food, state, deme); } */ // uz vjerojatnosti, jedinka po jedinka calculateProbabilities(state, deme); int demeSize = deme->getSize(); int i = state->getRandomizer()->getRandomInteger(demeSize); int n = 0; while( n < demeSize) { int fact = i++ % demeSize; IndividualP food = deme->at(fact); if (state->getRandomizer()->getRandomDouble() < probability_[fact]){ n++; createNewFoodSource(food, state, deme); } } return true; }
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; }
/** * \brief Register mutation related but Genotype unrelated parameters */ void Mutation::registerParameters(StateP state) { state->getRegistry()->registerEntry("mutation.indprob", (voidP) new double(0.3), ECF::DOUBLE, "individual mutation probability (unless the algorithm overrides it) (default: 0.3)"); // state->getRegistry()->registerEntry("mutation.geneprob", (voidP) new double(0.01), ECF::DOUBLE); state->getRegistry()->registerEntry("mutation.genotypes", (voidP) new std::string("random"), ECF::STRING, "if there are multiple genotypes, which to mutate? 'random': a random one, all: mutate all (default: random)"); state->getRegistry()->registerEntry("mutation.protected", (voidP) new std::string(""), ECF::STRING, "indexes of genotypes (separated by spaces) that are excluded (protected) from mutation (default: none)"); }
bool TermStagnationOp::operate(StateP state) { uint currentGen = state->getGenerationNo(); if(currentGen - state->getPopulation()->getHof()->getLastChange() > termStagnation_) { state->setTerminateCond(); ECF_LOG(state, 1, "Termination: maximum number of generations without improvement (" + uint2str(termStagnation_) + ") reached"); } return true; }
void RegEvalOp::registerParameters(StateP state) { state->getRegistry()->registerEntry("inputfile", (voidP)(new std::string("learning.txt")), ECF::STRING); state->getRegistry()->registerEntry("testfile", (voidP)(new std::string("test.txt")), ECF::STRING); state->getRegistry()->registerEntry("classesfile", (voidP)(new std::string("classes.txt")), ECF::STRING); state->getRegistry()->registerEntry("resultsfile", (voidP)(new std::string("results.txt")), ECF::STRING); state->getRegistry()->registerEntry("classesNum", (voidP)(new uint(2)), ECF::UINT); }
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 createNewFoodSource(IndividualP food, StateP state, DemeP deme) { //for each food source find a neighbour IndividualP neighbour; do{ neighbour = selRandomOp->select(*deme); }while(food->index == neighbour->index); //potential new food source IndividualP newFood = copy(food); FloatingPointP flp = boost::dynamic_pointer_cast<FloatingPoint::FloatingPoint> (food->getGenotype(0)); std::vector< double > &foodVars = flp->realValue; flp = boost::dynamic_pointer_cast<FloatingPoint::FloatingPoint> (neighbour->getGenotype(0)); std::vector< double > &neighbourVars = flp->realValue; flp = boost::dynamic_pointer_cast<FloatingPoint::FloatingPoint> (newFood->getGenotype(0)); std::vector< double > &newFoodVars = flp->realValue; uint param = state->getRandomizer()->getRandomInteger((int)foodVars.size()); double factor = state->getRandomizer()->getRandomDouble(); double value = foodVars[param] * (1-2*factor)*(foodVars[param]-neighbourVars[param]); if (value > ubound) value = ubound; else if (value <lbound) value = lbound; //produce a modification on the food source (discover a new food source) newFoodVars[param] = value; evaluate(newFood); flp = boost::dynamic_pointer_cast<FloatingPoint::FloatingPoint> (food->getGenotype(1)); double &foodTrial = flp->realValue[0]; // d) if the fitness value of the new food source is better than that of the original source, // memorize the new source, forget the old one and set trial to 0 // otherwise keep the old one and increment trial if(newFood->fitness->isBetterThan( food->fitness) ) { foodVars[param] = value; evaluate(food); foodTrial = 0; } else { foodTrial +=1; } return true; }
bool Individual::initialize(StateP state) { state_ = state; this->clear(); // copy genotypes from State for(uint i = 0; i < state->getGenotypes().size(); i++) { this->push_back(static_cast<GenotypeP> (state->getGenotypes()[i]->copy())); (*this)[i]->setGenotypeId(i); } // init genotypes for(uint i = 0; i < this->size(); i++) (*this)[i]->initialize(state); return true; }
//! cross donor vectors with population members to create trial vectors void DifferentialEvolution::crossover(DemeP deme, uint index, StateP state) { // get population member and corresponding donor vector FloatingPoint::FloatingPoint* flp1 = (FloatingPoint::FloatingPoint*) (deme->at(index)->getGenotype().get()); int dim = (int) flp1->realValue.size(); FloatingPoint::FloatingPoint* flp2 = (FloatingPoint::FloatingPoint*) donor_vector[index]->getGenotype().get(); // crossover their elements (keep the result in donor_vector) for(uint i = 0; i < flp1->realValue.size(); i++) { if (state->getRandomizer()->getRandomDouble() <= CR_ || i == state->getRandomizer()->getRandomInteger(dim)) { } else { flp2->realValue[i] = flp1->realValue[i]; } } }
bool hypermutationPhase(StateP state, DemeP deme, std::vector<IndividualP> &clones) { uint M; // M - number of mutations of a single antibody uint k; //sort std::sort (clones.begin(), clones.end(), sortPopulationByFitness); for( uint i = 0; i < clones.size(); i++ ){ // for each antibody in vector clones IndividualP antibody = clones.at(i); FloatingPointP flp = boost::dynamic_pointer_cast<FloatingPoint::FloatingPoint> (antibody->getGenotype(0)); std::vector< double > &antibodyVars = flp->realValue; k = 1 + i/(dup+1); M =(int) ((1- 1/(double)(k)) * (c*dimension) + (c*dimension)); // mutate M times for (uint j = 0; j < M; j++){ uint param = state->getRandomizer()->getRandomInteger((int)antibodyVars.size()); double randDouble1 = state->getRandomizer()->getRandomDouble(); double randDouble2 = state->getRandomizer()->getRandomDouble(); double value = antibodyVars[param] + (1-2*randDouble1)* 0.2 * (ubound - lbound) * pow(2, -16*randDouble2 ); if (value > ubound) value = ubound; else if (value <lbound) value = lbound; //produce a mutation on the antibody antibodyVars[param] = value; } FitnessP parentFitness = antibody->fitness; evaluate(antibody); // if the clone is better than its parent, reset clone's age if(antibody-> fitness->isBetterThan(parentFitness)){ flp = boost::dynamic_pointer_cast<FloatingPoint::FloatingPoint> (antibody->getGenotype(1)); double &age = flp->realValue[0]; age = 0; } } return true; }
bool DifferentialEvolution::initialize(StateP state) { selRandomOp->initialize(state); donor_vector.clear(); // read parameters, check defined genotype (only a single FloatingPoint is allowed) voidP F = getParameterValue(state, "F"); Fconst_ = *((double*) F.get()); voidP CR = getParameterValue(state, "CR"); CR_ = *((double*) CR.get()); FloatingPointP flp (new FloatingPoint::FloatingPoint); if(state->getGenotypes()[0]->getName() != flp->getName() || state->getGenotypes().size() != 1) { state->getLogger()->log(1, "Error: DE algorithm accepts only a single FloatingPoint genotype!"); throw (""); } return true; }
void ModularRobotEvalOp::registerParameters(StateP state) { state->getRegistry()->registerEntry("robot.modules", (voidP) (new uint(1)), ECF::UINT, "Number of modules" ); state->getRegistry()->registerEntry("robot.runtime", (voidP) (new uint(10000)), ECF::UINT, "Max robot runtime (ms)" ); state->getRegistry()->registerEntry("robot.timestep", (voidP) (new float(1.0)), ECF::FLOAT, "Time step (ms)" ); state->getRegistry()->registerEntry("robot.configfile", (voidP) (new std::string()), ECF::STRING, "Robot description file"); state->getRegistry()->registerEntry("osc.maxamplitude", (voidP) (new uint(90)), ECF::UINT, "Max amplitude of oscillators"); state->getRegistry()->registerEntry("osc.maxoffset", (voidP) (new uint(90)), ECF::UINT, "Max offset of oscillators"); state->getRegistry()->registerEntry("osc.maxphase", (voidP) (new uint(360)), ECF::UINT, "Max phase of oscillators"); state->getRegistry()->registerEntry("osc.maxfrequency", (voidP) (new float(1.0f)), ECF::FLOAT, "Max frequency of oscillators"); }
bool SymbRegEvalOp::initialize(StateP state) { domain.clear(); codomain.clear(); double datum; std::stringstream ss; // check if the parameters are defined in the conf. file // if not, we return false so the initialization fails if(!state->getRegistry()->isModified("domain") || !state->getRegistry()->isModified("codomain")) return false; voidP sptr = state->getRegistry()->getEntry("domain"); // get parameter value ss << *((std::string*) sptr.get()); // convert from voidP to user defined type while(ss >> datum) { // read all the data from string domain.push_back(datum); } ss.str(""); ss.clear(); // reset stringstream object sptr = state->getRegistry()->getEntry("codomain"); // get codomain parameter ss << *((std::string*) sptr.get()); while(ss >> datum) { // read values codomain.push_back(datum); } if(domain.size() != codomain.size()) // if the parameters are ill defined, return false return false; nSamples = (uint) domain.size(); return true; //nSamples = 10; //double x = -10; //for(uint i = 0; i < nSamples; i++) { // domain.push_back(x); // codomain.push_back(x + sin(x)); // x += 2; //} //return true; }
int main(int argc, char **argv) { // argc = 2; // argv[1] = "./examples/GAFunctionMin/parametri.txt"; // PSO algoritam: //argv[1] = "./examples/GAFunctionMin/parameters_DE.txt"; GenHookeJeevesP alg (new GenHookeJeeves); StateP state (new State); state->addAlgorithm(alg); state->setEvalOp(static_cast<EvaluateOpP> (new FunctionMinEvalOp)); state->initialize(argc, argv); state->run(); return 0; }
bool TermStagnationOp::initialize(StateP state) { voidP sptr = state->getRegistry()->getEntry("term.stagnation"); termStagnation_ = *((uint*) sptr.get()); // define the default criterion if(termStagnation_ == 0) { voidP sptr = state->getRegistry()->getEntry("population.size"); uint demeSize = *((uint*) sptr.get()); termStagnation_ = 5000 / demeSize; if(termStagnation_ < 10) termStagnation_ = 5; if(termStagnation_ > 200) termStagnation_ = 200; } if(!state->getRegistry()->isModified("term.stagnation")) return false; 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 StatCalc::initialize(StateP state) { state_ = state; average_.clear(); stdDev_.clear(); max_.clear(); min_.clear(); time_.clear(); sampleSize_.clear(); evaluations_.clear(); nEvaluations_ = 0; lowest_ = highest_ = 0; if(state->getRegistry()->isModified("stats.file")) { voidP sptr = state->getRegistry()->getEntry("stats.file"); statsFileName_ = *((std::string*) sptr.get()); statsFile_.open(statsFileName_.c_str()); if(!statsFile_) { throw std::string("Error: can't open stats file (") + statsFileName_ + ")"; } } return true; }
void SymbRegEvalOp::registerParameters(StateP state) { state->getRegistry()->registerEntry("domain", (voidP) (new std::string), ECF::STRING); state->getRegistry()->registerEntry("codomain", (voidP) (new std::string), ECF::STRING); }
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; }
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; }
void TermStagnationOp::registerParameters(StateP state) { uint *value = new uint(50); state->getRegistry()->registerEntry("term.stagnation", (voidP) value, ECF::UINT, "max number of consecutive generations without improvement (default: 5000 / pop_size)"); }
/** * \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; }
void CgdaPaintFitnessFunction::registerParameters(StateP state) { state->getRegistry()->registerEntry("function", (voidP) (new uint(1)), ECF::UINT); }
void StatCalc::registerParameters(StateP state) { state->getRegistry()->registerEntry("stats.file", (voidP) (new std::string("")), ECF::STRING); }
bool CgdaPaintFitnessFunction::initialize(StateP state) { voidP sptr = state->getRegistry()->getEntry("function"); // get parameter value return true; }
bool PSOInheritance::advanceGeneration(StateP state, DemeP deme) { // a) For each particle: // 1) If the fitness value is better than the best fitness value (pBest) in history // 2) Set current value as the new pBest // 3) Put particle in the ranking array using the fitness value // End // b) For the p best particles in the ranking arrayºº // 1) Find, in the particle neighborhood, the particle with the best fitness // 2) Calculate particle velocity according to the velocity equation (1) // 3) Apply the velocity constriction // 4) Update particle position according to the position equation (2) // 5) Apply the position constriction // c) Inherit // Evaluate // 1) Get the fitness value via evaluation or inheritance. // End for( uint i = 0; i < deme->getSize(); i++ ) { // for each particle IndividualP particle = deme->at(i); //Read "i" particle // the whole point of this section is to compare fitness and pbest FloatingPointP flp = boost::dynamic_pointer_cast<FloatingPoint::FloatingPoint> (particle->getGenotype(3)); double &particlePbestFitness = flp->realValue[0]; double fitness = particle->fitness->getValue(); //There is a problem with the particlePbestFitness initialization in this algorithm. The following lines take care of this. //TODO: Find a way to do this in the ¿initialize fuction?. if(state->getGenerationNo()==1){ //std::cout<<"INCIALIZADOOOOOOOOOOOOO!!!!!!!!!!!!!!!!!"<<std::endl; particlePbestFitness=fitness; } else{ //std::cout<<"FITNESS"<<fitness<<std::endl; flp = boost::dynamic_pointer_cast<FloatingPoint::FloatingPoint> (particle->getGenotype(0)); std::vector< double > &positions = flp->realValue; flp = boost::dynamic_pointer_cast<FloatingPoint::FloatingPoint> (particle->getGenotype(2)); std::vector< double > &pbestx = flp->realValue; // set particle pbestx-es if( /*iter == 0 ||*/ fitness < particlePbestFitness ) { // minimize error particlePbestFitness = fitness; //Update particle personal fitness // set pbestx-es for( uint j = 0;j<pbestx.size();j++ ) { pbestx[j] = positions[j]; } } } // NOTE store best particle index? //std::cout<<"THE PBEST OF THIS PARTICLE IS!!!!!!!!!!!!:"<<particlePbestFitness<<std::endl; } // b) for( uint i = 0; i < deme->getSize(); i++ ) { // for each particle IndividualP particle = deme->at(i); IndividualP bestParticle = selBestOp->select( *deme ); FloatingPointP flp = boost::dynamic_pointer_cast<FloatingPoint::FloatingPoint> (particle->getGenotype(0)); std::vector< double > &positions = flp->realValue; flp = boost::dynamic_pointer_cast<FloatingPoint::FloatingPoint> (particle->getGenotype(1)); std::vector< double > &velocities = flp->realValue; flp = boost::dynamic_pointer_cast<FloatingPoint::FloatingPoint> (particle->getGenotype(2)); std::vector< double > &pbestx = flp->realValue; double R1=rand()/(float)RAND_MAX, R2=rand()/(float)RAND_MAX, vf; int C1=2, C2=2; double weight_up; switch( m_weightType ) { //time variant weight, linear from weight to 0.4 case TIME_VARIANT: weight_up = ( m_weight - 0.4 ) * ( m_maxIter - state->getGenerationNo() ) / m_maxIter + 0.4; break; // constant inertia weight case CONSTANT: default: weight_up = m_weight; break; } // calculate particle velocity according to the velocity equation (1) flp = boost::dynamic_pointer_cast<FloatingPoint::FloatingPoint> (bestParticle->getGenotype(2)); std::vector< double > &bestParticlesPbestx = flp->realValue; for( uint j = 0; j < velocities.size(); j++ ) { double velocity; velocity = weight_up * velocities[j] + 2 * R1 * (pbestx[j] - positions[j]) + 2 * R2 * (bestParticlesPbestx[j] - positions[j]); if( velocity > m_maxV ) velocity = m_maxV; if( velocity < -m_maxV) velocity = -m_maxV; velocities[j] = velocity; positions[j] += velocities[j]; //Updated positions with velocitites X(t+1)=X(t)+velocities(t); // TODO apply position constriction // check for bounds if(bounded_) { if(positions[j] < lbound_) positions[j] = lbound_; if(positions[j] > ubound_) positions[j] = ubound_; } //std::cout<<"LA VELOCIDAD ES::::"<<velocity<<std::endl; } int proportion=55; if(rand()%100>=proportion){ //Initial PSO inheritance algorithm -> 100%inheritance no evaluations. //determine new particle fitness //Particle best personal fitness // flp = boost::dynamic_pointer_cast<FloatingPoint::FloatingPoint> (particle->getGenotype(3)); // double &particlePbestFitness = flp->realValue[0]; //Best particle fitness // flp = boost::dynamic_pointer_cast<FloatingPoint::FloatingPoint> (bestParticle->getGenotype(3)); // double &bestparticlePbestFitness = flp->realValue[0]; // vf=(C1*R1*(particlePbestFitness-particle->fitness->getValue())+C2*R2*(bestparticlePbestFitness-particle->fitness->getValue())) // /(1+C1*R1+C2*R2); // vf=vf+particle->fitness->getValue(); evaluate( particle ); //std::cout<< " Inherited: " << vf<< " -> Evaluated "<< particle->fitness->getValue() <<std::endl ; } else{ //Particle best personal fitness flp = boost::dynamic_pointer_cast<FloatingPoint::FloatingPoint> (particle->getGenotype(3)); double &particlePbestFitness = flp->realValue[0]; //Best particle fitness flp = boost::dynamic_pointer_cast<FloatingPoint::FloatingPoint> (bestParticle->getGenotype(3)); double &bestparticlePbestFitness = flp->realValue[0]; //std::cout<<std::endl<<"The EverPersonalBEST of this particle is:"<<particlePbestFitness<<std::endl; //std::cout<<std::endl<<"THE present LEADER(Allbes) of this particle fitness is:"<<bestparticlePbestFitness<<std::endl; //Inheritance based on flight formula std::cout<<"Particle Fitness"<<particle->fitness->getValue()<<" "<<std::endl; //Fitness inheritance vf=(C1*R1*(particlePbestFitness-particle->fitness->getValue())+C2*R2*(bestparticlePbestFitness-particle->fitness->getValue())) /(1+C1*R1+C2*R2); particle->fitness->setValue(vf+particle->fitness->getValue()); std::cout<< " Inherited: " << particle->fitness->getValue()<< " "<< std::endl ; } } //std::cout<<std::endl<<"THE NUMBER OF THIS GENERATION IS:"<<state->getGenerationNo() <<std::endl; std::cout<<std::endl<<"THE NUMBER OF EVALUATIONS ARE:"<<state->getEvaluations() <<std::endl; std::cout<<std::endl<<"THE TIME TAKEN TO DO THIS IS:"<<state->getElapsedTime() <<std::endl; //*******************FILE OUTPUT FOR DEBUGGING***********************************************// IndividualP bestParticle = selBestOp->select( *deme ); FloatingPointP flp = boost::dynamic_pointer_cast<FloatingPoint::FloatingPoint> (bestParticle->getGenotype(3)); double &bestparticlePbestFitness = flp->realValue[0]; std::ofstream myfile1; myfile1.open("FitnessvsEvaluations.txt", std::ios_base::app); if (myfile1.is_open()){ myfile1<<bestparticlePbestFitness<<" "; myfile1<<state->getEvaluations()<<std::endl; } //*******************************************************************************************// return true; }
bool ModularRobotEvalOp::initialize(StateP state) { //-- Get the robot values from the registry: //----------------------------------------------------------------------------------------- //-- Number of modules: voidP sptr = state->getRegistry()->getEntry("robot.modules"); n_modules = *((uint*) sptr.get() ); std::cout << "[Evolve] Info: Loaded \"robot.modules\"="<< n_modules << std::endl; //-- Max runtime: sptr = state->getRegistry()->getEntry("robot.runtime"); max_runtime =(unsigned long) *((uint*) sptr.get() ); std::cout << "[Evolve] Info: Loaded \"robot.runtime\"="<< max_runtime << std::endl; //-- Time step: sptr = state->getRegistry()->getEntry("robot.timestep"); timestep = *((float*) sptr.get() ); std::cout << "[Evolve] Info: Loaded \"robot.timestep\"="<< timestep << std::endl; //-- Gait table file: sptr = state->getRegistry()->getEntry("robot.configfile"); config_file = *((std::string*) sptr.get() ); std::cout << "[Evolve] Info: Loaded \"robot.configfile\"="<< config_file << std::endl; //-- Get the oscillator parameters from the registry: //--------------------------------------------------------------------------------------- //-- Max amplitude: sptr = state->getRegistry()->getEntry("osc.maxamplitude"); int max_amplitude = *((uint*) sptr.get()); max_amp_0_5 = max_amplitude / 2.0; std::cout << "[Evolve] Info: Loaded \"osc.maxamplitude\"="<< max_amplitude << std::endl; //-- Max offset: sptr = state->getRegistry()->getEntry("osc.maxoffset"); max_offset = *((uint*) sptr.get()); std::cout << "[Evolve] Info: Loaded \"osc.maxoffset\"="<< max_offset << std::endl; //-- Max phase: sptr = state->getRegistry()->getEntry("osc.maxphase"); int max_phase = *((uint*) sptr.get()); max_pha_0_5 = max_phase / 2.0; std::cout << "[Evolve] Info: Loaded \"osc.maxphase\"="<< max_phase << std::endl; //-- Max frequency: sptr = state->getRegistry()->getEntry("osc.maxfrequency"); float max_frequency = *((float*) sptr.get()); max_freq_0_5 = max_frequency / 2.0; std::cout << "[Evolve] Info: Loaded \"osc.maxfrequency\"="<< max_frequency << std::endl; //-- Create and configure the robot parts //--------------------------------------------------------------------------------------- //-- Read test data if ( configParser.parse(config_file) != 0) { std::cerr << "[Evolve] Error: error parsing xml config file!" << std::endl; return false; } if ( configParser.getNumModules() != n_modules ) { std::cerr << "[Evolve] Error: number of modules not consitent between config file and " << "robot model." << std::endl; return false; } //-- Create robot, simulated type robotInterface = createModularRobotInterface( "simulated", configParser); //-- Create sinusoidal oscillators with the test parameters oscillators.clear(); for ( int i = 0; i < configParser.getNumModules(); i++) oscillators.push_back(new SinusoidalOscillator( 0, 0, 0, 4000)); robotInterface->reset(); return true; }
int main(int argc, char **argv) { // run for selected COCO functions for(uint function = 1; function < 25; function++) { // read XML config std::ifstream fin(argv[1]); if (!fin) { throw std::string("Error opening file! "); } std::string xmlFile, temp; while (!fin.eof()) { getline(fin, temp); xmlFile += "\n" + temp; } fin.close(); // set log and stats parameters std::string funcName = uint2str(function); std::string logName = "log", statsName = "stats"; if(function < 10) { logName += "0"; statsName += "0"; } logName += uint2str(function) + ".txt"; statsName += uint2str(function) + ".txt"; // update in XML XMLResults results; XMLNode xConfig = XMLNode::parseString(xmlFile.c_str(), "ECF", &results); XMLNode registry = xConfig.getChildNode("Registry"); XMLNode func = registry.getChildNodeWithAttribute("Entry", "key", "coco.function"); func.updateText(funcName.c_str()); XMLNode log = registry.getChildNodeWithAttribute("Entry", "key", "log.filename"); log.updateText(logName.c_str()); XMLNode stats = registry.getChildNodeWithAttribute("Entry", "key", "batch.statsfile"); stats.updateText(statsName.c_str()); // write back std::ofstream fout(argv[1]); fout << xConfig.createXMLString(true); fout.close(); // finally, run ECF on single function StateP state (new State); //set newAlg MyAlgP alg = (MyAlgP) new MyAlg; state->addAlgorithm(alg); // set the evaluation operator state->setEvalOp(new FunctionMinEvalOp); state->initialize(argc, argv); state->run(); } return 0; }