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

Ajout des RndBestFC

Browse source 
git-svn-id: svn://scm.gforge.inria.fr/svnroot/paradiseo@1795 331e1502-861f-0410-8da2-ba01fb791d7f
This commit is contained in:
verel 2010-05-06 20:15:45 +00:00
commit fde8e1e620
4 changed files with 284 additions and 3 deletions
Download patch file Download diff file Expand all files Collapse all files

165
trunk/paradiseo-mo/src/continuator/moNeighborBestStat.h Normal file
View file

@ -0,0 +1,165 @@
/*
<moNeighborBestStat.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2010
Sébastien Verel, Arnaud Liefooghe, Jérémie Humeau
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
ParadisEO WebSite : http://paradiseo.gforge.inria.fr
Contact: paradiseo-help@lists.gforge.inria.fr
*/
#ifndef moNeighborBestStat_h
#define moNeighborBestStat_h
#include <continuator/moStat.h>
#include <explorer/moNeighborhoodExplorer.h>
#include <comparator/moNeighborComparator.h>
#include <comparator/moSolNeighborComparator.h>
#include <neighborhood/moNeighborhood.h>
/**
* Compute the fitness of the best solution among k neighbor or all neighbors
*/
template< class Neighbor >
class moNeighborBestStat : public moStat<typename Neighbor::EOT, typename Neighbor::EOT::Fitness>
{
public :
typedef typename Neighbor::EOT EOT ;
typedef moNeighborhood<Neighbor> Neighborhood ;
typedef typename EOT::Fitness Fitness ;
using moStat< EOT, Fitness >::value;
/**
* Default Constructor
* @param _neighborhood a neighborhood
* @param _eval an evaluation function
* @param _neighborComparator a neighbor Comparator
* @param _solNeighborComparator a comparator between a solution and a neighbor
*/
moNeighborBestStat(Neighborhood& _neighborhood, moEval<Neighbor>& _eval, moNeighborComparator<Neighbor>& _neighborComparator, moSolNeighborComparator<Neighbor>& _solNeighborComparator, unsigned int _k = 0):
moStat<EOT, Fitness>(true, "neighborhood"),
neighborhood(_neighborhood), eval(_eval),
neighborComparator(_neighborComparator),
solNeighborComparator(_solNeighborComparator),
kmax(_k)
{}
/**
* Default Constructor
* where the comparators are basic, there only compare the fitness values
*
* @param _neighborhood a neighborhood
* @param _eval an evaluation function
*/
moNeighborBestStat(Neighborhood& _neighborhood, moEval<Neighbor>& _eval, unsigned _k = 0):
moStat<EOT, Fitness>(Fitness(), "best"),
neighborhood(_neighborhood), eval(_eval),
neighborComparator(defaultNeighborComp),
solNeighborComparator(defaultSolNeighborComp),
kmax(_k)
{}
/**
* Compute classical statistics of the first solution's neighborhood
* @param _solution the first solution
*/
virtual void init(EOT & _solution) {
operator()(_solution);
}
/**
* Compute the best fitness amoung all neighbors or k neighbors
* @param _solution the corresponding solution
*/
virtual void operator()(EOT & _solution) {
Neighbor current ;
Neighbor best ;
if (neighborhood.hasNeighbor(_solution)) {
//init the first neighbor
neighborhood.init(_solution, current);
//eval the _solution moved with the neighbor and stock the result in the neighbor
eval(_solution, current);
//initialize the best neighbor
best = current;
// number of visited neighbors
unsigned int k = 1;
//test all others neighbors
while ( ( (kmax == 0) || (k < kmax) ) && neighborhood.cont(_solution)) {
//next neighbor
neighborhood.next(_solution, current);
//eval
eval(_solution, current);
//if we found a better neighbor, update the best
if (neighborComparator(best, current))
best = current;
k++;
}
value() = best.fitness();
}
else {
//if _solution hasn't neighbor,
value() = Fitness();
}
}
/**
* @return the class name
*/
virtual std::string className(void) const {
return "moNeighborBestStat";
}
private:
// to explore the neighborhood
Neighborhood& neighborhood ;
moEval<Neighbor>& eval;
// comparator betwenn solution and neighbor or between neighbors
moNeighborComparator<Neighbor>& neighborComparator;
moSolNeighborComparator<Neighbor>& solNeighborComparator;
// default comparators
// compare the fitness values of neighbors: true is strictly greater
moNeighborComparator<Neighbor> defaultNeighborComp;
// compare the fitness values of the solution and the neighbor: true if strictly greater
moSolNeighborComparator<Neighbor> defaultSolNeighborComp;
// number of neighbor to explore
unsigned int kmax;
};
#endif

3
trunk/paradiseo-mo/src/mo.h
View file

