hrf-model.h

Go to the documentation of this file.

// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Copyright 2014-2015 Tsinghua University
// Author: wb.th08@gmail.com (Bin Wang), ozj@tsinghua.edu.cn (Zhijian Ou) 
//
// All h, cpp, cc, and script files (e.g. bat, sh, pl, py) should include the above 
// license declaration. Different coding language may use different comment styles.

#ifndef _HRF_MODEL_H_
#define _HRF_MODEL_H_

#include "trf-model.h"

namespace hrf
{
    typedef trf::PValue PValue; // parameter values
    typedef float HValue; // hidden variable valuse
    typedef trf::Prob Prob;
    typedef trf::LogP LogP;
    typedef trf::Vocab Vocab;
    typedef trf::VocabID VocabID;


    class Model;
    class AlgNode;
    class AlgLayer;

    class Seq
    {
    public:
        trf::Seq x;
        Mat<HValue> h; 
        int m_nLen; 
        int m_hlayer;
        int m_hnode;

    public:
        Seq() : m_nLen(0),m_hnode(0),m_hlayer(0) {};
        Seq(int len, int hlayer, int hnode) : m_nLen(0), m_hnode(0), m_hlayer(0) { Reset(len, hlayer, hnode); }
        Seq(Seq &seq) { Copy(seq); }
        void SetLen(int len) { m_nLen = len; }
        int GetLen() const { return m_nLen; }
        int GetHlayer() const { return m_hlayer; }
        int GetHnode() const { return m_hnode; }
        VecShell<VocabID> GetWordSeq() { return VecShell<VocabID>(x.GetWordSeq(), m_nLen); }
        VocabID *wseq() { return x.GetWordSeq(); }
        VocabID *cseq() { return x.GetClassSeq(); }
        void Reset(int len, int hlayer, int hnode);
        void Copy(Seq &seq);
        Seq GetSubSeq(int nPos, int nOrder);
        bool operator == (Seq &s);
        void Print();
        void Write(File &file);
    };

    class AlgNode : public trf::Algfb
    {
    private:
        Model *m_pModel;
        Seq m_seq;
    public:
        AlgNode(Model *p);
        virtual LogP ClusterSum(int *pSeq, int nLen, int nPos, int nOrder);
    };

#define HHMap(h1, h2) (int)((h1) * 2 + (h2))

#define HRF_VALUE_SET(p, m) \
    memcpy(m.GetBuf(), p, sizeof(PValue)*m.GetSize()); \
    p += m.GetSize();
#define HRF_VALUE_GET(p, m) \
    memcpy(p, m.GetBuf(), sizeof(PValue)*m.GetSize()); \
    p += m.GetSize();


    class Model : public trf::Model
    {
    public:
        int m_hlayer;           
        int m_hnode;            
        Mat3d<PValue> m_m3dVH; 
        Mat3d<PValue> m_m3dCH; 
        Mat3d<PValue> m_m3dHH; 
        Mat<PValue>   m_matBias; 

    protected:
        AlgNode m_nodeCal; 

    public:
        Model(Vocab *pv) :trf::Model(pv), m_hlayer(0), m_hnode(0), m_nodeCal(this),
            m_nSampleHAccTimes(0), m_nSampleHTotalTimes(0),
            m_nLenJumpAccTimes(0), m_nLenJumpTotalTime(0)
        {}
        Model(Vocab *pv, int hlayer, int hnode, int maxlen) : trf::Model(pv, maxlen), 
            m_hlayer(hlayer), m_hnode(hnode), m_nodeCal(this),
            m_nSampleHAccTimes(0), m_nSampleHTotalTimes(0),
            m_nLenJumpAccTimes(0), m_nLenJumpTotalTime(0)
        {
            Reset(pv, hlayer, hnode, maxlen);
        }
        void Reset(Vocab *pv, int hlayer, int hnode, int maxlen);
        int GetHnode() const { return m_hnode; }
        int GetHiddenOrder() const { return 2; }
        int GetParamNum() const { return trf::Model::GetParamNum() + m_m3dVH.GetSize() + m_m3dCH.GetSize() + m_m3dHH.GetSize() + m_matBias.GetSize(); }
        virtual void SetParam(PValue *pParam);
        void GetParam(PValue *pParam);
        LogP GetLogProb(Seq &seq, bool bNorm = true);

        void ReadT(const char *pfilename);
        void WriteT(const char *pfilename);

    public:
        /* Exact calculatation function */
        LogP GetLogProb(VecShell<VocabID> &x, bool bNorm = true);
        LogP ClusterSum(Seq &seq, int nPos, int nOrder);
        LogP HiddenClusterSum(Seq &seq, int nPos, int nOrder);
        LogP FeatClusterSum(trf::Seq &x, int nPos, int nOrder);
        LogP LayerClusterSum(Seq &seq, int nlayer, int nPos, int nOrder);
        double ExactNormalize(int nLen);
        void ExactNormalize();
        LogP GetMarginalLogProb(int nLen, int nPos, Seq &sub, bool bNorm = true);
        void GetNodeExp(double *pExp, Prob *pLenProb = NULL);
        void GetNodeExp(int nLen, double *pExp);
        void GetNodeExp(int nLen, VecShell<double> featexp,
            Mat3dShell<double> VHexp, Mat3dShell<double> CHexp, Mat3dShell<double> HHexp,
            MatShell<double> Bexp);
        void GetHiddenExp(VecShell<int> x, double *pExp);
        void GetLayerExp(AlgLayer &fb, int nLayer,
            Mat3dShell<double> &VHexp, Mat3dShell<double> &CHexp, Mat3dShell<double> &HHexp, MatShell<double> &Bexp,
            LogP logz = 0);

