trf-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.


#pragma once
#include "trf-feature.h"
#include "trf-alg.h"
#include <omp.h>

namespace trf
{


    class Model;

    class AlgNode : public Algfb
    {
    private:
        Model *m_pModel;
        Seq m_seq;
    public:
        AlgNode(Model *p) :m_pModel(p){};
        virtual LogP ClusterSum(int *pSeq, int nLen, int nPos, int nOrder);
    };
    class Model
    {
    public:
        Feat *m_pFeat;   
        Vec<PValue> m_value; 

        int m_maxlen; 
        Vec<Prob> m_pi; 
        Vec<LogP> m_logz; 
        Vec<LogP> m_zeta; 

        Vocab *m_pVocab;

        Mat<Prob> m_matLenJump; 
        int m_maxSampleLen; 

    protected:
        AlgNode m_AlgNode; 

    public:
        Model(Vocab *pv) :
            m_pFeat(NULL),
            m_maxlen(0),
            m_pVocab(pv),
            m_AlgNode(this){
            m_nLenJumpAccTimes = 0;
            m_nLenJumpTotalTime = 0;
            m_nSampleHAccTimes = 0;
            m_nSampleHTotalTimes = 0;
        };
        Model(Vocab *pv, int maxlen) :
            m_pFeat(NULL),
            m_maxlen(0),
            m_pVocab(pv),
            m_AlgNode(this) {
            Reset(pv, maxlen);
            m_nLenJumpAccTimes = 0;
            m_nLenJumpTotalTime = 0;
            m_nSampleHAccTimes = 0;
            m_nSampleHTotalTimes = 0;
        }
        ~Model()
        {
            SAFE_DELETE(m_pFeat);
        }
        int GetMaxLen() const { return m_maxlen; }
        Vocab *GetVocab() const { return m_pVocab; }
        int GetMaxOrder() const { return m_pFeat->GetMaxOrder(); }
        int GetParamNum() const { return (m_pFeat) ? m_pFeat->GetNum() : 0; }
        void Reset(Vocab *pv, int maxlen);
        virtual void SetParam(PValue *pValue);
        void GetParam(PValue *pValue);
        void SetPi(Prob *pPi);
        template <typename T>
        void SetZeta(T *pzeta)
        {
            ExactNormalize(1);
            for (int i = 1; i <= m_maxlen; i++) {
                m_zeta[i] = (LogP)( pzeta[i] - pzeta[1] );
                m_logz[i] = (LogP)( m_zeta[i] + m_logz[1] );
            }
        }
        template <typename T>
        void GetZeta(T *pzeta)
        {
            for (int i = 1; i <= m_maxlen; i++) {
                pzeta[i] = (T) m_zeta[i];
            }
        }
        LogP GetLogProb(Seq &seq, bool bNorm = true);
        void LoadFromCorpus(const char *pcorpus, const char *pfeatstyle, int nOrder);
        void FeatCount(Seq &seq, double *pCount, double dadd = 1.0);

        void ReadT(const char *pfilename);
        void WriteT(const char *pfilename);
//      void ReadB(const char *pfilename);
//      /// Write Binary
//      void WriteB(const char *pfilename);

        /************************************************************************/
        /*exactly calculation functions                                         */
        /************************************************************************/
    public:
        LogP ClusterSum(Seq &seq, int nPos, int nOrder);
        virtual double ExactNormalize(int nLen);
        virtual void ExactNormalize();
        void GetNodeExp(int nLen, double *pExp);
        void GetNodeExp(double *pExp, Prob *pLenProb = NULL);

        /************************************************************************/
        /*sampling functions                                                    */
        /************************************************************************/
    public:
        int m_nLenJumpAccTimes; 
        int m_nLenJumpTotalTime; 
        int m_nSampleHAccTimes; 
        int m_nSampleHTotalTimes; 
        void Sample(Seq &seq);
        void LocalJump(Seq &seq);
        virtual void MarkovMove(Seq &seq);
        LogP ProposeLength(int nOld, int &nNew, bool bSample);
        LogP ProposeC0(VocabID &ci, Seq &seq, int nPos, bool bSample);
        void ProposeCProbs(VecShell<LogP> &logps, Seq &seq, int nPos);
        /* To reduce the computation cost, we using the following function to replace GetLogProb
           when sampling c_i at position i in function ProposeCProbs and ProposeC0.
           There we only consinder the features depending on c_i and indenpending with w_i,
           i.e. calculating the propose prob without knowing the w_i at position i.
        */
        LogP GetReducedModelForC(Seq &seq, int nPos);
        LogP GetReducedModelForW(Seq &seq, int nPos);
        LogP GetReducedModel(Seq &seq, int nPos);
        LogP GetMarginalProbOfC(Seq &seq, int nPos);
        /* the only differnece with ProposeC0 is than
           SampleC will accept the current class after propose it.
           While ProposeC0 not.
           ProposeC0 used in local jump. It cannot accept the propose c0 as there is no intial value of c_i.
           SampleC used in Markov move.
        */
        void SampleC(Seq &seq, int nPos);
        /* if bSample=ture, then sample x[nPos]. Otherwise only calculate the conditional probabilities of current x[nPos]. */
        LogP SampleX(Seq &seq, int nPos, bool bSample = true);
    public:
        LogP AISNormalize(int nLen, int nChain, int nInter);
        void AISNormalize(int nLenMin, int nLenMax, int nChain, int nInter);
    };

