bayesoptbase.hpp

Go to the documentation of this file.

/*
-------------------------------------------------------------------------
   This file is part of BayesOpt, an efficient C++ library for 
   Bayesian optimization.

   Copyright (C) 2011-2015 Ruben Martinez-Cantin <rmcantin@unizar.es>
 
   BayesOpt is free software: you can redistribute it and/or modify it 
   under the terms of the GNU Affero General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.

   BayesOpt 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 Affero General Public License for more details.

   You should have received a copy of the GNU Affero General Public License
   along with BayesOpt.  If not, see <http://www.gnu.org/licenses/>.
------------------------------------------------------------------------
*/


#ifndef  _BAYESOPTBASE_HPP_
#define  _BAYESOPTBASE_HPP_

#include <boost/scoped_ptr.hpp>
#include <boost/random.hpp>
#include <boost/numeric/ublas/vector.hpp>
#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/io.hpp>
#include "bayesopt/parameters.hpp"


namespace bayesopt {


  //Forward declaration
  class PosteriorModel;
  class ProbabilityDistribution;
  class Dataset;
  class BOptState;

  typedef boost::numeric::ublas::vector<double>                   vectord;
  typedef boost::numeric::ublas::vector<int>                      vectori;
  typedef boost::numeric::ublas::matrix<double>                   matrixd;
  typedef std::vector<vectord>                                   vecOfvec;


  class BAYESOPT_API BayesOptBase
  {
  public:
    BayesOptBase(size_t dim, Parameters params);

    virtual ~BayesOptBase();

    virtual double evaluateSample( const vectord &query ) = 0;
    

    virtual bool checkReachability( const vectord &query )
    { return true; };


    void optimize(vectord &bestPoint);

    void stepOptimization();

    void initializeOptimization();
    
    vectord getFinalResult();

    void saveOptimization(BOptState &state);
    
    void restoreOptimization(BOptState state);

    // Getters and Setters
    ProbabilityDistribution* getPrediction(const vectord& query);
    const Dataset* getData();
    Parameters* getParameters();
    double getValueAtMinimum();
    size_t getCurrentIter();
    double evaluateCriteria(const vectord& query);

  protected:
    vectord getPointAtMinimum();

    double evaluateSampleInternal( const vectord &query );

    virtual vectord samplePoint() = 0;

    virtual void findOptimal(vectord &xOpt) = 0;
  
    virtual vectord remapPoint(const vectord& x) = 0;

    virtual void generateInitialPoints(matrixd& xPoints) = 0;

    void plotStepData(size_t iteration, const vectord& xNext,
                  double yNext);
        
    void saveInitialSamples(matrixd xPoints);
    void saveResponse(double yPoint, bool clear);

  protected:
    Parameters mParameters;                    
    size_t mDims;                                   
    size_t mCurrentIter;                        
    boost::mt19937 mEngine;                      

  private:
    boost::scoped_ptr<PosteriorModel> mModel;
    double mYPrev;
    size_t mCounterStuck;
  private:

    BayesOptBase();

    vectord nextPoint();  

  };

} //namespace bayesopt


#endif