eoNormalMutation.h

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

//-----------------------------------------------------------------------------
// eoNormalMutation.h
// (c) EEAAX 2001 - Maarten Keijzer 2000
/*
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    Contact: Marc.Schoenauer@polytechnique.fr
             mak@dhi.dk
 */
//-----------------------------------------------------------------------------

#ifndef eoNormalMutation_h
#define eoNormalMutation_h

//-----------------------------------------------------------------------------

#include <algorithm>    // swap_ranges
#include <utils/eoRNG.h>
#include <utils/eoUpdatable.h>
#include <eoEvalFunc.h>
#include <es/eoReal.h>
#include <utils/eoRealBounds.h>
//-----------------------------------------------------------------------------

template<class EOT> class eoNormalVecMutation: public eoMonOp<EOT>
{
 public:
  eoNormalVecMutation(double _sigma, const double& _p_change = 1.0):
    sigma(_sigma), bounds(eoDummyVectorNoBounds), p_change(_p_change) {}

  eoNormalVecMutation(eoRealVectorBounds & _bounds,
                    double _sigma, const double& _p_change = 1.0):
    sigma(_bounds.size(), _sigma), bounds(_bounds), p_change(_p_change)
  {
    // scale to the range - if any
    for (unsigned i=0; i<bounds.size(); i++)
      if (bounds.isBounded(i))
          sigma[i] *= _sigma*bounds.range(i);
  }

  virtual std::string className() const { return "eoNormalVecMutation"; }

  bool operator()(EOT& _eo)
    {
      bool hasChanged=false;
      for (unsigned lieu=0; lieu<_eo.size(); lieu++)
        {
          if (rng.flip(p_change))
            {
              _eo[lieu] += sigma[lieu]*rng.normal();
              bounds.foldsInBounds(lieu, _eo[lieu]);
              hasChanged = true;
            }
        }
      return hasChanged;
    }

private:
  std::vector<double> sigma;
  eoRealVectorBounds & bounds;
  double p_change;
};

template<class EOT> class eoNormalMutation
    : public eoMonOp<EOT>
{
public:
  eoNormalMutation(double & _sigma, const double& _p_change = 1.0):
    sigma(_sigma), bounds(eoDummyVectorNoBounds), p_change(_p_change) {}

  eoNormalMutation(eoRealVectorBounds & _bounds,
                    double _sigma, const double& _p_change = 1.0):
    sigma(_sigma), bounds(_bounds), p_change(_p_change) {}

  virtual std::string className() const { return "eoNormalMutation"; }

  bool operator()(EOT& _eo)
    {
      bool hasChanged=false;
      for (unsigned lieu=0; lieu<_eo.size(); lieu++)
        {
          if (rng.flip(p_change))
            {
              _eo[lieu] += sigma*rng.normal();
              bounds.foldsInBounds(lieu, _eo[lieu]);
              hasChanged = true;
            }
        }
      return hasChanged;
    }

  double & Sigma() {return sigma;}

private:
  double & sigma;
  eoRealVectorBounds & bounds;
  double p_change;
};

template<class EOT> class eoOneFifthMutation :
  public eoNormalMutation<EOT>, public eoUpdatable
{
public:

    using eoNormalMutation< EOT >::Sigma;

    typedef typename EOT::Fitness Fitness;

  eoOneFifthMutation(eoEvalFunc<EOT> & _eval, double & _sigmaInit,
                     unsigned _windowSize = 10, double _updateFactor=0.83,
                     double _threshold=0.2):
    eoNormalMutation<EOT>(_sigmaInit), eval(_eval),
    threshold(_threshold), updateFactor(_updateFactor),
    nbMut(_windowSize, 0), nbSuccess(_windowSize, 0), genIndex(0)
  {
    // minimal check
    if (updateFactor>=1)
      throw std::runtime_error("Update factor must be < 1 in eoOneFifthMutation");
  }

  virtual std::string className() const { return "eoOneFifthMutation"; }

  bool operator()(EOT & _eo)
    {
      if (_eo.invalid())           // due to some crossover???
        eval(_eo);
      Fitness oldFitness = _eo.fitness(); // save old fitness

      // call standard operator - then count the successes
      if (eoNormalMutation<EOT>::operator()(_eo)) // _eo has been modified
        {
          _eo.invalidate();        // don't forget!!!
          nbMut[genIndex]++;
          eval(_eo);               // compute fitness of offspring

          if (_eo.fitness() > oldFitness)
            nbSuccess[genIndex]++;          // update counter
        }
      return false;                // because eval has reset the validity flag
    }

  void update()
  {
    unsigned totalMut = 0;
    unsigned totalSuccess = 0;
    // compute the average stats over the time window
    for ( unsigned i=0; i<nbMut.size(); i++)
      {
        totalMut += nbMut[i];
        totalSuccess += nbSuccess[i];
      }

    // update sigma accordingly
    double prop = double(totalSuccess) / totalMut;
    if (prop > threshold) {
      Sigma() /= updateFactor;     // increase sigma
    }
    else
      {
        Sigma() *= updateFactor;           // decrease sigma
      }
    genIndex = (genIndex+1) % nbMut.size() ;
    nbMut[genIndex] = nbSuccess[genIndex] = 0;

  }

private:
  eoEvalFunc<EOT> & eval;
  double threshold;                // 1/5 !
  double updateFactor ;            // the multiplicative factor
  std::vector<unsigned> nbMut;     // total number of mutations per gen
  std::vector<unsigned> nbSuccess;         // number of successful mutations per gen
  unsigned genIndex ;              // current index in std::vectors (circular)
};


//-----------------------------------------------------------------------------
#endif