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

119
deprecated/eo/es/eoPBILAdditive.h Normal file
View file

@ -0,0 +1,119 @@
// -*- 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
deprecated/eo/es/eoPBILDistrib.h Normal file
View file

@ -0,0 +1,100 @@
// -*- 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
deprecated/eo/es/eoPBILOrg.h Normal file
View file

@ -0,0 +1,78 @@
// -*- 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

148
deprecated/eo/es/t-eoPBIL.cpp Normal file
View file

@ -0,0 +1,148 @@
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
//-----------------------------------------------------------------------------
// t-eoPBIL.cpp
// (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
*/
//-----------------------------------------------------------------------------
/** test program for PBIL algorithm */
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <iostream>
#include <eo>
#include <ga/make_ga.h>
#include "binary_value.h"
#include <apply.h>
#include <ga/eoPBILDistrib.h>
#include <ga/eoPBILOrg.h>
#include <ga/eoPBILAdditive.h>
#include <eoSimpleEDA.h>
using namespace std;
typedef eoBit<double> Indi;
// instanciating the outside subroutine that creates the distribution
#include "ga/make_PBILdistrib.h"
eoPBILDistrib<Indi> & make_PBILdistrib(eoParser& _parser, eoState&_state, Indi _eo)
{
return do_make_PBILdistrib(_parser, _state, _eo);
}
// instanciating the outside subroutine that creates the update rule
#include "ga/make_PBILupdate.h"
eoDistribUpdater<Indi> & make_PBILupdate(eoParser& _parser, eoState&_state, Indi _eo)
{
return do_make_PBILupdate(_parser, _state, _eo);
}
int main(int argc, char* argv[])
{
try
{
eoParser parser(argc, argv); // for user-parameter reading
eoState state; // keeps all things allocated
///// FIRST, problem or representation dependent stuff
//////////////////////////////////////////////////////
// The evaluation fn - encapsulated into an eval counter for output
eoEvalFuncPtr<Indi, double> mainEval( binary_value<Indi>);
eoEvalFuncCounter<Indi> eval(mainEval);
// Construction of the distribution
eoPBILDistrib<Indi> & distrib = make_PBILdistrib(parser, state, Indi());
// and the update rule
eoDistribUpdater<Indi> & update = make_PBILupdate(parser, state, Indi());
//// Now the representation-independent things
//////////////////////////////////////////////
// stopping criteria
eoContinue<Indi> & term = make_continue(parser, state, eval);
// output
eoCheckPoint<Indi> & checkpoint = make_checkpoint(parser, state, eval, term);
// add a graphical output for the distribution
// first, get the direname from the parser
// it has been enetered in make_checkoint
eoParam* ptParam = parser.getParamWithLongName(string("resDir"));
eoValueParam<string>* ptDirNameParam = dynamic_cast<eoValueParam<string>*>(ptParam);
if (!ptDirNameParam) // not found
throw runtime_error("Parameter resDir not found where it was supposed to be");
// now create the snapshot monitor
eoValueParam<bool>& plotDistribParam = parser.getORcreateParam(false, "plotDistrib",
"Plot Distribution", '\0',
"Output - Graphical");
if (plotDistribParam.value())
{
#ifdef HAVE_GNUPLOT
unsigned frequency=1; // frequency of plots updates
eoGnuplot1DSnapshot *distribSnapshot = new eoGnuplot1DSnapshot(ptDirNameParam->value(),
frequency, "distrib");
state.storeFunctor(distribSnapshot);
// add the distribution (it is an eoValueParam<vector<double> >)
distribSnapshot->add(distrib);
// and of course add it to the checkpoint
checkpoint.add(*distribSnapshot);
#endif
}
// the algorithm: EDA
// don't know where else to put the population size!
unsigned popSize = parser.getORcreateParam(unsigned(100), "popSize",
"Population Size", 'P', "Algorithm").value();
eoSimpleEDA<Indi> eda(update, eval, popSize, checkpoint);
///// End of construction of the algorith
/////////////////////////////////////////
// to be called AFTER all parameters have been read!!!
make_help(parser);
//// GO
///////
eda(distrib); // run the eda
std::cout << "Final Distribution\n";
distrib.printOn(std::cout);
std::cout << std::endl;
// wait - for graphical output
if (plotDistribParam.value())
{
string foo;
cin >> foo;
}
}
catch(std::exception& e)
{
std::cout << e.what() << std::endl;
}
}