moeoIBEA.h

// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-

//-----------------------------------------------------------------------------
// moeoIBEASorting.h
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2006
/*
    This library...

    Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
 */
//-----------------------------------------------------------------------------


#ifndef _moeoIBEASorting_h
#define _moeoIBEASorting_h

#include <math.h>
#include <list>
#include <eoPop.h>
#include <eoPerf2Worth.h>
#include "moeoBinaryQualityIndicator.h"


template < class EOT, class Fitness > class moeoIBEA:public eoPerf2WorthCached < EOT,
  double >
{

public:
  using eoPerf2WorthCached < EOT, double >::value;

    moeoIBEA (moeoBinaryQualityIndicator < Fitness > *_I)
  {
    I = _I;
  }


  void calculate_worths (const eoPop < EOT > &_pop)
  {
    /* resizing the worths beforehand */
    value ().resize (_pop.size ());

    /* computation and setting of the bounds for each objective */
    setBounds (_pop);

    /* computation of the fitness for each individual */
    fitnesses (_pop);

    // higher is better, so invert the value
    double max = *std::max_element (value ().begin (), value ().end ());
    for (unsigned i = 0; i < value ().size (); i++)
      value ()[i] = max - value ()[i];
  }


protected:

  moeoBinaryQualityIndicator < Fitness > *I;

  virtual void setBounds (const eoPop < EOT > &_pop) = 0;
  virtual void fitnesses (const eoPop < EOT > &_pop) = 0;

};





template < class EOT, class Fitness = typename EOT::Fitness > class moeoIBEASorting:public moeoIBEA < EOT,
  Fitness
  >
{

public:

  moeoIBEASorting (moeoBinaryQualityIndicator < Fitness > *_I,
                   const double _kappa):
    moeoIBEA <
    EOT,
  Fitness > (_I)
  {
    kappa = _kappa;
  }


private:
  using moeoIBEA < EOT, Fitness >::I;
  using moeoIBEA < EOT, Fitness >::value;
  double
    kappa;


  void
  setBounds (const eoPop < EOT > &_pop)
  {
    typedef
      typename
      EOT::Fitness::fitness_traits
      traits;
    double
      min,
      max;
    for (unsigned i = 0; i < traits::nObjectives (); i++)
      {
        min = _pop[0].fitness ()[i];
        max = _pop[0].fitness ()[i];
        for (unsigned j = 1; j < _pop.size (); j++)
          {
            min = std::min (min, _pop[j].fitness ()[i]);
            max = std::max (max, _pop[j].fitness ()[i]);
          }
        // setting of the bounds for the objective i
        I->setBounds (i, min, max);
      }
  }


  void
  fitnesses (const eoPop < EOT > &_pop)
  {
    // reprsentation of the fitness components
    std::vector < std::vector < double > >
    fitComponents (_pop.size (), _pop.size ());
    // the maximum absolute indicator value
    double
      maxAbsoluteIndicatorValue = 0;

    // computation of the indicator values and of the maximum absolute indicator value
    for (unsigned i = 0; i < _pop.size (); i++)
      for (unsigned j = 0; j < _pop.size (); j++)
        if (i != j)
          {
            fitComponents[i][j] =
              (*I) (_pop[i].fitness (), _pop[j].fitness ());
            maxAbsoluteIndicatorValue =
              std::max (maxAbsoluteIndicatorValue,
                        fabs (fitComponents[i][j]));
          }

    // computation of the fitness components for each pair of individuals
    // if maxAbsoluteIndicatorValue==0, every individuals have the same fitness values for all objectives (already = 0)
    if (maxAbsoluteIndicatorValue != 0)
      for (unsigned i = 0; i < _pop.size (); i++)
        for (unsigned j = 0; j < _pop.size (); j++)
          if (i != j)
            fitComponents[i][j] =
              exp (-fitComponents[i][j] /
                   (maxAbsoluteIndicatorValue * kappa));

    // computation of the fitness for each individual
    for (unsigned i = 0; i < _pop.size (); i++)
      {
        value ()[i] = 0;
        for (unsigned j = 0; j < _pop.size (); j++)
          if (i != j)
            value ()[i] += fitComponents[j][i];
      }
  }

};





