1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
|
// $Id$
/***********************************************************************
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
***********************************************************************/
#pragma once
#include <iostream>
#include <vector>
#include "Phrase.h"
#include "TypeDef.h"
#include "WordsBitmap.h"
#include "Sentence.h"
#include "Phrase.h"
#include "PhraseDictionary.h"
#include "GenerationDictionary.h"
#include "LanguageModel.h"
#include "ScoreComponentCollection.h"
#include "LexicalReordering.h"
#include "Input.h"
#include "ObjectPool.h"
class SquareMatrix;
class StaticData;
class TranslationOption;
class WordsRange;
class Hypothesis;
typedef std::vector<Hypothesis*> ArcList;
class Hypothesis
{
friend std::ostream& operator<<(std::ostream&, const Hypothesis&);
private:
// MD5 checksum for fast comparison
unsigned char m_compSignature[16];
protected:
static ObjectPool<Hypothesis> s_objectPool;
const Hypothesis* m_prevHypo;
const Phrase &m_targetPhrase; //target phrase being created at the current decoding step
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, m_currTargetWordsRange;
bool m_wordDeleted;
float m_totalScore;
float m_futureScore;
ScoreComponentCollection2 m_scoreBreakdown;
std::vector<LanguageModel::State> m_languageModelStates;
#ifdef N_BEST
const Hypothesis *m_mainHypo;
ArcList *m_arcList; //all arcs that end at the same lattice point as we do
#endif
// * \return whether none of the factors clash
// * \param phrase TODO ???
// */
bool IsCompatible(const Phrase &phrase) const;
void CalcFutureScore(const SquareMatrix &futureScore);
//void CalcFutureScore(float futureScore[256][256]);
void CalcLMScore(const LMList &languageModels);
void CalcDistortionScore();
//TODO: add appropriate arguments to score calculator
void GenerateNGramCompareHash() const;
mutable size_t _hash;
mutable bool _hash_computed;
public:
static ObjectPool<Hypothesis> &GetObjectPool()
{
return s_objectPool;
}
static unsigned int s_HypothesesCreated; // Statistics: how many hypotheses were created in total
static unsigned int s_numNodes; // Statistics: how many hypotheses were created in total
int m_id;
Hypothesis(InputType const& source, const TargetPhrase &emptyTarget);
// used for initial seeding of trans process
Hypothesis(const Hypothesis &prevHypo, const TranslationOption &transOpt);
// create next
~Hypothesis();
/***
* return the subclass of Hypothesis most appropriate to the given translation option
*/
static Hypothesis* Create(const Hypothesis &prevHypo, const TranslationOption &transOpt);
/***
* return the subclass of Hypothesis most appropriate to the given target phrase
*/
static Hypothesis* Create(const WordsBitmap &initialCoverage);
/***
* return the subclass of Hypothesis most appropriate to the given target phrase
*/
static Hypothesis* Create(InputType const& source, const TargetPhrase &emptyTarget);
/***
* return the subclass of Hypothesis most appropriate to the given translation option
*/
Hypothesis* CreateNext(const TranslationOption &transOpt) const;
/***
* if any factors aren't set in our target phrase but are present in transOpt, copy them over
* (unless the factors that we do have fail to match the corresponding ones in transOpt,
* in which case presumably there's a programmer's error)
*
* return NULL if we aren't compatible with the given option
*/
void PrintHypothesis( const InputType &source, float weightDistortion, float weightWordPenalty) const;
const Phrase &GetTargetPhrase() 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;
}
// subsequent translation should only translate this sub-phrase
size_t GetCurrTargetLength() const
{
return m_currTargetWordsRange.GetWordsCount();
}
void ResetScore();
void CalcScore(const StaticData& staticData, const SquareMatrix &futureScore);
int GetId() const;
const Hypothesis* GetPrevHypo() const;
// same as for phrase
inline size_t GetSize() const
{
return m_currTargetWordsRange.GetEndPos() + 1;
}
inline const Phrase &GetPhrase() const
{
return m_targetPhrase;
}
inline const InputType &GetSourcePhrase() const
{
return m_sourceInput;
}
std::string GetSourcePhraseStringRep() const;
std::string GetTargetPhraseStringRep() const;
// curr - pos is relative from CURRENT hypothesis's starting ind ex
// (ie, start of sentence would be some negative number, which is
// not allowed- USE WITH CAUTION)
inline const FactorArray &GetCurrFactorArray(size_t pos) const
{
return m_targetPhrase.GetFactorArray(pos);
}
inline const Factor *GetCurrFactor(size_t pos, FactorType factorType) const
{
return m_targetPhrase.GetFactor(pos, factorType);
}
// recursive - pos is relative from start of sentence
inline const FactorArray &GetFactorArray(size_t pos) const
{
const Hypothesis *hypo = this;
while (pos < hypo->GetCurrTargetWordsRange().GetStartPos())
{
hypo = hypo->GetPrevHypo();
assert(hypo != NULL);
}
return hypo->GetCurrFactorArray(pos - hypo->GetCurrTargetWordsRange().GetStartPos());
}
inline const Factor* GetFactor(size_t pos, FactorType factorType) const
{
return GetFactorArray(pos)[factorType];
}
/***
* \return The bitmap of source words we cover
*/
inline const WordsBitmap &GetWordsBitmap() const
{
return m_sourceCompleted;
}
int Hypothesis::NGramCompare(const Hypothesis &compare) const;
inline size_t hash() const
{
if (_hash_computed) return _hash;
GenerateNGramCompareHash();
return _hash;
}
void ToStream(std::ostream& out) const
{
if (m_prevHypo != NULL)
{
m_prevHypo->ToStream(out);
}
out << GetPhrase();
}
TO_STRING;
#ifdef N_BEST
inline void SetMainHypo(const Hypothesis *hypo)
{
m_mainHypo = hypo;
}
void AddArc(Hypothesis *loserHypo);
inline void InitializeArcs()
{
if (!m_arcList) return;
ArcList::iterator iter = m_arcList->begin();
for (; iter != m_arcList->end() ; ++iter)
{
Hypothesis *arc = *iter;
arc->SetMainHypo(this);
}
}
inline const ArcList* GetArcList() const
{
return m_arcList;
}
#endif
const ScoreComponentCollection2& GetScoreBreakdown() const
{
return m_scoreBreakdown;
}
float GetTotalScore() const { return m_totalScore; }
float GetFutureScore() const { return m_futureScore; }
};
std::ostream& operator<<(std::ostream& out, const Hypothesis& hypothesis);
|