blob: cfa517872921ed9501b2d5088de726d610e011ef (
plain)
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
|
#include "ChartTrellisNode.h"
#include "ChartHypothesis.h"
#include "../../moses/src/ScoreComponentCollection.h"
using namespace std;
namespace MosesChart
{
TrellisNode::TrellisNode(const Hypothesis *hypo)
:m_hypo(hypo)
{
const std::vector<const Hypothesis*> &prevHypos = hypo->GetPrevHypos();
for (size_t ind = 0; ind < prevHypos.size(); ++ind)
{
const Hypothesis *prevHypo = prevHypos[ind];
TrellisNode *child = new TrellisNode(prevHypo);
m_edge.push_back(child);
}
assert(m_hypo);
}
TrellisNode::TrellisNode(const TrellisNode &origNode
, const TrellisNode &soughtNode
, const Hypothesis &replacementHypo
, Moses::ScoreComponentCollection &scoreChange
, const TrellisNode *&nodeChanged)
{
if (&origNode.GetHypothesis() == &soughtNode.GetHypothesis())
{ // this node should be replaced
m_hypo = &replacementHypo;
nodeChanged = this;
// scores
assert(scoreChange.GetWeightedScore() == 0); // should only be changing 1 node
scoreChange = replacementHypo.GetScoreBreakDown();
scoreChange.MinusEquals(origNode.GetHypothesis().GetScoreBreakDown());
float deltaScore = scoreChange.GetWeightedScore();
assert(deltaScore <= 0.0005);
// follow prev hypos back to beginning
const std::vector<const Hypothesis*> &prevHypos = replacementHypo.GetPrevHypos();
vector<const Hypothesis*>::const_iterator iter;
for (iter = prevHypos.begin(); iter != prevHypos.end(); ++iter)
{
const Hypothesis *prevHypo = *iter;
TrellisNode *prevNode = new TrellisNode(prevHypo);
m_edge.push_back(prevNode);
}
}
else
{ // not the node we're looking for. Copy as-is and continue finding node
m_hypo = &origNode.GetHypothesis();
NodeChildren::const_iterator iter;
for (iter = origNode.m_edge.begin(); iter != origNode.m_edge.end(); ++iter)
{
const TrellisNode &prevNode = **iter;
TrellisNode *newPrevNode = new TrellisNode(prevNode, soughtNode, replacementHypo, scoreChange, nodeChanged);
m_edge.push_back(newPrevNode);
}
}
assert(m_hypo);
}
TrellisNode::~TrellisNode()
{
Moses::RemoveAllInColl(m_edge);
}
Moses::Phrase TrellisNode::GetOutputPhrase() const
{
// exactly like same fn in hypothesis, but use trellis nodes instead of prevHypos pointer
Moses::Phrase ret(Moses::Output);
const Moses::Phrase &currTargetPhrase = m_hypo->GetCurrTargetPhrase();
for (size_t pos = 0; pos < currTargetPhrase.GetSize(); ++pos)
{
const Moses::Word &word = currTargetPhrase.GetWord(pos);
if (word.IsNonTerminal())
{ // non-term. fill out with prev hypo
size_t nonTermInd = m_hypo->GetWordsConsumedTargetOrder(pos);
const TrellisNode &childNode = GetChild(nonTermInd);
Moses::Phrase childPhrase = childNode.GetOutputPhrase();
ret.Append(childPhrase);
}
else
{
ret.AddWord(word);
}
}
return ret;
}
std::ostream& operator<<(std::ostream &out, const TrellisNode &node)
{
out << "* " << node.GetHypothesis() << endl;
TrellisNode::NodeChildren::const_iterator iter;
for (iter = node.GetChildren().begin(); iter != node.GetChildren().end(); ++iter)
{
out << **iter;
}
return out;
}
}
|
