From fa3e31eca7cb3a9a392a0d166de7a3b6aef31b15 Mon Sep 17 00:00:00 2001 From: liefooga Date: Tue, 17 Apr 2007 15:47:54 +0000 Subject: [PATCH] update do git-svn-id: svn://scm.gforge.inria.fr/svnroot/paradiseo@265 331e1502-861f-0410-8da2-ba01fb791d7f --- .../src/do/make_checkpoint_moeo.h | 176 +++++++++++++ .../src/do/make_continue_moeo.h | 106 ++++++++ trunk/paradiseo-moeo/src/do/make_ea_moeo.h | 240 ++++++++++++++++++ 3 files changed, 522 insertions(+) create mode 100755 trunk/paradiseo-moeo/src/do/make_checkpoint_moeo.h create mode 100755 trunk/paradiseo-moeo/src/do/make_continue_moeo.h create mode 100755 trunk/paradiseo-moeo/src/do/make_ea_moeo.h diff --git a/trunk/paradiseo-moeo/src/do/make_checkpoint_moeo.h b/trunk/paradiseo-moeo/src/do/make_checkpoint_moeo.h new file mode 100755 index 000000000..65957e51f --- /dev/null +++ b/trunk/paradiseo-moeo/src/do/make_checkpoint_moeo.h @@ -0,0 +1,176 @@ +// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- + +//----------------------------------------------------------------------------- +// make_checkpoint_moeo.h +// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007 +/* + This library... + + Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr + */ +//----------------------------------------------------------------------------- + +#ifndef MAKE_CHECKPOINT_MOEO_H_ +#define MAKE_CHECKPOINT_MOEO_H_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +bool testDirRes(std::string _dirName, bool _erase); + +/** + * This functions allows to build an eoCheckPoint for multi-objective optimization from the parser (partly taken from make_checkpoint_pareto.h) + * @param _parser the parser + * @param _state to store allocated objects + * @param _eval the funtions evaluator + * @param _continue the stopping crietria + * @param _pop the population + * @param _archive the archive of non-dominated solutions + */ +template < class MOEOT > +eoCheckPoint < MOEOT > & do_make_checkpoint_moeo (eoParser & _parser, eoState & _state, eoEvalFuncCounter < MOEOT > & _eval, eoContinue < MOEOT > & _continue, eoPop < MOEOT > & _pop, moeoArchive < MOEOT > & _archive) +{ + eoCheckPoint < MOEOT > & checkpoint = _state.storeFunctor(new eoCheckPoint < MOEOT > (_continue)); + /* the objective vector type */ + typedef typename MOEOT::ObjectiveVector ObjectiveVector; + + /////////////////// + // Counters + ////////////////// + // is nb Eval to be used as counter? + //bool useEval = _parser.getORcreateParam(true, "useEval", "Use nb of eval. as counter (vs nb of gen.)", '\0', "Output").value(); + // Create anyway a generation-counter parameter + eoValueParam *generationCounter = new eoValueParam(0, "Gen."); + // Create an incrementor (sub-class of eoUpdater). + eoIncrementor & increment = _state.storeFunctor( new eoIncrementor(generationCounter->value()) ); + // Add it to the checkpoint + checkpoint.add(increment); + // dir for DISK output + std::string & dirName = _parser.getORcreateParam(std::string("Res"), "resDir", "Directory to store DISK outputs", '\0', "Output").value(); + // shoudl we empty it if exists + eoValueParam& eraseParam = _parser.getORcreateParam(true, "eraseDir", "erase files in dirName if any", '\0', "Output"); + bool dirOK = false; // not tested yet + + // Dump of the whole population + //----------------------------- + bool printPop = _parser.getORcreateParam(false, "printPop", "Print sorted pop. every gen.", '\0', "Output").value(); + eoSortedPopStat * popStat; + if ( printPop ) // we do want pop dump + { + popStat = & _state.storeFunctor(new eoSortedPopStat); + checkpoint.add(*popStat); + } + + ////////////////////////////////// + // State savers + ////////////////////////////// + // feed the state to state savers + // save state every N generation + eoValueParam& saveFrequencyParam = _parser.createParam(unsigned(0), "saveFrequency", "Save every F generation (0 = only final state, absent = never)", '\0', "Persistence" ); + if (_parser.isItThere(saveFrequencyParam)) + { + // first make sure dirName is OK + if (! dirOK ) + dirOK = testDirRes(dirName, eraseParam.value()); // TRUE + unsigned freq = (saveFrequencyParam.value()>0 ? saveFrequencyParam.value() : UINT_MAX ); +#ifdef _MSVC + std::string stmp = dirName + "\generations"; +#else + std::string stmp = dirName + "/generations"; +#endif + eoCountedStateSaver *stateSaver1 = new eoCountedStateSaver(freq, _state, stmp); + _state.storeFunctor(stateSaver1); + checkpoint.add(*stateSaver1); + } + // save state every T seconds + eoValueParam& saveTimeIntervalParam = _parser.getORcreateParam(unsigned(0), "saveTimeInterval", "Save every T seconds (0 or absent = never)", '\0',"Persistence" ); + if (_parser.isItThere(saveTimeIntervalParam) && saveTimeIntervalParam.value()>0) + { + // first make sure dirName is OK + if (! dirOK ) + dirOK = testDirRes(dirName, eraseParam.value()); // TRUE +#ifdef _MSVC + std::string stmp = dirName + "\time"; +#else + std::string stmp = dirName + "/time"; +#endif + eoTimedStateSaver *stateSaver2 = new eoTimedStateSaver(saveTimeIntervalParam.value(), _state, stmp); + _state.storeFunctor(stateSaver2); + checkpoint.add(*stateSaver2); + } + + /////////////////// + // Archive + ////////////////// + // update the archive every generation + bool updateArch = _parser.getORcreateParam(true, "updateArch", "Update the archive at each gen.", '\0', "Evolution Engine").value(); + if (updateArch) + { + moeoArchiveUpdater < MOEOT > * updater = new moeoArchiveUpdater < MOEOT > (_archive, _pop); + _state.storeFunctor(updater); + checkpoint.add(*updater); + } + // store the objective vectors contained in the archive every generation + bool storeArch = _parser.getORcreateParam(false, "storeArch", "Store the archive's objective vectors at each gen.", '\0', "Output").value(); + if (storeArch) + { + if (! dirOK ) + dirOK = testDirRes(dirName, eraseParam.value()); // TRUE +#ifdef _MSVC + std::string stmp = dirName + "\arch"; +#else + std::string stmp = dirName + "/arch"; +#endif + moeoArchiveObjectiveVectorSavingUpdater < MOEOT > * save_updater = new moeoArchiveObjectiveVectorSavingUpdater < MOEOT > (_archive, stmp); + _state.storeFunctor(save_updater); + checkpoint.add(*save_updater); + } + // store the contribution of the non-dominated solutions + bool cont = _parser.getORcreateParam(false, "contribution", "Store the contribution of the archive at each gen.", '\0', "Output").value(); + if (cont) + { + if (! dirOK ) + dirOK = testDirRes(dirName, eraseParam.value()); // TRUE +#ifdef _MSVC + std::string stmp = dirName + "\contribution"; +#else + std::string stmp = dirName + "/contribution"; +#endif + moeoContributionMetric < ObjectiveVector > * contribution = new moeoContributionMetric < ObjectiveVector >; + moeoBinaryMetricSavingUpdater < MOEOT > * contribution_updater = new moeoBinaryMetricSavingUpdater < MOEOT > (*contribution, _archive, stmp); + _state.storeFunctor(contribution_updater); + checkpoint.add(*contribution_updater); + } + // store the entropy of the non-dominated solutions + bool ent = _parser.getORcreateParam(false, "entropy", "Store the entropy of the archive at each gen.", '\0', "Output").value(); + if (ent) + { + if (! dirOK ) + dirOK = testDirRes(dirName, eraseParam.value()); // TRUE +#ifdef _MSVC + std::string stmp = dirName + "\entropy"; +#else + std::string stmp = dirName + "/entropy"; +#endif + moeoEntropyMetric < ObjectiveVector > * entropy = new moeoEntropyMetric < ObjectiveVector >; + moeoBinaryMetricSavingUpdater < MOEOT > * entropy_updater = new moeoBinaryMetricSavingUpdater < MOEOT > (*entropy, _archive, stmp); + _state.storeFunctor(entropy_updater); + checkpoint.add(*entropy_updater); + } + + // and that's it for the (control and) output + return checkpoint; +} + +#endif /*MAKE_CHECKPOINT_MOEO_H_*/ diff --git a/trunk/paradiseo-moeo/src/do/make_continue_moeo.h b/trunk/paradiseo-moeo/src/do/make_continue_moeo.h new file mode 100755 index 000000000..5000c3b0c --- /dev/null +++ b/trunk/paradiseo-moeo/src/do/make_continue_moeo.h @@ -0,0 +1,106 @@ +// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- + +//----------------------------------------------------------------------------- +// make_continue_moeo.h +// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007 +/* + This library... + + Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr + */ +//----------------------------------------------------------------------------- + +#ifndef MAKE_CONTINUE_MOEO_H_ +#define MAKE_CONTINUE_MOEO_H_ + +#include +#include +#include +#include +#include +#ifndef _MSC_VER +#include +#endif +#include +#include + + +/** + * Helper function + * @param _combined the eoCombinedContinue object + * @param _cont the eoContinue to add + */ +template +eoCombinedContinue * make_combinedContinue(eoCombinedContinue *_combined, eoContinue *_cont) +{ + if (_combined) // already exists + _combined->add(*_cont); + else + _combined = new eoCombinedContinue(*_cont); + return _combined; +} + + +/** + * This functions allows to build a eoContinue for multi-objective optimization from the parser (partly taken from make_continue_pareto.h) + * @param _parser the parser + * @param _state to store allocated objects + * @param _eval the funtions evaluator + */ +template +eoContinue & do_make_continue_moeo(eoParser& _parser, eoState& _state, eoEvalFuncCounter & _eval) +{ + // the combined continue - to be filled + eoCombinedContinue *continuator = NULL; + // First the eoGenContinue - need a default value so you can run blind + // but we also need to be able to avoid it <--> 0 + eoValueParam& maxGenParam = _parser.createParam(unsigned(100), "maxGen", "Maximum number of generations (0 = none)",'G',"Stopping criterion"); + if (maxGenParam.value()) // positive: -> define and store + { + eoGenContinue *genCont = new eoGenContinue(maxGenParam.value()); + _state.storeFunctor(genCont); + // and "add" to combined + continuator = make_combinedContinue(continuator, genCont); + } + // maxEval + eoValueParam& maxEvalParam = _parser.getORcreateParam((unsigned long)0, "maxEval", "Maximum number of evaluations (0 = none)", 'E', "Stopping criterion"); + if (maxEvalParam.value()) + { + eoEvalContinue *evalCont = new eoEvalContinue(_eval, maxEvalParam.value()); + _state.storeFunctor(evalCont); + // and "add" to combined + continuator = make_combinedContinue(continuator, evalCont); + } + // maxTime + eoValueParam& maxTimeParam = _parser.getORcreateParam((unsigned long)0, "maxTime", "Maximum running time in seconds (0 = none)", 'T', "Stopping criterion"); + if (maxTimeParam.value()) // positive: -> define and store + { + eoTimeContinue *timeCont = new eoTimeContinue(maxTimeParam.value()); + _state.storeFunctor(timeCont); + // and "add" to combined + continuator = make_combinedContinue(continuator, timeCont); + } + // CtrlC +#ifndef _MSC_VER + // the CtrlC interception (Linux only I'm afraid) + eoCtrlCContinue *ctrlCCont; + eoValueParam& ctrlCParam = _parser.createParam(true, "CtrlC", "Terminate current generation upon Ctrl C",'C', "Stopping criterion"); + if (_parser.isItThere(ctrlCParam)) + { + ctrlCCont = new eoCtrlCContinue; + // store + _state.storeFunctor(ctrlCCont); + // add to combinedContinue + continuator = make_combinedContinue(continuator, ctrlCCont); + } +#endif + // now check that there is at least one! + if (!continuator) + throw std::runtime_error("You MUST provide a stopping criterion"); + // OK, it's there: store in the eoState + _state.storeFunctor(continuator); + // and return + return *continuator; +} + +#endif /*MAKE_CONTINUE_MOEO_H_*/ diff --git a/trunk/paradiseo-moeo/src/do/make_ea_moeo.h b/trunk/paradiseo-moeo/src/do/make_ea_moeo.h new file mode 100755 index 000000000..513a29974 --- /dev/null +++ b/trunk/paradiseo-moeo/src/do/make_ea_moeo.h @@ -0,0 +1,240 @@ +// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- + +//----------------------------------------------------------------------------- +// make_ea_moeo.h +// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007 +/* + This library... + + Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr + */ +//----------------------------------------------------------------------------- + +#ifndef MAKE_EA_MOEO_H_ +#define MAKE_EA_MOEO_H_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/** + * This functions allows to build a moeoEA from the parser + * @param _parser the parser + * @param _state to store allocated objects + * @param _eval the funtions evaluator + * @param _continue the stopping crietria + * @param _op the variation operators + * @param _archive the archive of non-dominated solutions + */ +template < class MOEOT > +moeoEA < MOEOT > & do_make_ea_moeo(eoParser & _parser, eoState & _state, eoEvalFunc < MOEOT > & _eval, eoContinue < MOEOT > & _continue, eoGenOp < MOEOT > & _op, moeoArchive < MOEOT > & _archive) +{ + + /* the objective vector type */ + typedef typename MOEOT::ObjectiveVector ObjectiveVector; + + + /* the fitness assignment strategy */ + string & fitnessParam = _parser.createParam(string("FastNonDominatedSorting"), "fitness", + "Fitness assignment scheme: Dummy, FastNonDominatedSorting or IndicatorBased", 'F', + "Evolution Engine").value(); + string & indicatorParam = _parser.createParam(string("Epsilon"), "indicator", + "Binary indicator for IndicatorBased: Epsilon, Hypervolume", 'i', + "Evolution Engine").value(); + double rho = _parser.createParam(1.1, "rho", "reference point for the hypervolume indicator", 'r', + "Evolution Engine").value(); + double kappa = _parser.createParam(0.05, "kappa", "Scaling factor kappa for IndicatorBased", 'k', + "Evolution Engine").value(); + moeoFitnessAssignment < MOEOT > * fitnessAssignment; + if (fitnessParam == string("Dummy")) + { + fitnessAssignment = new moeoDummyFitnessAssignment < MOEOT> (); + } + else if (fitnessParam == string("FastNonDominatedSorting")) + { + fitnessAssignment = new moeoFastNonDominatedSortingFitnessAssignment < MOEOT> (); + } + else if (fitnessParam == string("IndicatorBased")) + { + // metric + moeoNormalizedSolutionVsSolutionBinaryMetric < ObjectiveVector, double > *metric; + if (indicatorParam == string("Epsilon")) + { + metric = new moeoAdditiveEpsilonBinaryMetric < ObjectiveVector >; + } + else if (indicatorParam == string("Hypervolume")) + { + metric = new moeoHypervolumeBinaryMetric < ObjectiveVector > (rho); + } + else + { + string stmp = string("Invalid binary quality indicator: ") + indicatorParam; + throw std::runtime_error(stmp.c_str()); + } + fitnessAssignment = new moeoIndicatorBasedFitnessAssignment < MOEOT> (metric, kappa); + } + else + { + string stmp = string("Invalid fitness assignment strategy: ") + fitnessParam; + throw std::runtime_error(stmp.c_str()); + } + _state.storeFunctor(fitnessAssignment); + + + /* the diversity assignment strategy */ + string & diversityParam = _parser.createParam(string("Dummy"), "diversity", + "Diversity assignment scheme: Dummy or CrowdingDistance", 'D', "Evolution Engine").value(); + moeoDiversityAssignment < MOEOT > * diversityAssignment; + if (diversityParam == string("CrowdingDistance")) + { + diversityAssignment = new moeoCrowdingDistanceDiversityAssignment < MOEOT> (); + } + else if (diversityParam == string("Dummy")) + { + diversityAssignment = new moeoDummyDiversityAssignment < MOEOT> (); + } + else + { + string stmp = string("Invalid diversity assignment strategy: ") + diversityParam; + throw std::runtime_error(stmp.c_str()); + } + _state.storeFunctor(diversityAssignment); + + + /* the comparator strategy */ + string & comparatorParam = _parser.createParam(string("FitnessThenDiversity"), "comparator", + "Comparator scheme: FitnessThenDiversity or DiversityThenFitness", 'C', "Evolution Engine").value(); + moeoComparator < MOEOT > * comparator; + if (comparatorParam == string("FitnessThenDiversity")) + { + comparator = new moeoFitnessThenDiversityComparator < MOEOT> (); + } + else if (comparatorParam == string("DiversityThenFitness")) + { + comparator = new moeoDiversityThenFitnessComparator < MOEOT> (); + } + else + { + string stmp = string("Invalid comparator strategy: ") + comparatorParam; + throw std::runtime_error(stmp.c_str()); + } + _state.storeFunctor(comparator); + + + /* the selection strategy */ + eoValueParam < eoParamParamType > & selectionParam = _parser.createParam(eoParamParamType("DetTour(2)"), "selection", + "Selection scheme: DetTour(T), StochTour(t) or Random", 'S', "Evolution Engine"); + eoParamParamType & ppSelect = selectionParam.value(); + moeoSelectOne < MOEOT > * select; + if (ppSelect.first == string("DetTour")) + { + unsigned tSize; + if (!ppSelect.second.size()) // no parameter added + { + cerr << "WARNING, no parameter passed to DetTour, using 2" << endl; + tSize = 2; + // put back 2 in parameter for consistency (and status file) + ppSelect.second.push_back(string("2")); + } + else // parameter passed by user as DetTour(T) + { + tSize = atoi(ppSelect.second[0].c_str()); + } + select = new moeoDetTournamentSelect < MOEOT > (*comparator, tSize); + } + else if (ppSelect.first == string("StochTour")) + { + double tRate; + if (!ppSelect.second.size()) // no parameter added + { + cerr << "WARNING, no parameter passed to StochTour, using 1" << endl; + tRate = 1; + // put back 1 in parameter for consistency (and status file) + ppSelect.second.push_back(string("1")); + } + else // parameter passed by user as StochTour(T) + { + tRate = atof(ppSelect.second[0].c_str()); + } + select = new moeoStochTournamentSelect < MOEOT > (*comparator, tRate); + } + else if (ppSelect.first == string("Roulette")) + { + // TO DO ! + // ... + } + else if (ppSelect.first == string("Random")) + { + select = new moeoRandomSelect (); + } + else + { + string stmp = string("Invalid selection strategy: ") + ppSelect.first; + throw std::runtime_error(stmp.c_str()); + } + _state.storeFunctor(select); + + + /* the replacement strategy */ + string & replacementParam = _parser.createParam(string("Elitist"), "replacement", + "Replacement scheme: Elitist, Environmental or Generational", 'R', "Evolution Engine").value(); + moeoReplacement < MOEOT > * replace; + if (replacementParam == string("Elitist")) + { + replace = new moeoElitistReplacement < MOEOT> (*fitnessAssignment, *diversityAssignment, *comparator); + } + else if (replacementParam == string("Environmental")) + { + replace = new moeoEnvironmentalReplacement < MOEOT> (*fitnessAssignment, *diversityAssignment, *comparator); + } + else if (replacementParam == string("Generational")) + { + replace = new moeoGenerationalReplacement < MOEOT> (); + } + else + { + string stmp = string("Invalid replacement strategy: ") + replacementParam; + throw std::runtime_error(stmp.c_str()); + } + _state.storeFunctor(replace); + + + /* the number of offspring */ + eoValueParam < eoHowMany > & offspringRateParam = _parser.createParam(eoHowMany(1.0), "nbOffspring", + "Number of offspring (percentage or absolute)", 'O', "Evolution Engine"); + + + // the general breeder + eoGeneralBreeder < MOEOT > * breed = new eoGeneralBreeder < MOEOT > (*select, _op, offspringRateParam.value()); + _state.storeFunctor(breed); + // the eoEasyEA + moeoEA < MOEOT > * algo = new moeoEasyEA < MOEOT > (_continue, _eval, *breed, *replace, *fitnessAssignment, *diversityAssignment); + _state.storeFunctor(algo); + return *algo; + +} + +#endif /*MAKE_EA_MOEO_H_*/