Markov.hpp

Go to the documentation of this file.

#ifndef MARKOV_HPP_INCLUDED
#define MARKOV_HPP_INCLUDED

#include "Music.hpp"
#include "Traits.hpp"
#include "Database.hpp"
#include <vector>
#include <map>
#include <exception>
#include <string>
#include <iostream>
#include <boost/type_traits.hpp>
#include <boost/rational.hpp>


class HMM
{
public:
    friend HMM*  loadFromFile(std::string fname);    
     using Proba = double;
    using ObsId = unsigned;
    using StateId = unsigned;
    using Score = double;
    //using Proba = boost::rational<int>;
    //using Score = boost::rational<int>;
    
    virtual ~HMM() {};
    
    virtual std::vector<std::pair<ChordProgression,Score> > getBestProgressions(Melody M, unsigned n =1) const = 0;


    virtual unsigned getMaxProgressionsNbr() const = 0;

    virtual void saveToFile(const std::string & fname) const = 0;


    virtual void learn(Database& db, const std::string& style) = 0;

protected:

};


#include "Observation.hpp"

CREATE_MEMBER_DETECTOR(getClosestObs) //macro that generates a trait has_getClosestObs<> that checks for the implementation of the public method "getClosestObs"
CREATE_STATIC_MEMBER_DETECTOR(TypeID)

template <class Obs>
class HMM_backend;

template <class Obs>
class HMM_backend : public HMM
{
    static_assert(boost::has_left_shift<std::ostream,Obs>::value,"error : the template argument Obs must provide a stream operator to ostream"); //ensure that the template class can be printed to ostream
    static_assert(function_traits::has_TypeID<Obs>::value,"error : the template argument Obs must provide a static member describing its type id");
    static_assert(function_traits::has_getClosestObs<Obs,HMM::ObsId(const std::vector<Obs>&)>::value,"error : the template argument must provide a public getClosestObs method of type std::vector<Obs> -> ObsId");
public :
    class State
    {
    public :
        friend class HMM_backend;
        Chord m_c; 
        unsigned m_position; 
    private :
        State(const Chord & c,unsigned p,unsigned id) : m_c(c),m_position(p),m_stateID(id){}
        unsigned m_stateID;
        operator unsigned() const{return m_stateID;};
    };

    HMM_backend();
    ~HMM_backend(){};
    std::vector<std::pair<ChordProgression,Score> > getBestProgressions(Melody M, unsigned n =1) const;

    unsigned getMaxProgressionsNbr() const;

    void saveToFile(const std::string & fname) const;



    void learn(Database& db, const std::string& style);
    void learn_unsupervised(Database& db, const std::string& style);

protected:
    void forwardProcedure(const std::vector<Obs> & o);
    void backwardProcedure(const std::vector<Obs> & o);
    void updateProcedure(const std::vector<Obs> & o);
    void generateObsSet(const std::vector<Data>& entries);

private :
    std::vector<Proba> m_pi; 
    std::vector<State> m_states; 
    std::vector<std::vector<Proba> > m_transition; 
    std::vector<std::vector<Proba> > m_observation; 
    std::vector<Obs> m_obsSet; 

    std::vector<std::vector<Proba>> m_alpha; // used for forward procedure
    std::vector<std::vector<Proba>> m_beta; // used for backward procedure
};


HMM * loadFromFile(std::string fname);

#include "Markov.cpp"
#endif // MARKOV_HPP_INCLUDED