nojhan/paradiseo
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

fix back some errors inserted by previous refactoring

Browse source 
- move PBIL classes in deprecated/, superseeded by the EDO module
This commit is contained in:
Johann Dreo 2019-12-06 15:26:21 +01:00
commit 646f20934e
17 changed files with 30 additions and 30 deletions
Download patch file Download diff file Expand all files Collapse all files

6
eo/src/eoCombinedContinue.h
View file

@ -22,8 +22,8 @@
Authors :
todos@geneura.ugr.es
Marc Schoenauer
Ram<EFBFBD>n Casero Ca<EFBFBD>as
Johann Dr<EFBFBD>o
Ramón Casero Cañas
Johann Dreo
*/
//-----------------------------------------------------------------------------
@ -40,7 +40,7 @@ Authors :
to be consistent with other Combined constructs
and allow to easily handle more than 2 continuators
02/2003 Ram<EFBFBD>n Casero Ca<EFBFBD>as - added the removeLast() method
02/2003 Ramón Casero Cañas - added the removeLast() method
@ingroup Combination
*/

2
eo/src/eoFactory.h
View file

@ -31,7 +31,7 @@
//-----------------------------------------------------------------------------
/** EO Factory. A factory is used to create other objects. In particular,
it can be used so that objects of that kind can<EFBFBD>t be created in any other
it can be used so that objects of that kind can't be created in any other
way. It should be instantiated with anything that needs a factory, like selectors
or whatever; but the instance class should be the parent class from which all the
object that are going to be created descend. This class basically defines an interface,

2
eo/src/eoObject.h
View file

@ -39,7 +39,7 @@ changed. eoObject is used to define a name (#className#)
that is used when loading or saving the state.
Previously, this object also defined a print and read
interface, but it<EFBFBD>s been moved to eoPrintable and eoPersistent.
interface, but it's been moved to eoPrintable and eoPersistent.
*/
/** Defines a name (#className#), used when loading or saving a state.

2
eo/src/eoOpSelMason.h
View file

@ -79,7 +79,7 @@ public:
_is >> rate;
if ( _is ) {
eoOp<eoClass>* op = operatorFactory.make( _is ); // This reads the rest of the line
// Add the operators to the selector, don<EFBFBD>t pay attention to the IDs
// Add the operators to the selector, don't pay attention to the IDs
opSelectorP->addOp( *op, rate );
// Keep it in the store, to destroy later
tmpPVec.push_back( op );

4
eo/src/eoPrintable.h
View file

@ -27,8 +27,8 @@
//-----------------------------------------------------------------------------
#include "iostream" // std::istream, std::ostream
#include "string" // para std::string
#include <iostream> // std::istream, std::ostream
#include <string> // para std::string
/*
This functionality was separated from eoObject, since it makes no sense to print

26
eo/src/es.h
View file

@ -36,28 +36,28 @@
//-----------------------------------------------------------------------------
// the genotypes - from plain std::vector<double> to full correlated mutation
#include "eoReal.h"
#include "eoEsSimple.h"
#include "eoEsStdev.h"
#include "eoEsFull.h"
#include "es/eoReal.h"
#include "es/eoEsSimple.h"
#include "es/eoEsStdev.h"
#include "es/eoEsFull.h"
// the initialization
#include "eoEsChromInit.h"
#include "es/eoEsChromInit.h"
// general operators
#include "eoRealOp.h"
#include "eoNormalMutation.h"
#include "eoRealAtomXover.h" // for generic operators
#include "es/eoRealOp.h"
#include "es/eoNormalMutation.h"
#include "es/eoRealAtomXover.h" // for generic operators
// SBX crossover (following Deb)
#include "eoSBXcross.h"
#include "es/eoSBXcross.h"
// ES specific operators
#include "eoEsGlobalXover.h" // Global ES Xover
#include "eoEsStandardXover.h" // 2-parents ES Xover
#include "es/eoEsGlobalXover.h" // Global ES Xover
#include "es/eoEsStandardXover.h" // 2-parents ES Xover
// the ES-mutations
#include "eoEsMutationInit.h"
#include "eoEsMutate.h"
#include "es/eoEsMutationInit.h"
#include "es/eoEsMutate.h"
#endif

2
eo/src/ga/ChangeLog
View file

@ -2,7 +2,7 @@
* all files: Change from absolute to relative include.
2007-08-21 Jochen K<EFBFBD>pper <jochen@fhi-berlin.mpg.de>
2007-08-21 Jochen Küpper <jochen@fhi-berlin.mpg.de>
* eoBitOp.h (eoNPtsBitXover::operator()): Make sure bit is within
allocated length of vector points: [0, max_size).

119
eo/src/ga/eoPBILAdditive.h
View file

@ -1,119 +0,0 @@
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
//-----------------------------------------------------------------------------
// eoPBILAdditive.h
// (c) Marc Schoenauer, Maarten Keijzer, 2001
/*
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Contact: Marc.Schoenauer@polytechnique.fr
mkeijzer@dhi.dk
*/
//-----------------------------------------------------------------------------
#ifndef _eoPBILAdditive_H
#define _eoPBILAdditive_H
#include "../eoDistribUpdater.h"
#include "eoPBILDistrib.h"
/**
* Distribution Class for PBIL algorithm
* (Population-Based Incremental Learning, Baluja and Caruana 96)
*
* This class implements an extended update rule:
* in the original paper, the authors used
*
* p(i)(t+1) = (1-LR)*p(i)(t) + LR*best(i)
*
* here the same formula is applied, with some of the best individuals
* and for some of the worst individuals (with different learning rates)
*/
template <class EOT>
class eoPBILAdditive : public eoDistribUpdater<EOT>
{
public:
/** Ctor with parameters
* using the default values is equivalent to using eoPBILOrg
*/
eoPBILAdditive(double _LRBest, unsigned _nbBest = 1,
double _tolerance=0.0,
double _LRWorst = 0.0, unsigned _nbWorst = 0 ) :
maxBound(1.0-_tolerance), minBound(_tolerance),
LR(0.0), nbBest(_nbBest), nbWorst(_nbWorst)
{
if (nbBest+nbWorst == 0)
throw std::runtime_error("Must update either from best or from worst in eoPBILAdditive");
if (_nbBest)
{
lrb = _LRBest/_nbBest;
LR += _LRBest;
}
else
lrb=0.0; // just in case
if (_nbWorst)
{
lrw = _LRWorst/_nbWorst;
LR += _LRWorst;
}
else
lrw=0.0; // just in case
}
/** Update the distribution from the current population */
virtual void operator()(eoDistribution<EOT> & _distrib, eoPop<EOT>& _pop)
{
eoPBILDistrib<EOT>& distrib = dynamic_cast<eoPBILDistrib<EOT>&>(_distrib);
std::vector<double> & p = distrib.value();
unsigned i, popSize=_pop.size();
std::vector<const EOT*> result;
_pop.sort(result); // is it necessary to sort the whole population?
// but I'm soooooooo lazy !!!
for (unsigned g=0; g<distrib.size(); g++)
{
p[g] *= (1-LR); // relaxation
if (nbBest) // update from some of the best
for (i=0; i<nbBest; i++)
{
const EOT & best = (*result[i]);
if ( best[g] ) // if 1, increase proba
p[g] += lrb;
}
if (nbWorst)
for (i=popSize-1; i>=popSize-nbWorst; i--)
{
const EOT & best = (*result[i]);
if ( !best[g] ) // if 0, increase proba
p[g] += lrw;
}
// stay in [0,1] (possibly strictly due to tolerance)
p[g] = std::min(maxBound, p[g]);
p[g] = std::max(minBound, p[g]);
}
}
private:
double maxBound, minBound; // proba stay away from 0 and 1 by at least tolerance
double LR; // learning rate
unsigned nbBest; // number of Best individuals used for update
unsigned nbWorst; // number of Worse individuals used for update
double lrb, lrw; // "local" learning rates (see operator())
};
#endif