    public:
        int m_nSampleHAccTimes; 
        int m_nSampleHTotalTimes; 
        int m_nLenJumpAccTimes; 
        int m_nLenJumpTotalTime; 
        void Sample(Seq &seq);
        void LocalJump(Seq &seq);
        void MarkovMove(Seq &seq);
        LogP ProposeLength(int nOld, int &nNew, bool bSample);
        LogP ProposeH0(VecShell<HValue> &hi, Seq &seq, int nPos, bool bSample);
        LogP ProposeC0(VocabID &ci, Seq &seq, int nPos, bool bSample);
        /*
        * \param [out] logps return K values, denoting logP(h_{i,k} = 1), k=1,...,K
        * \param [in] seq the sequence.
        * \param [in] nPos position i.
        * \param [in] bConsiderXandC =true mean considering the VH and CH matrix, otherwise only HH matrix.
        * \details The function return the probability of each component and used to sample h_i or calculate Q.
        */
        void ProposeHProbs(VecShell<LogP> &logps, Seq &seq, int nPos, bool bConsiderXandC = false);
        void ProposeCProbs(VecShell<LogP> &logps, Seq &seq, int nPos);
        LogP GetReducedModelForH(Seq &seq, int nPos);
        LogP GetReducedModelForC(Seq &seq, int nPos);
        LogP GetReducedModelForW(Seq &seq, int nPos);
        LogP GetConditionalProbForH(VecShell<HValue> &hi, VecShell<Prob> &probs);
        LogP GetMarginalProbOfC(Seq &seq, int nPos);
        void SampleC(Seq &seq, int nPos);
        /* if bSample=ture, then sample w[nPos]. Otherwise only calculate the conditional probabilities of current w[nPos]. */
        LogP SampleW(Seq &seq, int nPos, bool bSample = true);
        void RandSeq(Seq &seq, int nLen = -1);
        void RandHidden(Seq &seq);
        /* different with SampleH, which using MH sample to sample h
        If tagH != NULL, then just calcualte the transition probability.
        */
        virtual LogP SampleHAndCGivenX(Seq &seq, MatShell<HValue> *tagH = NULL);
        
    public:
        int EncodeNode(VocabID xi, VocabID ci, VecShell<HValue> &hi);
        void EncodeNode(VecShell<int> &vn, Seq &seq, int nPos = 0, int nDim = -1);
        void DecodeNode(int n, VocabID &xi, VocabID &ci, VecShell<HValue> &hi);
        void DecodeNode(VecShell<int> &vn, Seq &seq, int nPos = 0, int nDim = -1);
        int GetEncodeNodeLimit() const;
        int EncodeHidden(VecShell<HValue> hi);
        void DecodeHidden(int n, VecShell<HValue> hi);
        void DecodeHidden(VecShell<int> &vn, Mat<HValue> &h, int nPos = 0, int nDim = -1);
        int GetEncodeHiddenLimit() const;
        void DecodeLayer(VecShell<int> &vn, Mat<HValue> &h, int layer, int nPos = 0, int nDim = -1);
        int GetEncodeLayerLimit() const;

    public:
        template <typename T>
        void BufMap(T *p, VecShell<T> &feat, Mat3dShell<T> &VH, Mat3dShell<T> &CH, Mat3dShell<T> &HH, MatShell<T> &Bias)
        {
            feat.Reset(p, trf::Model::GetParamNum());
            p += feat.GetSize();

            VH.Reset(p, m_m3dVH.GetXDim(), m_m3dVH.GetYDim(), m_m3dVH.GetZDim());
            p += VH.GetSize();
            CH.Reset(p, m_m3dCH.GetXDim(), m_m3dCH.GetYDim(), m_m3dCH.GetZDim());
            p += CH.GetSize();
            HH.Reset(p, m_m3dHH.GetXDim(), m_m3dHH.GetYDim(), m_m3dHH.GetZDim());
            p += HH.GetSize();
            Bias.Reset(p, m_matBias.GetRow(), m_matBias.GetCol());
        }
        void FeatCount(Seq &seq, VecShell<double> featcount,
            Mat3dShell<double> VHcount, Mat3dShell<double> CHcount, Mat3dShell<double> HHcount, 
            MatShell<double> Bcount,
            double dadd = 1);
        void HiddenFeatCount(Seq &seq,
            Mat3dShell<double> VHcount, Mat3dShell<double> CHcount, Mat3dShell<double> HHcount,
            MatShell<double> Bcount,
            double dadd = 1);
        void FeatCount(Seq &seq, VecShell<double> count, double dadd = 1);

    public:
        PValue SumVHWeight(MatShell<PValue> m, VecShell<HValue> h);
        PValue SumHHWeight(Mat3dShell<PValue> m, VecShell<HValue> h1, VecShell<HValue> h2);
        PValue SumVHWeight(MatShell<PValue> m, VecShell<HValue> h, int layer);
        PValue SumHHWeight(Mat3dShell<PValue> m, VecShell<HValue> h1, VecShell<HValue> h2, int layer);

    public:
        void PerformSAMS(int nMinibatch, int tmax, int t0, int beta, double zgap = 10);
        LogP GetLogProb_AIS(VecShell<VocabID> &x, int nChain = 10, int nIntermediate = 10000);
        LogP GetLogProb_Gibbs(VecShell<VocabID> &x, int num = 100);
    };


    class AlgLayer : public trf::Algfb
    {
    public:
        Model *m_pModel;
        Seq m_seq;
        int m_nlayer; 
    public:
        AlgLayer(Model *p, VecShell<VocabID> x, int nlayer);
        virtual LogP ClusterSum(int *pSeq, int nLen, int nPos, int nOrder);
    };

}


#endif