@ -59,6 +59,7 @@
#include <continuator/moDistanceStat.h>
#include <continuator/moFitnessStat.h>
#include <continuator/moNeighborFitnessStat.h>
#include <continuator/moNeighborBestStat.h>
#include <continuator/moMaxNeighborStat.h>
#include <continuator/moMinNeighborStat.h>
#include <continuator/moNbInfNeighborStat.h>
@ -148,7 +149,9 @@
#include <sampling/moNeutralDegreeSampling.h>
#include <sampling/moFitnessCloudSampling.h>
#include <sampling/moRndRndFitnessCloudSampling.h>
#include <sampling/moRndBestFitnessCloudSampling.h>
#include <sampling/moMHRndFitnessCloudSampling.h>
#include <sampling/moMHBestFitnessCloudSampling.h>
#include <problems/bitString/moBitNeighbor.h>
#include <problems/eval/moOneMaxIncrEval.h>

111
trunk/paradiseo-mo/src/sampling/moRndBestFitnessCloudSampling.h Normal file
View file

@ -0,0 +1,111 @@
/*
<moRndBestFitnessCloudSampling.h>
Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2010
Sebastien Verel, Arnaud Liefooghe, Jeremie Humeau
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
ParadisEO WebSite : http://paradiseo.gforge.inria.fr
Contact: paradiseo-help@lists.gforge.inria.fr
*/
#ifndef moRndBestFitnessCloudSampling_h
#define moRndBestFitnessCloudSampling_h
#include <eoInit.h>
#include <neighborhood/moNeighborhood.h>
#include <eval/moEval.h>
#include <eoEvalFunc.h>
#include <algo/moRandomSearch.h>
#include <continuator/moNeighborBestStat.h>
#include <sampling/moFitnessCloudSampling.h>
/**
* To compute an estimation of the fitness cloud,
* i.e. the scatter plot of solution fitness versus neighbor fitness:
*
* Sample the fitness of random solution in the search space
* and the best fitness of k random neighbor
*
* The values are collected during the random search
*
*/
template <class Neighbor>
class moRndBestFitnessCloudSampling : public moFitnessCloudSampling<Neighbor>
{
public:
typedef typename Neighbor::EOT EOT ;
using moSampling<Neighbor>::localSearch;
using moSampling<Neighbor>::checkpoint;
using moSampling<Neighbor>::monitorVec;
using moSampling<Neighbor>::continuator;
using moFitnessCloudSampling<Neighbor>::fitnessStat;
/**
* Default Constructor
* @param _init initialisation method of the solution
* @param _neighborhood neighborhood to get one random neighbor (supposed to be random neighborhood)
* @param _fullEval Fitness function, full evaluation function
* @param _eval neighbor evaluation, incremental evaluation function
* @param _nbSol Number of solutions in the sample
*/
moRndBestFitnessCloudSampling(eoInit<EOT> & _init,
moNeighborhood<Neighbor> & _neighborhood,
eoEvalFunc<EOT>& _fullEval,
moEval<Neighbor>& _eval,
unsigned int _nbSol) :
moFitnessCloudSampling<Neighbor>(_init, _neighborhood, _fullEval, _eval, _nbSol),
neighborBestStat(_neighborhood, _eval)
{
// delete the dummy local search
delete localSearch;
// random sampling
localSearch = new moRandomSearch<Neighbor>(_init, _fullEval, _nbSol);
// delete the checkpoint with the wrong continuator
delete checkpoint;
// set the continuator
continuator = localSearch->getContinuator();
// re-construction of the checkpoint
checkpoint = new moCheckpoint<Neighbor>(*continuator);
checkpoint->add(fitnessStat);
checkpoint->add(*monitorVec[0]);
// one random neighbor
add(neighborBestStat);
}
protected:
moNeighborBestStat< Neighbor > neighborBestStat;
};
#endif

8
trunk/paradiseo-mo/tutorial/Lesson6/fitnessCloud.cpp
View file

@ -33,12 +33,13 @@ using namespace std;
//-----------------------------------------------------------------------------
// neighborhood description
#include <neighborhood/moRndWithReplNeighborhood.h> // visit one random neighbor possibly the same one several times
#include <neighborhood/moRndWithoutReplNeighborhood.h> // visit one random neighbor possibly the same one several times
//-----------------------------------------------------------------------------
// the sampling class
#include <sampling/moRndRndFitnessCloudSampling.h>
#include <sampling/moMHRndFitnessCloudSampling.h>
#include <sampling/moRndBestFitnessCloudSampling.h>
// Declaration of types
//-----------------------------------------------------------------------------
@ -150,7 +151,7 @@ void main_function(int argc, char **argv)
// Exploration of the neighborhood in random order
// at each step one bit is randomly generated
moRndWithReplNeighborhood<Neighbor> neighborhood(vecSize);
moRndWithoutReplNeighborhood<Neighbor> neighborhood(vecSize);
/* =========================================================
*
@ -166,7 +167,8 @@ void main_function(int argc, char **argv)
// - number of solutions to sample
// moRndRndFitnessCloudSampling<Neighbor> sampling(random, neighborhood, fullEval, neighborEval, nbSol);
moMHRndFitnessCloudSampling<Neighbor> sampling(random, neighborhood, fullEval, neighborEval, nbSol);
// moMHRndFitnessCloudSampling<Neighbor> sampling(random, neighborhood, fullEval, neighborEval, nbSol);
moRndBestFitnessCloudSampling<Neighbor> sampling(random, neighborhood, fullEval, neighborEval, nbSol);
/* =========================================================
*