template < class EOT, class FitnessEval = typename EOT::Fitness::FitnessEval > class moeoIBEAStochSorting:public moeoIBEA < EOT,
  FitnessEval
  >
{

public:

moeoIBEAStochSorting (moeoBinaryQualityIndicator < FitnessEval > *_I):moeoIBEA < EOT,
    FitnessEval >
    (_I)
  {
  }


private:
  using moeoIBEAStochSorting < EOT, FitnessEval >::I;
  using moeoIBEAStochSorting < EOT, FitnessEval >::value;


  static double
  zero ()
  {
    return 1e-7;
  }


  void
  setBounds (const eoPop < EOT > &_pop)
  {
    typedef
      typename
      EOT::Fitness::FitnessTraits
      traits;
    double
      min,
      max;
    for (unsigned i = 0; i < traits::nObjectives (); i++)
      {
        min = _pop[0].fitness ().minimum (i);
        max = _pop[0].fitness ().maximum (i);
        for (unsigned j = 1; j < _pop.size (); j++)
          {
            min = std::min (min, _pop[j].fitness ().minimum (i));
            max = std::max (max, _pop[j].fitness ().maximum (i));
          }
        // setting of the bounds for the ith objective
        I->setBounds (i, min, max);
      }
  }


  void
  fitnesses (const eoPop < EOT > &_pop)
  {
    typedef
      typename
      EOT::Fitness::FitnessTraits
      traits;
    unsigned
      nEval = traits::nEvaluations ();
    unsigned
      index;
    double
      eiv,
      p,
      sumP,
      iValue;
    std::list < std::pair < double, unsigned > >
      l;
    std::vector < unsigned >
    n (_pop.size ());

    for (unsigned ind = 0; ind < _pop.size (); ind++)
      {
        value ()[ind] = 0.0;    // fitness value for the individual ind
        for (unsigned eval = 0; eval < nEval; eval++)
          {

            // I-values computation for the evaluation eval of the individual ind
            l.clear ();
            for (unsigned i = 0; i < _pop.size (); i++)
              {
                if (i != ind)
                  {
                    for (unsigned j = 0; j < nEval; j++)
                      {
                        std::pair < double, unsigned >
                          pa;
                        // I-value
                        pa.first =
                          (*I) (_pop[ind].fitness ()[eval],
                                _pop[i].fitness ()[j]);
                        // index of the individual
                        pa.second = i;
                        // append this to the list
                        l.push_back (pa);
                      }
                  }
              }

            // sorting of the I-values (in decreasing order)
            l.sort ();

            // computation of the Expected Indicator Value (eiv) for the evaluation eval of the individual ind
            eiv = 0.0;
            n.assign (n.size (), 0);    // n[i]==0 for all i
            sumP = 0.0;
            while (((1 - sumP) > zero ()) && (l.size () > 0))
              {
                // we use the last element of the list (the greatest one)
                iValue = l.back ().first;
                index = l.back ().second;
                // computation of the probability to appear
                p = (1.0 / (nEval - n[index])) * (1.0 - sumP);
                // eiv update
                eiv += p * iValue;
                // update of the number of elements for individual index
                n[index]++;
                // removing the last element of the list
                l.pop_back ();
                // sum of p update
                sumP += p;
              }
            value ()[ind] += eiv / nEval;
          }
      }

  }

};





template < class EOT, class FitnessEval = typename EOT::Fitness::FitnessEval > class moeoIBEAAvgSorting:public moeoIBEA < EOT,
  FitnessEval
  >
{

public:

  moeoIBEAAvgSorting (moeoBinaryQualityIndicator < FitnessEval > *_I,
                      const double _kappa):
    moeoIBEA <
    EOT,
  FitnessEval > (_I)
  {
    kappa = _kappa;
  }


private:
  using moeoIBEAAvgSorting < EOT, FitnessEval >::I;
  using moeoIBEAAvgSorting < EOT, FitnessEval >::value;
  double
    kappa;


  void
  setBounds (const eoPop < EOT > &_pop)
  {
    typedef
      typename
      EOT::Fitness::FitnessTraits
      traits;
    double
      min,
      max;
    for (unsigned i = 0; i < traits::nObjectives (); i++)
      {
        min = _pop[0].fitness ().averagedParetoFitnessObject ()[i];
        max = _pop[0].fitness ().averagedParetoFitnessObject ()[i];
        for (unsigned j = 1; j < _pop.size (); j++)
          {
            min =
              std::min (min,
                        _pop[j].fitness ().averagedParetoFitnessObject ()[i]);
            max =
              std::max (max,
                        _pop[j].fitness ().averagedParetoFitnessObject ()[i]);
          }
        // setting of the bounds for the objective i
        I->setBounds (i, min, max);
      }
  }


  void
  fitnesses (const eoPop < EOT > &_pop)
  {
    // reprsentation of the fitness components
    std::vector < std::vector < double > >
    fitComponents (_pop.size (), _pop.size ());
    // the maximum absolute indicator value
    double
      maxAbsoluteIndicatorValue = 0;

    // computation of the indicator values and of the maximum absolute indicator value
    for (unsigned i = 0; i < _pop.size (); i++)
      for (unsigned j = 0; j < _pop.size (); j++)
        if (i != j)
          {
            fitComponents[i][j] =
              (*I) (_pop[i].fitness ().averagedParetoFitnessObject (),
                    _pop[j].fitness ().averagedParetoFitnessObject ());
            maxAbsoluteIndicatorValue =
              std::max (maxAbsoluteIndicatorValue,
                        fabs (fitComponents[i][j]));
          }

    // computation of the fitness components for each pair of individuals
    // if maxAbsoluteIndicatorValue==0, every individuals have the same fitness values for all objectives (already = 0)
    if (maxAbsoluteIndicatorValue != 0)
      for (unsigned i = 0; i < _pop.size (); i++)
        for (unsigned j = 0; j < _pop.size (); j++)
          if (i != j)
            fitComponents[i][j] =
              exp (-fitComponents[i][j] /
                   (maxAbsoluteIndicatorValue * kappa));

    // computation of the fitness for each individual
    for (unsigned i = 0; i < _pop.size (); i++)
      {
        value ()[i] = 0;
        for (unsigned j = 0; j < _pop.size (); j++)
          if (i != j)
            value ()[i] += fitComponents[j][i];
      }
  }

};


#endif

---