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
|
// $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
***********************************************************************/
#ifndef moses_TargetPhrase_h
#define moses_TargetPhrase_h
#include <vector>
#include "TypeDef.h"
#include "Phrase.h"
#include "ScoreComponentCollection.h"
#include "AlignmentInfo.h"
#include "util/string_piece.hh"
#ifdef HAVE_PROTOBUF
#include "rule.pb.h"
#endif
namespace Moses
{
class FeatureFunction;
/** represents an entry on the target side of a phrase table (scores, translation, alignment)
*/
class TargetPhrase: public Phrase
{
friend std::ostream& operator<<(std::ostream&, const TargetPhrase&);
protected:
float m_fullScore, m_futureScore;
ScoreComponentCollection m_scoreBreakdown;
// in case of confusion net, ptr to source phrase
Phrase m_sourcePhrase;
const AlignmentInfo* m_alignTerm, *m_alignNonTerm;
const Word *m_lhsTarget;
public:
TargetPhrase();
TargetPhrase(const TargetPhrase ©);
explicit TargetPhrase(std::string out_string);
explicit TargetPhrase(const Phrase &targetPhrase);
~TargetPhrase();
void Evaluate(const Phrase &source);
void Evaluate(const Phrase &source, const std::vector<FeatureFunction*> &ffs);
void Evaluate(const InputType &input);
void SetSparseScore(const FeatureFunction* translationScoreProducer, const StringPiece &sparseString);
// used to set translation or gen score
void SetXMLScore(float score);
void SetInputScore(const Scores &scoreVector);
#ifdef HAVE_PROTOBUF
void WriteToRulePB(hgmert::Rule* pb) const;
#endif
/***
* return the estimated score resulting from our being added to a sentence
* (it's an estimate because we don't have full n-gram info for the language model
* without using the (unknown) full sentence)
*
*/
inline float GetFutureScore() const {
return m_fullScore;
}
inline const ScoreComponentCollection &GetScoreBreakdown() const {
return m_scoreBreakdown;
}
inline ScoreComponentCollection &GetScoreBreakdown() {
return m_scoreBreakdown;
}
//TODO: Probably shouldn't copy this, but otherwise ownership is unclear
void SetSourcePhrase(const Phrase& p) {
m_sourcePhrase=p;
}
const Phrase& GetSourcePhrase() const {
return m_sourcePhrase;
}
void SetTargetLHS(const Word *lhs) {
m_lhsTarget = lhs;
}
const Word &GetTargetLHS() const {
return *m_lhsTarget;
}
void SetAlignmentInfo(const StringPiece &alignString);
void SetAlignTerm(const AlignmentInfo *alignTerm) {
m_alignTerm = alignTerm;
}
void SetAlignNonTerm(const AlignmentInfo *alignNonTerm) {
m_alignNonTerm = alignNonTerm;
}
void SetAlignTerm(const AlignmentInfo::CollType &coll);
void SetAlignNonTerm(const AlignmentInfo::CollType &coll);
const AlignmentInfo &GetAlignTerm() const {
return *m_alignTerm;
}
const AlignmentInfo &GetAlignNonTerm() const {
return *m_alignNonTerm;
}
void Merge(const TargetPhrase ©, const std::vector<FactorType>& factorVec);
TO_STRING();
};
std::ostream& operator<<(std::ostream&, const TargetPhrase&);
/**
* Hasher that looks at source and target phrase.
**/
struct TargetPhraseHasher {
inline size_t operator()(const TargetPhrase& targetPhrase) const {
size_t seed = 0;
boost::hash_combine(seed, targetPhrase);
boost::hash_combine(seed, targetPhrase.GetSourcePhrase());
boost::hash_combine(seed, targetPhrase.GetAlignTerm());
boost::hash_combine(seed, targetPhrase.GetAlignNonTerm());
return seed;
}
};
struct TargetPhraseComparator {
inline bool operator()(const TargetPhrase& lhs, const TargetPhrase& rhs) const {
return lhs.Compare(rhs) == 0 &&
lhs.GetSourcePhrase().Compare(rhs.GetSourcePhrase()) == 0 &&
lhs.GetAlignTerm() == rhs.GetAlignTerm() &&
lhs.GetAlignNonTerm() == rhs.GetAlignNonTerm();
}
};
}
#endif
|
