mosesdecoder/moses/src/Hypothesis.h

Go to the documentation of this file.

// $Id$
// vim:tabstop=2

/***********************************************************************
Moses - factored phrase-based language decoder
Copyright (C) 2006 University of Edinburgh

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library 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
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
***********************************************************************/

#ifndef moses_Hypothesis_h
#define moses_Hypothesis_h

#include <iostream>
#include <vector>
#include "Phrase.h"
#include "TypeDef.h"
#include "WordsBitmap.h"
#include "Sentence.h"
#include "Phrase.h"
#include "PhraseDictionaryMemory.h"
#include "GenerationDictionary.h"
#include "ScoreComponentCollection.h"
#include "InputType.h"
#include "ObjectPool.h"

namespace Moses
{

class SquareMatrix;
class StaticData;
class TranslationOption;
class WordsRange;
class Hypothesis;
class FFState;
class Manager;
class LexicalReordering;

typedef std::vector<Hypothesis*> ArcList;

class Hypothesis
{
  friend std::ostream& operator<<(std::ostream&, const Hypothesis&);

protected:
  static ObjectPool<Hypothesis> s_objectPool;

  const Hypothesis* m_prevHypo; 
//      const Phrase                    &m_targetPhrase; /*! target phrase being created at the current decoding step */
  const TargetPhrase                    &m_targetPhrase; 
  Phrase const*     m_sourcePhrase; 
  WordsBitmap                           m_sourceCompleted; 
  //TODO: how to integrate this into confusion network framework; what if
  //it's a confusion network in the end???
  InputType const&  m_sourceInput;
  WordsRange                            m_currSourceWordsRange; 
  WordsRange        m_currTargetWordsRange; 
  bool                                                  m_wordDeleted;
  float                                                 m_totalScore;  
  float                                                 m_futureScore; 
  ScoreComponentCollection m_scoreBreakdown; 
  std::vector<const FFState*> m_ffStates;
  const Hypothesis      *m_winningHypo;
  ArcList                                       *m_arcList; 
  const TranslationOption *m_transOpt;
  Manager& m_manager;

  int m_id; 
  Hypothesis(Manager& manager, InputType const& source, const TargetPhrase &emptyTarget);
  Hypothesis(const Hypothesis &prevHypo, const TranslationOption &transOpt);

public:
  static ObjectPool<Hypothesis> &GetObjectPool() {
    return s_objectPool;
  }

  ~Hypothesis();

  static Hypothesis* Create(const Hypothesis &prevHypo, const TranslationOption &transOpt, const Phrase* constraint);

  static Hypothesis* Create(Manager& manager, const WordsBitmap &initialCoverage);

  static Hypothesis* Create(Manager& manager, InputType const& source, const TargetPhrase &emptyTarget);

  Hypothesis* CreateNext(const TranslationOption &transOpt, const Phrase* constraint) const;

  void PrintHypothesis() const;

  const InputType& GetInput() const {
    return m_sourceInput;
  }

//      const Phrase &GetCurrTargetPhrase() const
  const TargetPhrase &GetCurrTargetPhrase() const {
    return m_targetPhrase;
  }

// void PrintLMScores(const LMList &lmListInitial, const LMList &lmListEnd) const;

  inline const WordsRange &GetCurrSourceWordsRange() const {
    return m_currSourceWordsRange;
  }

  inline const WordsRange &GetCurrTargetWordsRange() const {
    return m_currTargetWordsRange;
  }

  Manager& GetManager() const {
    return m_manager;
  }

  inline size_t GetCurrTargetLength() const {
    return m_currTargetWordsRange.GetNumWordsCovered();
  }

  void ResetScore();

  void CalcScore(const SquareMatrix &futureScore);

  float CalcExpectedScore( const SquareMatrix &futureScore );
  void CalcRemainingScore();

  int GetId()const {
    return m_id;
  }

  const Hypothesis* GetPrevHypo() const;

  inline size_t GetSize() const {
    return m_currTargetWordsRange.GetEndPos() + 1;
  }

  inline const Phrase* GetSourcePhrase() const {
    return m_sourcePhrase;
  }

  std::string GetSourcePhraseStringRep(const std::vector<FactorType> factorsToPrint) const;
  std::string GetTargetPhraseStringRep(const std::vector<FactorType> factorsToPrint) const;
  std::string GetSourcePhraseStringRep() const;
  std::string GetTargetPhraseStringRep() const;

  inline const Word &GetCurrWord(size_t pos) const {
    return m_targetPhrase.GetWord(pos);
  }
  inline const Factor *GetCurrFactor(size_t pos, FactorType factorType) const {
    return m_targetPhrase.GetFactor(pos, factorType);
  }
  inline const Word &GetWord(size_t pos) const {
    const Hypothesis *hypo = this;
    while (pos < hypo->GetCurrTargetWordsRange().GetStartPos()) {
      hypo = hypo->GetPrevHypo();
      CHECK(hypo != NULL);
    }
    return hypo->GetCurrWord(pos - hypo->GetCurrTargetWordsRange().GetStartPos());
  }
  inline const Factor* GetFactor(size_t pos, FactorType factorType) const {
    return GetWord(pos)[factorType];
  }

  /***
   * \return The bitmap of source words we cover
   */
  inline const WordsBitmap &GetWordsBitmap() const {
    return m_sourceCompleted;
  }

  inline bool IsSourceCompleted() const {
    return m_sourceCompleted.IsComplete();
  }

  int RecombineCompare(const Hypothesis &compare) const;

  void ToStream(std::ostream& out) const {
    if (m_prevHypo != NULL) {
      m_prevHypo->ToStream(out);
    }
    out << (Phrase) GetCurrTargetPhrase();
  }

  TO_STRING();

  inline void SetWinningHypo(const Hypothesis *hypo) {
    m_winningHypo = hypo;
  }
  inline const Hypothesis *GetWinningHypo() const {
    return m_winningHypo;
  }

  void AddArc(Hypothesis *loserHypo);
  void CleanupArcList();

  inline const ArcList* GetArcList() const {
    return m_arcList;
  }
  const ScoreComponentCollection& GetScoreBreakdown() const {
    return m_scoreBreakdown;
  }
  float GetTotalScore() const {
    return m_totalScore;
  }
  float GetScore() const {
    return m_totalScore-m_futureScore;
  }




  size_t GetNextStartPos(const TranslationOption &transOpt) const;

  std::vector<std::vector<unsigned int> > *GetLMStats() const {
    return NULL;
  }

  const TranslationOption &GetTranslationOption() const {
    return *m_transOpt;
  }
};

std::ostream& operator<<(std::ostream& out, const Hypothesis& hypothesis);

// sorting helper
struct CompareHypothesisTotalScore {
  bool operator()(const Hypothesis* hypo1, const Hypothesis* hypo2) const {
    return hypo1->GetTotalScore() > hypo2->GetTotalScore();
  }
};

#ifdef USE_HYPO_POOL

#define FREEHYPO(hypo) \
{ \
        ObjectPool<Hypothesis> &pool = Hypothesis::GetObjectPool(); \
        pool.freeObject(hypo); \
} \
 
#else
#define FREEHYPO(hypo) delete hypo
#endif

class HypothesisRecombinationOrderer
{
public:
  bool operator()(const Hypothesis* hypoA, const Hypothesis* hypoB) const {
    return (hypoA->RecombineCompare(*hypoB) < 0);
  }
};

}
#endif

---