sample_sampler.h

Go to the documentation of this file.

/* $Id: sample_sampler.h 18278 2014-11-25 01:42:10Z ksimek $ */
/* =========================================================================== *
   |
   |  Copyright (c) 1994-2010 by Kobus Barnard (author)
   |
   |  Personal and educational use of this code is granted, provided that this
   |  header is kept intact, and that the authorship is not misrepresented, that
   |  its use is acknowledged in publications, and relevant papers are cited.
   |
   |  For other use contact the author (kobus AT cs DOT arizona DOT edu).
   |
   |  Please note that the code in this file has not necessarily been adequately
   |  tested. Naturally, there is no guarantee of performance, support, or fitness
   |  for any particular task. Nonetheless, I am interested in hearing about
   |  problems that you encounter.
   |
   |  Author:  Kyle Simek, Ernesto Brau
 * =========================================================================== */

#ifndef SAMPLE_SAMPLER_H_INCLUDED
#define SAMPLE_SAMPLER_H_INCLUDED

#include "sample_cpp/sample_step.h"
#include "sample_cpp/sample_base.h"
#include "sample_cpp/sample_recorder.h"

#include <boost/lambda/lambda.hpp>
#include <boost/function.hpp>
#include <l_cpp/l_index.h>
#include <vector>

template<typename Model>
class Abstract_sampler
{
private:
    typedef boost::function0<void> Callback;
public:
    typedef typename Sampler_step<Model>::Type Step;
    typedef Model Model_type;
    //typedef typename Sampler_callback<Model>::Type Callback;
    
    Abstract_sampler(
            const Model& initial_state,
            double initial_log_target) :
        m_cur_model(initial_state),
        m_cur_log_target(initial_log_target)
    {}

    BOOST_CONCEPT_ASSERT((BaseModel<Model>));

    virtual void run(int num_iterations);
    
    Model& current_state()
    {
        return m_cur_model;
    }

    const Model& current_state() const
    {
        return m_cur_model;
    }

    double current_log_target() const
    {
        return m_cur_log_target;
    }

    template <class Recorder>
    void add_recorder(Recorder r)
    {
        BOOST_CONCEPT_ASSERT((ModelRecorder<Recorder>));
        m_record.add(r);
    }

    template <class Recorder>
    void add_recorder(Recorder* r)
    {
        BOOST_CONCEPT_ASSERT((ModelRecorder<Recorder>));
        m_record.add(r);
    }

    template <class Callback>
    void add_record_callback(Callback cb)
    {
        add_recorder(Callback_recorder<Model>(cb));
    }

    //virtual const char* get_type() const{ return "Abstract_sampler"; }

//    template <class Recorder>
//    Recorder& get_recorder(size_t i)
//    { 
//        BOOST_CONCEPT_ASSERT((ModelRecorder<Recorder>));
//        return m_record.get_recorder<Recorder>(i);
//    }

    template <class Recorder>
    const Recorder& get_recorder(size_t i) const
    { 
        BOOST_CONCEPT_ASSERT((ModelRecorder<Recorder>));
        return m_record.template get_recorder<Recorder>(i);
    }

    void if_accept(const Callback& cb)
    {
        using namespace boost::lambda;
        if(m_if_accept.empty())
            m_if_accept = cb;
        else
            // comma operator of boost::lambda chains two functions together
            m_if_accept = (m_if_accept , cb);
    }

    void if_reject(const Callback& cb)
    {
        using namespace boost::lambda;
        if(m_if_reject.empty())
            m_if_reject = cb;
        else
            // comma operator of boost::lambda chains two functions together
            m_if_reject = (m_if_reject , cb);
    }

    void on_accept(const Callback& cb)
    {
        using namespace boost::lambda;
        if(m_on_accept.empty())
            m_on_accept = cb;
        else
            // comma operator of boost::lambda chains two functions together
            m_on_accept = (m_on_accept , cb);
    }

    void on_reject(const Callback& cb)
    {
        using namespace boost::lambda;
        if(m_on_reject.empty())
            m_on_reject = cb;
        else
            // comma operator of boost::lambda chains two functions together
            m_on_reject = (m_on_reject , cb);
    }

protected:

    virtual const Step& choose_step() const = 0;

private:
    Model m_cur_model;
    double m_cur_log_target;
    Multi_model_recorder<Model> m_record;
    //Callback pre_callback;
    //Callback post_callback;

    // one-off callbacks (cleared every iteration)
    Callback m_if_accept;
    Callback m_if_reject;

    // persistent callbacks (called every iteration)
    Callback m_on_accept;
    Callback m_on_reject;
};

/* \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ */

template<typename Model>
void Abstract_sampler<Model>::run(int num_iterations)
{
    for(int i = 1; i <= num_iterations; i++)
    {
        const Step& step = choose_step();
        Step_log<Model> log = step(m_cur_model, m_cur_log_target);
        m_cur_log_target = log[0].lt;
        m_record(m_cur_model, log);

        if(log.back().accept)
        {
            if(!m_on_accept.empty())
                m_on_accept();
            if(!m_if_accept.empty())
                m_if_accept();
        }
        else
        {
            if(!m_on_reject.empty())
                m_on_reject();
            if(!m_if_reject.empty())
                m_if_reject();
        }

        // clear non-persisitent callbacks
        m_if_accept.clear();
        m_if_reject.clear();
    }
};

/* \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ */

template<typename Model>
class Multi_step_sampler : public Abstract_sampler<Model>
{
protected:
    struct null_deleter
    {
        void operator()(const void*) const{}
    };
public:
    typedef Abstract_sampler<Model> Parent;

    //typedef typename Sampler_callback<Model>::Type Callback;
    //
    typedef typename Abstract_sampler<Model>::Step Step;


    BOOST_CONCEPT_ASSERT((BaseModel<Model>));

    Multi_step_sampler(
            const Model& initial_state,
            double initial_log_target) :
        Parent(initial_state, initial_log_target),
        m_steps(),
        m_step_callbacks(),
        m_name(),
        m_probabilities()
    {}

    template <class StepType>
    Multi_step_sampler(
            const StepType& st,
            const Model& initial_state,
            double initial_log_target) : 
        Parent(initial_state, initial_log_target),
        m_steps(),
        m_step_callbacks(),
        m_name(),
        m_probabilities()
    {
        add_step(st, 1.0);
    }

    Multi_step_sampler(
            const std::vector<Step>& step_list,
            const std::vector<double>& prob_list,
            const Model& initial_state,
            double initial_log_target) :
        Parent(initial_state, initial_log_target),
        m_steps(), 
        m_step_callbacks(),
        m_name(),
        m_probabilities()
    {
        assert(step_list.size() == prob_list.size());
        for(size_t i = 0; i < step_list.size(); ++i)
        {
            add_step(step_list[i], prob_list[i]);
        }
    }

   template <class StepType>
    void add_step(const StepType& step, double prob, const std::string& name = "")
    {
        BOOST_CONCEPT_ASSERT((boost::CopyConstructible<StepType>));

        boost::shared_ptr<StepType> tmp(new StepType(step));
        add_step(tmp, prob, name);
    }


   template <class StepType>
    void add_step(StepType* step, double prob, const std::string& name = "")
    {
        BOOST_CONCEPT_ASSERT((boost::CopyConstructible<StepType>));

        add_step(boost::shared_ptr<StepType>(step, null_deleter()), prob, name);
    }

    template <class StepType>
    void add_step(const boost::shared_ptr<StepType>& step, double prob, const std::string& name = "")
    {
        m_steps.push_back(step);
        m_step_callbacks.push_back(boost::ref(*step));
        m_name.push_back(name);
        m_probabilities.push_back(prob);
    }

    template <class StepType>
    const StepType& get_step(size_t i) const
    {
        return *boost::any_cast<boost::shared_ptr<StepType> >(m_steps.at(i));
    }

    //virtual const char* get_type() const
    //{ return "Multi_step_sampler"; }

protected:
    virtual const Step& choose_step() const
    {
        assert(m_steps.size() > 0);
        std::vector<size_t> indices = kjb::Index_range(0, m_steps.size() - 1).expand();

        // TODO: make this object a member to avoid constructing every time
        kjb::Categorical_distribution<size_t> P(
                indices, 
                m_probabilities);
        size_t s = kjb::sample(P);
        return m_step_callbacks[s];
    }

private:
    std::vector<boost::any> m_steps;
    std::vector<Step> m_step_callbacks;
    std::vector<std::string> m_name;
    std::vector<double> m_probabilities;
};


template<typename Model>
class Single_step_sampler : public Abstract_sampler<Model>
{
public:
    typedef Abstract_sampler<Model> Parent;

    typedef typename Abstract_sampler<Model>::Step Step;

    BOOST_CONCEPT_ASSERT((BaseModel<Model>));


    Single_step_sampler(
            const Step& step,
            const Model& initial_state,
            double initial_log_target) :
        Parent(initial_state, initial_log_target),
        m_step(step)
    {}

protected:

    virtual const Step& choose_step() const
    {
        return m_step;
    }

private:
    Step m_step;
};

#endif /*SAMPLE_SAMPLER_H_INCLUDED */