100
eo/src/ga/eoPBILDistrib.h
View file

@ -1,100 +0,0 @@
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
//-----------------------------------------------------------------------------
// eoPBILDistrib.h
// (c) Marc Schoenauer, 2001
/*
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Contact: Marc.Schoenauer@inria.fr
*/
//-----------------------------------------------------------------------------
#ifndef _eoPBILDistrib_H
#define _eoPBILDistrib_H
#include "../eoDistribution.h"
/**
* Distribution Class for PBIL algorithm
* (Population-Based Incremental Learning, Baluja and Caruana 96)
*
* It encodes a univariate distribution on the space of bitstrings,
* i.e. one probability for each bit to be one
*
* It is an eoValueParam<std::vector<double> > :
* the std::vector<double> stores the probabilities that each bit is 1
*
* It is still pure virtual, as the update method needs to be specified
*/
template <class EOT>
class eoPBILDistrib : public eoDistribution<EOT>,
public eoValueParam<std::vector<double> >
{
public:
/** Ctor with size of genomes, and update parameters */
eoPBILDistrib(unsigned _genomeSize) :
eoDistribution<EOT>(),
eoValueParam<std::vector<double> >(std::vector<double>(_genomeSize, 0.5), "Distribution"),
genomeSize(_genomeSize)
{}
/** the randomizer of indis */
virtual void operator()(EOT & _eo)
{
_eo.resize(genomeSize); // just in case
for (unsigned i=0; i<genomeSize; i++)
_eo[i] = eo::rng.flip(value()[i]);
_eo.invalidate(); // DO NOT FORGET!!!
}
/** Accessor to the genome size */
unsigned Size() {return genomeSize;}
/** printing... */
virtual void printOn(std::ostream& os) const
{
os << value().size() << ' ';
for (unsigned i=0; i<value().size(); i++)
os << value()[i] << ' ';
}
/** reading...*/
virtual void readFrom(std::istream& is)
{
unsigned sz;
is >> sz;
value().resize(sz);
unsigned i;
for (i = 0; i < sz; ++i)
{
double atom;
is >> atom;
value()[i] = atom;
}
}
unsigned int size() {return genomeSize;}
virtual std::string className() const {return "eoPBILDistrib";};
private:
unsigned genomeSize; // size of indis
};
#endif

