Moses: mosesdecoder/moses/src/DummyScoreProducers.cpp Source File

00001 // $Id$
00002 
00003 #include "util/check.hh"
00004 #include "FFState.h"
00005 #include "StaticData.h"
00006 #include "DummyScoreProducers.h"
00007 #include "WordsRange.h"
00008 #include "TranslationOption.h"
00009 
00010 namespace Moses
00011 {
00012 
00013 struct DistortionState_traditional : public FFState {
00014   WordsRange range;
00015   int first_gap;
00016   DistortionState_traditional(const WordsRange& wr, int fg) : range(wr), first_gap(fg) {}
00017   int Compare(const FFState& other) const {
00018     const DistortionState_traditional& o =
00019       static_cast<const DistortionState_traditional&>(other);
00020     if (range.GetEndPos() < o.range.GetEndPos()) return -1;
00021     if (range.GetEndPos() > o.range.GetEndPos()) return 1;
00022     return 0;
00023   }
00024 };
00025 
00026 const FFState* DistortionScoreProducer::EmptyHypothesisState(const InputType &input) const
00027 {
00028   // fake previous translated phrase start and end
00029   size_t start = NOT_FOUND;
00030   size_t end = NOT_FOUND;
00031   if (input.m_frontSpanCoveredLength > 0) {
00032     // can happen with --continue-partial-translation
00033     start = 0;
00034     end = input.m_frontSpanCoveredLength -1;
00035   }
00036   return new DistortionState_traditional(
00037            WordsRange(start, end),
00038            NOT_FOUND);
00039 }
00040 
00041 DistortionScoreProducer::DistortionScoreProducer(ScoreIndexManager &scoreIndexManager)
00042 {
00043   scoreIndexManager.AddScoreProducer(this);
00044 }
00045 
00046 size_t DistortionScoreProducer::GetNumScoreComponents() const
00047 {
00048   return 1;
00049 }
00050 
00051 std::string DistortionScoreProducer::GetScoreProducerDescription(unsigned) const
00052 {
00053   return "Distortion";
00054 }
00055 
00056 std::string DistortionScoreProducer::GetScoreProducerWeightShortName(unsigned) const
00057 {
00058   return "d";
00059 }
00060 
00061 float DistortionScoreProducer::CalculateDistortionScore(const Hypothesis& hypo,
00062     const WordsRange &prev, const WordsRange &curr, const int FirstGap) const
00063 {
00064   const int USE_OLD = 1;
00065   if (USE_OLD) {
00066     return - (float) hypo.GetInput().ComputeDistortionDistance(prev, curr);
00067   }
00068 
00069   // Pay distortion score as soon as possible, from Moore and Quirk MT Summit 2007
00070 
00071   int prefixEndPos = FirstGap-1;
00072   if ((int) curr.GetStartPos() == prefixEndPos+1) {
00073     return 0;
00074   }
00075 
00076   if ((int) curr.GetEndPos() < (int) prev.GetEndPos()) {
00077     return (float) -2*curr.GetNumWordsCovered();
00078   }
00079 
00080   if ((int) prev.GetEndPos() <= prefixEndPos) {
00081     int z = curr.GetStartPos()-prefixEndPos;
00082     return (float) -2*(z + curr.GetNumWordsCovered());
00083   }
00084 
00085   return (float) -2*(curr.GetNumWordsBetween(prev) + curr.GetNumWordsCovered());
00086 }
00087 
00088 size_t DistortionScoreProducer::GetNumInputScores() const
00089 {
00090   return 0;
00091 }
00092 
00093 FFState* DistortionScoreProducer::Evaluate(
00094   const Hypothesis& hypo,
00095   const FFState* prev_state,
00096   ScoreComponentCollection* out) const
00097 {
00098   const DistortionState_traditional* prev = static_cast<const DistortionState_traditional*>(prev_state);
00099   const float distortionScore = CalculateDistortionScore(
00100                                   hypo,
00101                                   prev->range,
00102                                   hypo.GetCurrSourceWordsRange(),
00103                                   prev->first_gap);
00104   out->PlusEquals(this, distortionScore);
00105   DistortionState_traditional* res = new DistortionState_traditional(
00106     hypo.GetCurrSourceWordsRange(),
00107     hypo.GetPrevHypo()->GetWordsBitmap().GetFirstGapPos());
00108   return res;
00109 }
00110 
00111 
00112 WordPenaltyProducer::WordPenaltyProducer(ScoreIndexManager &scoreIndexManager)
00113 {
00114   scoreIndexManager.AddScoreProducer(this);
00115 }
00116 
00117 size_t WordPenaltyProducer::GetNumScoreComponents() const
00118 {
00119   return 1;
00120 }
00121 
00122 std::string WordPenaltyProducer::GetScoreProducerDescription(unsigned) const
00123 {
00124   return "WordPenalty";
00125 }
00126 
00127 std::string WordPenaltyProducer::GetScoreProducerWeightShortName(unsigned) const
00128 {
00129   return "w";
00130 }
00131 
00132 size_t WordPenaltyProducer::GetNumInputScores() const
00133 {
00134   return 0;
00135 }
00136 
00137 void WordPenaltyProducer::Evaluate(const TargetPhrase& tp, ScoreComponentCollection* out) const
00138 {
00139   out->PlusEquals(this, -static_cast<float>(tp.GetSize()));
00140 }
00141 
00142 UnknownWordPenaltyProducer::UnknownWordPenaltyProducer(ScoreIndexManager &scoreIndexManager)
00143 {
00144   scoreIndexManager.AddScoreProducer(this);
00145 }
00146 
00147 size_t UnknownWordPenaltyProducer::GetNumScoreComponents() const
00148 {
00149   return 1;
00150 }
00151 
00152 std::string UnknownWordPenaltyProducer::GetScoreProducerDescription(unsigned) const
00153 {
00154   return "!UnknownWordPenalty";
00155 }
00156 
00157 std::string UnknownWordPenaltyProducer::GetScoreProducerWeightShortName(unsigned) const
00158 {
00159   return "u";
00160 }
00161 
00162 size_t UnknownWordPenaltyProducer::GetNumInputScores() const
00163 {
00164   return 0;
00165 }
00166 
00167 bool UnknownWordPenaltyProducer::ComputeValueInTranslationOption() const
00168 {
00169   return true;
00170 }
00171 
00172 }