    class Model_FastSample : public Model
    {
    public:
        int m_nMHtimes;
    public:
        Model_FastSample(Vocab *pv) :Model(pv) {
            m_nMHtimes = 1;
        }
        Model_FastSample(Vocab *pv, int maxlen) :Model(pv, maxlen) {
            m_nMHtimes = 1;
        }
        LogP ProposeW0(VocabID &wi, Seq &seq, int nPos, bool bSample = true)
        {
            Array<VocabID> *pXs = m_pVocab->GetWord(seq.x[class_layer][nPos]);
            Array<LogP> aLogps;

            VocabID nSaveX = seq.x[word_layer][nPos]; // save w[nPos]
            for (int i = 0; i < pXs->GetNum(); i++) {
                seq.x[word_layer][nPos] = pXs->Get(i);

//              LogP d = 0;
//              Array<int> afeat;
//              m_pFeat->Find(afeat, seq, nPos, 1);
//              for (int i = 0; i < afeat.GetNum(); i++)
//                  d += m_value[afeat[i]];
                aLogps[i] = 1; //GetReducedModelForW(seq, nPos);
            }
            seq.x[word_layer][nPos] = nSaveX;
            LogLineNormalize(aLogps, pXs->GetNum());

            int idx;
            if (bSample) {
                /* sample a value for x[nPos] */
                idx = LogLineSampling(aLogps, pXs->GetNum());
                wi = pXs->Get(idx);
            }
            else {
                idx = pXs->Find(nSaveX); // find nSave in the array.
                if (idx == -1) {
                    lout_error("Can't find the VocabID(" << nSaveX << ") in the array.\n"
                        << "This may beacuse word(" << nSaveX << ") doesnot belongs to class("
                        << seq.x[class_layer][nPos] << ")");
                }
            }

            return aLogps[idx];
        }

        void ProposeCProbs(VecShell<LogP> &logps, Seq &seq, int nPos)
        {
            VocabID savecid = seq.x[class_layer][nPos];
            for (int cid = 0; cid < m_pVocab->GetClassNum(); cid++) {
                seq.x[class_layer][nPos] = cid;
                logps[cid] = 1;
            }
            seq.x[class_layer][nPos] = savecid;
            LogLineNormalize(logps.GetBuf(), m_pVocab->GetClassNum());
        }

        void MarkovMove(Seq &seq)
        {
            for (int i = 0; i < seq.GetLen(); i++)
                SamplePos(seq, i);
        }
        void SamplePos(Seq &seq, int nPos)
        {
            for (int times = 0; times < m_nMHtimes; times++)
            {

                VocabID old_c = seq.x[class_layer][nPos];
                VocabID old_w = seq.x[word_layer][nPos];
                LogP pold = GetReducedModel(seq, nPos);


                VocabID prop_c = omp_nrand(0, m_pVocab->GetClassNum());
                Array<VocabID> *pWords = m_pVocab->GetWord(prop_c);
                int prop_w_id = omp_nrand(0, pWords->GetNum());
                VocabID prop_w = pWords->Get(prop_w_id);

                seq.x[class_layer][nPos] = prop_c;
                seq.x[word_layer][nPos] = prop_w;
                LogP pnew = GetReducedModel(seq, nPos);

                LogP g_old = Prob2LogP(1.0 / m_pVocab->GetClassNum()) + Prob2LogP(1.0 / m_pVocab->GetWord(old_c)->GetNum());
                LogP g_new = Prob2LogP(1.0 / m_pVocab->GetClassNum()) + Prob2LogP(1.0 / m_pVocab->GetWord(prop_c)->GetNum());
                LogP acclogp = pnew + g_old - (pold + g_new);

                if (Acceptable(LogP2Prob(acclogp))) {
                    m_nSampleHAccTimes++;
                    seq.x[class_layer][nPos] = prop_c;
                    seq.x[word_layer][nPos] = prop_w;
                }
                else {
                    seq.x[class_layer][nPos] = old_c;
                    seq.x[word_layer][nPos] = old_w;
                }
                m_nSampleHTotalTimes++;

                lout_assert(seq.x[class_layer][nPos] == m_pVocab->GetClass(seq.x[word_layer][nPos]));
            }

//          Vec<LogP> vlogps_c(m_pVocab->GetClassNum());
//          ProposeCProbs(vlogps_c, seq, nPos);
//          VocabID ci = seq.x[class_layer][nPos];
//          VocabID C0 = LogLineSampling(vlogps_c.GetBuf(), vlogps_c.GetSize());
//          LogP gci = vlogps_c[ci];
//          LogP gc0 = vlogps_c[C0];
//
//          VocabID wi = seq.x[word_layer][nPos];
//          VocabID w0;
//          seq.x[class_layer][nPos] = ci;
//          LogP gwi_ci = ProposeW0(wi, seq, nPos, false);
//          seq.x[class_layer][nPos] = C0;
//          LogP gw0_c0 = ProposeW0(w0, seq, nPos, true);
//
//          seq.x[class_layer][nPos] = ci;
//          seq.x[word_layer][nPos] = wi;
//          LogP pold = GetReducedModel(seq, nPos);
//          seq.x[class_layer][nPos] = C0;
//          seq.x[word_layer][nPos] = w0;
//          LogP pnew = GetReducedModel(seq, nPos);
//
//          LogP acclogp = pnew + gci + gwi_ci - (pold + gc0 + gw0_c0);
//          if (Acceptable(LogP2Prob(acclogp))) {
//              m_nSampleHAccTimes++;
//              seq.x[class_layer][nPos] = C0;
//              seq.x[word_layer][nPos] = w0;
//          }
//          else {
//              seq.x[class_layer][nPos] = ci;
//              seq.x[word_layer][nPos] = wi;
//          }
//          m_nSampleHTotalTimes++;
        }
    };
}