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
|
#include "apply_fsa_models.h"
#include "hg.h"
#include "ff_fsa_dynamic.h"
#include "ff_from_fsa.h"
#include "feature_vector.h"
#include "stringlib.h"
#include "apply_models.h"
#include <stdexcept>
#include <cassert>
#include "cfg.h"
#include "hg_cfg.h"
#include "utoa.h"
using namespace std;
//impl details (not exported). flat namespace for my ease.
typedef CFG::BinRhs BinRhs;
typedef CFG::NTs NTs;
typedef CFG::NT NT;
typedef CFG::NTHandle NTHandle;
typedef CFG::Rules Rules;
typedef CFG::Rule Rule;
typedef CFG::RuleHandle RuleHandle;
namespace {
// if we don't greedy-binarize, we want to encode recognized prefixes p (X -> p . rest) efficiently. if we're doing this, we may as well also push costs so we can best-first select rules in a lazy fashion. this is effectively left-branching binarization, of course.
template <class K,class V>
struct prefix_map_type {
typedef std::map<K,V> type;
};
//template typedef
#define PREFIX_MAP(k,v) prefix_map_type<k,v>::type
typedef NTHandle LHS;
struct PrefixTrieNode {
prob_t backward; // (viterbi) backward prob (for cost pushing)
typedef PREFIX_MAP(LHS,RuleHandle) Completed; // can only have one rule w/ a given signature (duplicates should be collapsed when making CFG). but there may be multiple rules, with different LHS
Completed completed;
typedef PREFIX_MAP(WordID,PrefixTrieNode *) Adj;
Adj adj;
//TODO:
};
struct PrefixTrie {
CFG const* cfgp;
CFG const& cfg() const { return *cfgp; }
PrefixTrie(CFG const& cfg) : cfgp(&cfg) {
//TODO:
}
};
}//anon ns
DEFINE_NAMED_ENUM(FSA_BY)
struct ApplyFsa {
ApplyFsa(HgCFG &i,
const SentenceMetadata& smeta,
const FsaFeatureFunction& fsa,
DenseWeightVector const& weights,
ApplyFsaBy const& by,
Hypergraph* oh
)
:hgcfg(i),smeta(smeta),fsa(fsa),weights(weights),by(by),oh(oh)
{
}
void Compute() {
if (by.IsBottomUp())
ApplyBottomUp();
else
ApplyEarley();
}
void ApplyBottomUp();
void ApplyEarley();
CFG const& GetCFG();
private:
CFG cfg;
HgCFG &hgcfg;
const SentenceMetadata& smeta;
const FsaFeatureFunction& fsa;
// WeightVector weight_vector;
DenseWeightVector weights;
ApplyFsaBy by;
Hypergraph* oh;
std::string cfg_out;
};
void ApplyFsa::ApplyBottomUp()
{
assert(by.IsBottomUp());
FeatureFunctionFromFsa<FsaFeatureFunctionFwd> buff(&fsa);
buff.Init(); // mandatory to call this (normally factory would do it)
vector<const FeatureFunction*> ffs(1,&buff);
ModelSet models(weights, ffs);
IntersectionConfiguration i(by.BottomUpAlgorithm(),by.pop_limit);
ApplyModelSet(hgcfg.ih,smeta,models,i,oh);
}
void ApplyFsa::ApplyEarley()
{
hgcfg.GiveCFG(cfg);
//TODO:
}
void ApplyFsaModels(HgCFG &i,
const SentenceMetadata& smeta,
const FsaFeatureFunction& fsa,
DenseWeightVector const& weight_vector,
ApplyFsaBy const& by,
Hypergraph* oh)
{
ApplyFsa a(i,smeta,fsa,weight_vector,by,oh);
a.Compute();
}
/*
namespace {
char const* anames[]={
"BU_CUBE",
"BU_FULL",
"EARLEY",
0
};
}
*/
//TODO: named enum type in boost?
std::string ApplyFsaBy::name() const {
// return anames[algorithm];
return GetName(algorithm);
}
std::string ApplyFsaBy::all_names() {
return FsaByNames(" ");
/*
std::ostringstream o;
for (int i=0;i<N_ALGORITHMS;++i) {
assert(anames[i]);
if (i) o<<' ';
o<<anames[i];
}
return o.str();
*/
}
ApplyFsaBy::ApplyFsaBy(std::string const& n, int pop_limit) : pop_limit(pop_limit) {
std::string uname=toupper(n);
algorithm=GetFsaBy(uname);
/*anames=0;
while(anames[algorithm] && anames[algorithm] != uname) ++algorithm;
if (!anames[algorithm])
throw std::runtime_error("Unknown ApplyFsaBy type: "+n+" - legal types: "+all_names());
*/
}
ApplyFsaBy::ApplyFsaBy(FsaBy i, int pop_limit) : pop_limit(pop_limit) {
/* if (i<0 || i>=N_ALGORITHMS)
throw std::runtime_error("Unknown ApplyFsaBy type id: "+itos(i)+" - legal types: "+all_names());
*/
GetName(i); // checks validity
algorithm=i;
}
int ApplyFsaBy::BottomUpAlgorithm() const {
assert(IsBottomUp());
return algorithm==BU_CUBE ?
IntersectionConfiguration::CUBE
:IntersectionConfiguration::FULL;
}
void ApplyFsaModels(Hypergraph const& ih,
const SentenceMetadata& smeta,
const FsaFeatureFunction& fsa,
DenseWeightVector const& weights, // pre: in is weighted by these (except with fsa featval=0 before this)
ApplyFsaBy const& cfg,
Hypergraph* out)
{
HgCFG i(ih);
ApplyFsaModels(i,smeta,fsa,weights,cfg,out);
}
|
