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

update and new stuffs

Browse source 
git-svn-id: svn://scm.gforge.inria.fr/svnroot/paradiseo@203 331e1502-861f-0410-8da2-ba01fb791d7f
This commit is contained in:
liefooga 2007-03-14 16:33:28 +00:00
commit 8f5ccd0d12
9 changed files with 158 additions and 239 deletions
Download patch file Download diff file Expand all files Collapse all files

4
branches/paradiseo-moeo-1.0/src/MOEO.h
View file

@ -115,7 +115,7 @@ public:
{ {
if ( invalidFitness() ) if ( invalidFitness() )
{ {
throw std::runtime_error("invalid fitness"); // throw std::runtime_error("invalid fitness");
} }
return fitnessValue; return fitnessValue;
} }
@ -157,7 +157,7 @@ public:
{ {
if ( invalidDiversity() ) if ( invalidDiversity() )
{ {
throw std::runtime_error("invalid diversity"); // throw std::runtime_error("invalid diversity");
} }
return diversityValue; return diversityValue;
} }

14
branches/paradiseo-moeo-1.0/src/do/make_algo.h
View file

@ -29,11 +29,14 @@
#include <moeoFastNonDominatedSortingFitnessAssignment.h> #include <moeoFastNonDominatedSortingFitnessAssignment.h>
#include <moeoFitnessAssignment.h> #include <moeoFitnessAssignment.h>
#include <moeoGenerationalReplacement.h> #include <moeoGenerationalReplacement.h>
#include <moeoIndicatorBasedFitnessAssignment.h>
#include <moeoRandomSelect.h> #include <moeoRandomSelect.h>
#include <moeoReplacement.h> #include <moeoReplacement.h>
#include <moeoRouletteSelect.h> #include <moeoRouletteSelect.h>
#include <moeoSelectOne.h> #include <moeoSelectOne.h>
#include <moeoStochTournamentSelect.h> #include <moeoStochTournamentSelect.h>
#include <metric/moeoNormalizedSolutionVsSolutionBinaryMetric.h>
#include <metric/moeoVectorVsSolutionBinaryMetric.h>
/** /**
* ... * ...
@ -49,12 +52,21 @@ eoAlgo < MOEOT > & do_make_algo(eoParser & _parser, eoState & _state, eoEvalFunc
/* the fitness assignment strategy */ /* the fitness assignment strategy */
string & fitnessParam = _parser.createParam(string("FastNonDominatedSorting"), "fitness", string & fitnessParam = _parser.createParam(string("FastNonDominatedSorting"), "fitness",
"Fitness assignment strategy parameter: FastNonDominatedSorting, ...", 'F', "Evolution Engine").value(); "Fitness assignment strategy parameter: FastNonDominatedSorting, IndicatorBased...", 'F', "Evolution Engine").value();
moeoFitnessAssignment < MOEOT > * fitnessAssignment; moeoFitnessAssignment < MOEOT > * fitnessAssignment;
if (fitnessParam == string("FastNonDominatedSorting")) if (fitnessParam == string("FastNonDominatedSorting"))
{ {
fitnessAssignment = new moeoFastNonDominatedSortingFitnessAssignment < MOEOT> (); fitnessAssignment = new moeoFastNonDominatedSortingFitnessAssignment < MOEOT> ();
} }
/****************************************************************************************************************************/
else if (fitnessParam == string("IndicatorBased"))
{
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
moeoAdditiveEpsilonBinaryMetric < ObjectiveVector > * e = new moeoAdditiveEpsilonBinaryMetric < ObjectiveVector >;
moeoVectorVsSolutionBinaryMetric < ObjectiveVector, double > * metric = new moeoExponentialVectorVsSolutionBinaryMetric < ObjectiveVector> (e,0.001);
fitnessAssignment = new moeoIndicatorBasedFitnessAssignment < MOEOT> (metric);
}
/****************************************************************************************************************************/
else else
{ {
string stmp = string("Invalid fitness assignment strategy: ") + fitnessParam; string stmp = string("Invalid fitness assignment strategy: ") + fitnessParam;

84
branches/paradiseo-moeo-1.0/src/metric/moeoAdditiveEpsilonBinaryMetric.h
View file

@ -1,84 +0,0 @@
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
//-----------------------------------------------------------------------------
// moeoAdditiveEpsilonBinaryMetric.h
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
/*
This library...
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
*/
//-----------------------------------------------------------------------------
#ifndef MOEOADDITIVEEPSILONBINARYMETRIC_H_
#define MOEOADDITIVEEPSILONBINARYMETRIC_H_
#include <metric/moeoMetric.h>
/**
* Additive epsilon binary metric allowing to compare two objective vectors as proposed in
* Zitzler E., Thiele L., Laumanns M., Fonseca C. M., Grunert da Fonseca V.:
* Performance Assessment of Multiobjective Optimizers: An Analysis and Review. IEEE Transactions on Evolutionary Computation 7(2), pp.117–132 (2003).
*/
template < class ObjectiveVector >
class moeoAdditiveEpsilonBinaryMetric : public moeoNormalizedSolutionVsSolutionBinaryMetric < ObjectiveVector, double >
{
public:
/**
* Returns the maximum epsilon value by which the objective vector _o1 must be translated in all objectives
* so that it weakly dominates the objective vector _o2
* @warning don't forget to set the bounds for every objective before the call of this function
* @param _o1 the first objective vector
* @param _o2 the second objective vector
*/
double operator()(const ObjectiveVector & _o1, const ObjectiveVector & _o2)
{
// computation of the epsilon value for the first objective
double result = epsilon(_o1, _o2, 0);
// computation of the epsilon value for the other objectives
double tmp;
for (unsigned i=1; i<ObjectiveVector::Traits::nObjectives(); i++)
{
tmp = epsilon(_o1, _o2, i);
result = std::max(result, tmp);
}
// returns the maximum epsilon value
return result;
}
private:
/** the bounds for every objective */
using moeoNormalizedSolutionVsSolutionBinaryMetric < ObjectiveVector, double > :: bounds;
/**
* Returns the epsilon value by which the objective vector _o1 must be translated in the objective _obj
* so that it dominates the objective vector _o2
* @param _o1 the first objective vector
* @param _o2 the second objective vector
* @param _obj the index of the objective
*/
double epsilon(const ObjectiveVector & _o1, const ObjectiveVector & _o2, const unsigned _obj)
{
double result;
// if the objective _obj have to be minimized
if (ObjectiveVector::Traits::minimizing(_obj))
{
// _o1[_obj] - _o2[_obj]
result = ( (_o1[_obj] - bounds[_obj].minimum()) / bounds[_obj].range() ) - ( (_o2[_obj] - bounds[_obj].minimum()) / bounds[_obj].range() );
}
// if the objective _obj have to be maximized
else
{
// _o2[_obj] - _o1[_obj]
result = ( (_o2[_obj] - bounds[_obj].minimum()) / bounds[_obj].range() ) - ( (_o1[_obj] - bounds[_obj].minimum()) / bounds[_obj].range() );
}
return result;
}
};
#endif /*MOEOADDITIVEEPSILONBINARYMETRIC_H_*/

139
branches/paradiseo-moeo-1.0/src/metric/moeoHypervolumeBinaryMetric.h
View file

@ -1,139 +0,0 @@
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
//-----------------------------------------------------------------------------
// moeoHypervolumeBinaryMetric.h
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
/*
This library...
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
*/
//-----------------------------------------------------------------------------
#ifndef MOEOHYPERVOLUMEBINARYMETRIC_H_
#define MOEOHYPERVOLUMEBINARYMETRIC_H_
#include <stdexcept>
#include <metric/moeoMetric.h>
/**
* Hypervolume binary metric allowing to compare two objective vectors as proposed in
* Zitzler E., Künzli S.: Indicator-Based Selection in Multiobjective Search. In Parallel Problem Solving from Nature (PPSN VIII).
* Lecture Notes in Computer Science 3242, Springer, Birmingham, UK pp.832–842 (2004).
* This indicator is based on the hypervolume concept introduced in
* Zitzler, E., Thiele, L.: Multiobjective Optimization Using Evolutionary Algorithms - A Comparative Case Study.
* Parallel Problem Solving from Nature (PPSN-V), pp.292-301 (1998).
*/
template < class ObjectiveVector >
class moeoHypervolumeBinaryMetric : public moeoNormalizedSolutionVsSolutionBinaryMetric < ObjectiveVector, double >
{
public:
/**
* Ctor
* @param _rho value used to compute the reference point from the worst values for each objective (default : 1.1)
*/
moeoHypervolumeBinaryMetric(double _rho = 1.1) : rho(_rho)
{
// not-a-maximization problem check
for (unsigned i=0; i<ObjectiveVector::Traits::nObjectives(); i++)
{
if (ObjectiveVector::Traits::maximizing(i))
{
throw std::runtime_error("Hypervolume binary metric not yet implemented for a maximization problem in moeoHypervolumeBinaryMetric");
}
}
// consistency check
if (rho < 1)
{
cout << "Warning, value used to compute the reference point rho for the hypervolume calculation must not be smaller than 1" << endl;
cout << "Adjusted to 1" << endl;
rho = 1;
}
}
/**
* Returns the volume of the space that is dominated by _o2 but not by _o1 with respect to a reference point computed using rho.
* @warning don't forget to set the bounds for every objective before the call of this function
* @param _o1 the first objective vector
* @param _o2 the second objective vector
*/
double operator()(const ObjectiveVector & _o1, const ObjectiveVector & _o2)
{
double result;
// if _o1 dominates _o2
if ( paretoComparator(_o1,_o2) )
{
result = - hypervolume(_o1, _o2, ObjectiveVector::Traits::nObjectives()-1);
}
else
{
result = hypervolume(_o2, _o1, ObjectiveVector::Traits::nObjectives()-1);
}
return result;
}
private:
/** value used to compute the reference point from the worst values for each objective */
double rho;
/** the bounds for every objective */
using moeoNormalizedSolutionVsSolutionBinaryMetric < ObjectiveVector, double > :: bounds;
/** Functor to compare two objective vectors according to Pareto dominance relation */
moeoParetoObjectiveVectorComparator < ObjectiveVector > paretoComparator;
/**
* Returns the volume of the space that is dominated by _o2 but not by _o1 with respect to a reference point computed using rho for the objective _obj.
* @param _o1 the first objective vector
* @param _o2 the second objective vector
* @param _obj the objective index
* @param _flag used for iteration, if _flag=true _o2 is not talen into account (default : false)
*/
double hypervolume(const ObjectiveVector & _o1, const ObjectiveVector & _o2, const unsigned _obj, const bool _flag = false)
{
double result;
double range = rho * bounds[_obj].range();
double max = bounds[_obj].minimum() + range;
// value of _1 for the objective _obj
double v1 = _o1[_obj];
// value of _2 for the objective _obj (if _flag=true, v2=max)
double v2;
if (_flag)
{
v2 = max;
}
else
{
v2 = _o2[_obj];
}
// computation of the volume
if (_obj == 0)
{
if (v1 < v2)
{
result = (v2 - v1) / range;
}
else
{
result = 0;
}
}
else
{
if (v1 < v2)
{
result = ( hypervolume(_o1, _o2, _obj-1, true) * (v2 - v1) / range ) + ( hypervolume(_o1, _o2, _obj-1) * (max - v2) / range );
}
else
{
result = hypervolume(_o1, _o2, _obj-1) * (max - v2) / range;
}
}
return result;
}
};
#endif /*MOEOHYPERVOLUMEBINARYMETRIC_H_*/

42
branches/paradiseo-moeo-1.0/src/moeoConvertPopToObjectiveVectors.h Normal file
View file

@ -0,0 +1,42 @@
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
//-----------------------------------------------------------------------------
// moeoConvertPopToObjectiveVectors.h
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
/*
This library...
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
*/
//-----------------------------------------------------------------------------
#ifndef MOEOPOPTOOBJECTIVEVECTORS_H_
#define MOEOPOPTOOBJECTIVEVECTORS_H_
#include <eoFunctor.h>
/**
* Functor allowing to get a vector of objective vectors from a population
*/
template < class MOEOT, class ObjectiveVector = typename MOEOT::ObjectiveVector >
class moeoConvertPopToObjectiveVectors : public eoUF < const eoPop < MOEOT >, const std::vector < ObjectiveVector > >
{
public:
/**
* Returns a vector of the objective vectors from the population _pop
* @param _pop the population
*/
const std::vector < ObjectiveVector > operator()(const eoPop < MOEOT > _pop)
{
std::vector < ObjectiveVector > result;
result.resize(_pop.size());
for (unsigned i=0; i<_pop.size(); i++)
{
result.push_back(_pop[i].objectiveVector());
}
return result;
}
};
#endif /*MOEOPOPTOOBJECTIVEVECTORS_H_*/

10
branches/paradiseo-moeo-1.0/src/moeoDetTournamentSelect.h
View file

@ -13,6 +13,9 @@
#ifndef MOEODETTOURNAMENTSELECT_H_ #ifndef MOEODETTOURNAMENTSELECT_H_
#define MOEODETTOURNAMENTSELECT_H_ #define MOEODETTOURNAMENTSELECT_H_
#include <moeoComparator.h>
#include <moeoDiversityAssignment.h>
#include <moeoFitnessAssignment.h>
#include <moeoSelectOne.h> #include <moeoSelectOne.h>
#include <moeoSelectors.h> #include <moeoSelectors.h>
@ -113,12 +116,13 @@ public:
* Evaluate the fitness and the diversity of each individual of the population _pop. * Evaluate the fitness and the diversity of each individual of the population _pop.
* @param _pop the population * @param _pop the population
*/ */
void setup (eoPop<MOEOT>& _pop) //void setup (eoPop<MOEOT>& _pop)
virtual void setup(const eoPop<MOEOT>& _pop)
{ {
// eval fitness // eval fitness
evalFitness(_pop); //evalFitness(_pop);
// eval diversity // eval diversity
evalDiversity(_pop); //evalDiversity(_pop);
} }

9
branches/paradiseo-moeo-1.0/src/moeoDiversityAssignment.h
View file

@ -25,7 +25,7 @@ class moeoDiversityAssignment : public eoUF < eoPop < MOEOT > &, void >
/** /**
* moeoDummyDiversityAssignment is a moeoDiversityAssignment that gives the value '0' as the individual's diversity for a whole population. * moeoDummyDiversityAssignment is a moeoDiversityAssignment that gives the value '0' as the individual's diversity for a whole population if it is invalid.
*/ */
template < class MOEOT > template < class MOEOT >
class moeoDummyDiversityAssignment : public moeoDiversityAssignment < MOEOT > class moeoDummyDiversityAssignment : public moeoDiversityAssignment < MOEOT >
@ -33,15 +33,18 @@ class moeoDummyDiversityAssignment : public moeoDiversityAssignment < MOEOT >
public: public:
/** /**
* Sets the diversity to '0' for every individuals of the population _pop * Sets the diversity to '0' for every individuals of the population _pop if it is invalid
* @param _pop the population * @param _pop the population
*/ */
void operator () (eoPop < MOEOT > & _pop) void operator () (eoPop < MOEOT > & _pop)
{ {
for (unsigned idx = 0; idx<_pop.size (); idx++) for (unsigned idx = 0; idx<_pop.size (); idx++)
{
if (_pop[idx].invalidDiversity())
{ {
// set the diversity to 0 // set the diversity to 0
_pop[idx].diversity(0); _pop[idx].diversity(0.0);
}
} }
} }

7
branches/paradiseo-moeo-1.0/src/moeoElitistReplacement.h
View file

@ -93,7 +93,12 @@ public:
evalFitness (_parents); evalFitness (_parents);
evalDiversity (_parents); evalDiversity (_parents);
// sorts the whole population according to the comparator // sorts the whole population according to the comparator
std::sort (_parents.begin (), _parents.end (), comparator);
/*************************************************************************/
moeoFitnessThenDiversityComparator < MOEOT > comp;
std::sort (_parents.begin (), _parents.end (), comp);
/*************************************************************************/
// finally, resize this global population // finally, resize this global population
_parents.resize (sz); _parents.resize (sz);
// and clear the offspring population // and clear the offspring population

76
branches/paradiseo-moeo-1.0/src/moeoIndicatorBasedFitnessAssignment.h Normal file
View file

@ -0,0 +1,76 @@
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
//-----------------------------------------------------------------------------
// moeoIndicatorBasedFitnessAssignment.h
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
/*
This library...
Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
*/
//-----------------------------------------------------------------------------
#ifndef MOEOINDICATORBASEDFITNESSASSIGNMENT_H_
#define MOEOINDICATORBASEDFITNESSASSIGNMENT_H_
#include <eoPop.h>
#include <moeoConvertPopToObjectiveVectors.h>
#include <moeoFitnessAssignment.h>
#include <metric/moeoNormalizedSolutionVsSolutionBinaryMetric.h>
#include <metric/moeoVectorVsSolutionBinaryMetric.h>
/**
*
*/
template < class MOEOT >
class moeoIndicatorBasedFitnessAssignment : public moeoFitnessAssignment < MOEOT >
{
public:
/** The type of objective vector */
typedef typename MOEOT::ObjectiveVector ObjectiveVector;
/**
* Default ctor
* @param ...
*/
moeoIndicatorBasedFitnessAssignment(moeoVectorVsSolutionBinaryMetric < ObjectiveVector, double > * _metric) : metric(_metric)
{}
/**
* Ctor
* @param ...
*/
moeoIndicatorBasedFitnessAssignment(moeoNormalizedSolutionVsSolutionBinaryMetric < ObjectiveVector, double > * _solutionVsSolutionMetric, const double _kappa)// : metric(moeoExponentialVectorVsSolutionBinaryMetric < ObjectiveVector > (_solutionVsSolutionMetric, _kappa))
{
metric = new moeoExponentialVectorVsSolutionBinaryMetric < ObjectiveVector > (_solutionVsSolutionMetric, _kappa);
}
/**
*
*/
void operator()(eoPop < MOEOT > & _pop)
{
eoPop < MOEOT > tmp_pop;
moeoConvertPopToObjectiveVectors < MOEOT > convertor;
for (unsigned i=0; i<_pop.size() ; i++)
{
tmp_pop.clear();
tmp_pop = _pop;
tmp_pop.erase(tmp_pop.begin() + i);
_pop[i].fitness((*metric) (convertor(tmp_pop), _pop[i].objectiveVector()));
}
}
private:
moeoVectorVsSolutionBinaryMetric < ObjectiveVector, double > * metric;
};
#endif /*MOEOINDICATORBASEDFITNESSASSIGNMENT_H_*/