FixedPisaNsga2.h

Go to the documentation of this file.

//
// Class FixedPisaNsga2
//   Implementing the Variator for the PISA state machine.
//
//   @see http://www.tik.ee.ethz.ch/pisa/
//
//   The convergence behavior of the optimizer can be steered in 3 ways,
//   corresponding command line arguments are given in brackets:
//     - limit the number of generations (maxGenerations),
//     - specify a target hypervolume (expected-hypervol) and tolerance
//       (epsilon)
//     - specify a minimal hypervolume progress (conv-hvol-prog), relative to
//       the last generation, ((prev - new)/prev) that has to be attained to
//       continue optimizing.
//
// Copyright (c) 2010 - 2013, Yves Ineichen, ETH Zürich
// All rights reserved
//
// Implemented as part of the PhD thesis
// "Toward massively parallel multi-objective optimization with application to
// particle accelerators" (https://doi.org/10.3929/ethz-a-009792359)
//
// This file is part of OPAL.
//
// OPAL is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// You should have received a copy of the GNU General Public License
// along with OPAL. If not, see <https://www.gnu.org/licenses/>.
//
#ifndef __FIXED_PISA_NSGA2_H__
#define __FIXED_PISA_NSGA2_H__
 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
#include <deque>
#include <fstream>
#include <map>
#include <string>
#include <sstream>
#include <utility>
#include <vector>
 
#include "Comm/types.h"
#include "Util/Types.h"
#include "Util/CmdArguments.h"
#include "Util/Statistics.h"
 
#include "Optimizer/Optimizer.h"
#include "Optimizer/EA/Individual.h"
#include "Optimizer/EA/Population.h"
#include "Optimizer/EA/Variator.h"
 
#include <boost/property_tree/ptree.hpp>
 
#include "Util/Trace/Trace.h"
 
 
template<
      template <class> class CrossoverOperator
    , template <class> class MutationOperator
>
class FixedPisaNsga2 : public Optimizer {
 
public:

    FixedPisaNsga2(Expressions::Named_t objectives,
                   Expressions::Named_t constraints,
                   DVarContainer_t dvars, size_t dim, Comm::Bundle_t comms,
                   CmdArguments_t args,
                   std::vector<double> hypervolRef,
                   int nrWorkerGroups);
 
    ~FixedPisaNsga2();

    virtual void initialize();

    typedef std::vector< Individual > SolutionState_t;
    typedef Individual Individual_t;
    typedef Variator< Individual_t, CrossoverOperator, MutationOperator >
        Variator_t;
    typedef Population< Individual_t > Population_t;
    using individual = std::shared_ptr<typename FixedPisaNsga2::Individual_t>;
 
protected:

    void writeVariatorCfg();

    virtual bool onMessage(MPI_Status status, size_t length);
    virtual void postPoll();
 
    virtual void setupPoll() {}
    virtual void prePoll() {
        // std::ostringstream debug;
        // debug << "IN PRE POLL: ";
        // debug << getStateString(curState_m) << std::endl;
        // progress_->log(debug);
    }
    virtual void onStop() {}
    void dispatch_forward_solves();
 
 
private:

    enum PisaState_t {
          Initialize         = 0
        , InitializeSelector = 1
        , Variate            = 2
        , Select             = 3
        , Stop               = 4
        , VariatorStopped    = 5
        , VariatorTerminate  = 6
        /* , SelectorStopped    = 7 */
        /* , Reset              = 8 */
        /* , ReadyForReset      = 9 */
        /* , ReadyForResetS     = 10 */
        /* , Restart            = 11 */
    };
 
    std::string getStateString(PisaState_t) const;
 
    // selector parameters
    int seed;   /* seed for random number generator */
    const int tournament_m = 1;  /* number of opponents for mating selection */

    PisaState_t curState_m;

    const std::unique_ptr<Statistics<size_t> > statistics_;
 
    std::unique_ptr<Variator_t> variator_m;
 
    std::vector<unsigned int> pp_all;        
    std::vector<unsigned int> parent_queue_; 
    // std::set<unsigned int> archive_;
    std::set<unsigned int> to_selector_;     
 
    // to compute the front
    std::vector<int> copies; 
    std::vector<double> dist;
    std::vector< std::vector<int> > front; 
    std::map<size_t, double> fitness_; 

    Comm::Bundle_t comms_;

    std::deque<unsigned int> finishedBuffer_m;

    std::map<size_t, individual > jobmapping_m;

    std::shared_ptr<Population_t> paretoFront_m;

    bool initialized_m;

    bounds_t dVarBounds_m;
    Expressions::Named_t objectives_m;
    Expressions::Named_t constraints_m;
    DVarContainer_t dvars_m;

    CmdArguments_t args_m;

    size_t alpha_m;
    bool initialOptimization_m;
    bool birthControl_m;
    std::string file_start_m;

    //size_t mu_m;
    size_t lambda_m;
    size_t dim_m;
    size_t act_gen = 1;
    size_t maxGenerations_m;
    int num_workergroups_m;

    std::string resultFile_m;
    std::string resultDir_m;
 
 
    // dump frequency
    int dump_freq_m;
    bool dump_offspring_m;
    bool dump_dat_m;
    double hvol_eps_;
    double expected_hvol_;
    double current_hvol_;
    double conv_hvol_progress_;
    double hvol_progress_;

    std::vector<double> hvol_ref_m;

    std::string file_param_descr_;
 
    std::chrono::system_clock::time_point run_clock_start_;
    std::chrono::system_clock::time_point last_clock_;
 
    // DEBUG output helpers
    std::unique_ptr<Trace> job_trace_;
    std::unique_ptr<Trace> progress_;
 
 
    // entry point for starting the selector side of the PISA state machine
    void startSelector(std::string filename_base);

    void runStateMachine();

    void toSelectorAndCommit();

    size_t exchangeSolStateFreq_m;

    void exchangeSolutionStates();
 
    // Selector methods
    void selection();
    void mergeOffspring();
    void calcFitnesses();
    void calcDistances();
    void environmentalSelection();
    void matingSelection();
    int dominates(individual ind_a, individual ind_b);

    bool checkParetoFront(unsigned int id);
    void dumpPopulation(std::shared_ptr<Population_t>);
    void dumpPopulationToFile(std::shared_ptr<Population_t>, std::ostringstream& filename, bool dump_offspring);
    void dumpPopulationToJSON(std::shared_ptr<Population_t>, std::ostringstream& filename, bool dump_offspring);
    void dumpIndividualToFile(int id,
                              individual& ind,
                              std::ofstream& file,
                              const size_t numDigits);
    void dumpIndividualToJSON(int id,
                              individual& ind,
                              boost::property_tree::ptree& tree);

    int irand(int range) {
        return (int) ((double) range * (double) rand() / (RAND_MAX + 1.0));
    }
};
 
#include "Optimizer/EA/FixedPisaNsga2.tcc"
 
#endif