78
eo/src/ga/eoPBILOrg.h
View file

@ -1,78 +0,0 @@
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
//-----------------------------------------------------------------------------
// eoPBILOrg.h
// (c) Marc Schoenauer, Maarten Keijzer, 2001
/*
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Contact: Marc.Schoenauer@polytechnique.fr
mkeijzer@dhi.dk
*/
//-----------------------------------------------------------------------------
#ifndef _eoPBILOrg_H
#define _eoPBILOrg_H
#include "eoDistribUpdater.h"
#include "../eoPBILDistrib.h"
/**
* Distribution Class for PBIL algorithm
* (Population-Based Incremental Learning, Baluja and Caruana 95)
*
* This class implements the update rule from the original paper:
*
* p(i)(t+1) = (1-LR)*p(i)(t) + LR*best(i)
*/
template <class EOT>
class eoPBILOrg : public eoDistribUpdater<EOT>
{
public:
/** Ctor with size of genomes, and update parameters */
eoPBILOrg(double _LR, double _tolerance=0.0 ) :
LR(_LR), maxBound(1.0-_tolerance), minBound(_tolerance)
{}
/** Update the distribution from the current population */
virtual void operator()(eoDistribution<EOT> & _distrib, eoPop<EOT>& _pop)
{
const EOT & best = _pop.best_element();
eoPBILDistrib<EOT>& distrib = dynamic_cast<eoPBILDistrib<EOT>&>(_distrib);
std::vector<double> & p = distrib.value();
for (unsigned g=0; g<distrib.size(); g++)
{
// double & r = value()[g];
p[g] *= (1-LR);
if ( best[g] )
p[g] += LR;
// else nothing
// stay away from 0 and 1
p[g] = std::min(maxBound, p[g]);
p[g] = std::max(minBound, p[g]);
}
}
private:
double LR; // learning rate for best guys
double maxBound, minBound; // proba stay away from 0 and 1 by at least tolerance
};
#endif