sa.hpp

Go to the documentation of this file.

#ifndef MLPACK_CORE_OPTIMIZERS_SA_SA_HPP
#define MLPACK_CORE_OPTIMIZERS_SA_SA_HPP

#include <mlpack/prereqs.hpp>

#include "exponential_schedule.hpp"

namespace mlpack {
namespace optimization {

template<
    typename FunctionType,
    typename CoolingScheduleType = ExponentialSchedule
>
class SA
{
 public:
  SA(FunctionType& function,
     CoolingScheduleType& coolingSchedule,
     const size_t maxIterations = 1000000,
     const double initT = 10000.,
     const size_t initMoves = 1000,
     const size_t moveCtrlSweep = 100,
     const double tolerance = 1e-5,
     const size_t maxToleranceSweep = 3,
     const double maxMoveCoef = 20,
     const double initMoveCoef = 0.3,
     const double gain = 0.3);

  double Optimize(arma::mat& iterate);

  const FunctionType& Function() const { return function; }
  FunctionType& Function() { return function; }

  double Temperature() const { return temperature; }
  double& Temperature() { return temperature; }

  size_t InitMoves() const { return initMoves; }
  size_t& InitMoves() { return initMoves; }

  size_t MoveCtrlSweep() const { return moveCtrlSweep; }
  size_t& MoveCtrlSweep() { return moveCtrlSweep; }

  double Tolerance() const { return tolerance; }
  double& Tolerance() { return tolerance; }

  size_t MaxToleranceSweep() const { return maxToleranceSweep; }
  size_t& MaxToleranceSweep() { return maxToleranceSweep; }

  double Gain() const { return gain; }
  double& Gain() { return gain; }

  size_t MaxIterations() const { return maxIterations; }
  size_t& MaxIterations() { return maxIterations; }

  arma::mat MaxMove() const { return maxMove; }
  arma::mat& MaxMove() { return maxMove; }

  arma::mat MoveSize() const { return moveSize; }
  arma::mat& MoveSize() { return moveSize; }

 private:
  FunctionType& function;
  CoolingScheduleType& coolingSchedule;
  size_t maxIterations;
  double temperature;
  size_t initMoves;
  size_t moveCtrlSweep;
  double tolerance;
  size_t maxToleranceSweep;
  double gain;

  arma::mat maxMove;
  arma::mat moveSize;

  void GenerateMove(arma::mat& iterate,
                    arma::mat& accept,
                    double& energy,
                    size_t& idx,
                    size_t& sweepCounter);

  void MoveControl(const size_t nMoves, arma::mat& accept);
};

} // namespace optimization
} // namespace mlpack

#include "sa_impl.hpp"

#endif