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
|
#include "score.h"
namespace dtrain
{
/******************************************************************************
* NGRAMS
*
*
* make_ngrams
*
*/
typedef map<vector<WordID>, size_t> Ngrams;
Ngrams
make_ngrams( vector<WordID>& s, size_t N )
{
Ngrams ngrams;
vector<WordID> ng;
for ( size_t i = 0; i < s.size(); i++ ) {
ng.clear();
for ( size_t j = i; j < min( i+N, s.size() ); j++ ) {
ng.push_back( s[j] );
ngrams[ng]++;
}
}
return ngrams;
}
/*
* ngram_matches
*
*/
NgramCounts
make_ngram_counts( vector<WordID> hyp, vector<WordID> ref, size_t N )
{
Ngrams hyp_ngrams = make_ngrams( hyp, N );
Ngrams ref_ngrams = make_ngrams( ref, N );
NgramCounts counts( N );
Ngrams::iterator it;
Ngrams::iterator ti;
for ( it = hyp_ngrams.begin(); it != hyp_ngrams.end(); it++ ) {
ti = ref_ngrams.find( it->first );
if ( ti != ref_ngrams.end() ) {
counts.add( it->second, ti->second, it->first.size() - 1 );
} else {
counts.add( it->second, 0, it->first.size() - 1 );
}
}
return counts;
}
/******************************************************************************
* SCORES
*
*
* brevity_penaly
*
*/
double
brevity_penaly( const size_t hyp_len, const size_t ref_len )
{
if ( hyp_len > ref_len ) return 1;
return exp( 1 - (double)ref_len/(double)hyp_len );
}
/*
* bleu
* as in "BLEU: a Method for Automatic Evaluation of Machine Translation" (Papineni et al. '02)
* page TODO
* 0 if for N one of the counts = 0
*/
double
bleu( NgramCounts& counts, const size_t hyp_len, const size_t ref_len,
size_t N, vector<float> weights )
{
if ( hyp_len == 0 || ref_len == 0 ) return 0;
if ( ref_len < N ) N = ref_len;
float N_ = (float)N;
if ( weights.empty() )
{
for ( size_t i = 0; i < N; i++ ) weights.push_back( 1/N_ );
}
double sum = 0;
for ( size_t i = 0; i < N; i++ ) {
if ( counts.clipped[i] == 0 || counts.sum[i] == 0 ) return 0;
sum += weights[i] * log( (double)counts.clipped[i] / (double)counts.sum[i] );
}
return brevity_penaly( hyp_len, ref_len ) * exp( sum );
}
/*
* stupid_bleu
* as in "ORANGE: a Method for Evaluating Automatic Evaluation Metrics for Machine Translation (Lin & Och '04)
* page TODO
* 0 iff no 1gram match
*/
double
stupid_bleu( NgramCounts& counts, const size_t hyp_len, const size_t ref_len,
size_t N, vector<float> weights )
{
if ( hyp_len == 0 || ref_len == 0 ) return 0;
if ( ref_len < N ) N = ref_len;
float N_ = (float)N;
if ( weights.empty() )
{
for ( size_t i = 0; i < N; i++ ) weights.push_back( 1/N_ );
}
double sum = 0;
float add = 0;
for ( size_t i = 0; i < N; i++ ) {
if ( i == 1 ) add = 1;
sum += weights[i] * log( ((double)counts.clipped[i] + add) / ((double)counts.sum[i] + add) );
}
return brevity_penaly( hyp_len, ref_len ) * exp( sum );
}
/*
* smooth_bleu
* as in "An End-to-End Discriminative Approach to Machine Translation" (Liang et al. '06)
* page TODO
* max. 0.9375
*/
double
smooth_bleu( NgramCounts& counts, const size_t hyp_len, const size_t ref_len,
const size_t N, vector<float> weights )
{
if ( hyp_len == 0 || ref_len == 0 ) return 0;
float N_ = (float)N;
if ( weights.empty() )
{
for ( size_t i = 0; i < N; i++ ) weights.push_back( 1/N_ );
}
double sum = 0;
float j = 1;
for ( size_t i = 0; i < N; i++ ) {
if ( counts.clipped[i] == 0 || counts.sum[i] == 0) continue;
sum += exp((weights[i] * log((double)counts.clipped[i]/(double)counts.sum[i]))) / pow( 2, N_-j+1 );
j++;
}
return brevity_penaly( hyp_len, ref_len ) * sum;
}
/*
* approx_bleu
* as in "Online Large-Margin Training for Statistical Machine Translation" (Watanabe et al. '07)
* page TODO
*
*/
double
approx_bleu( NgramCounts& counts, const size_t hyp_len, const size_t ref_len,
const size_t N, vector<float> weights )
{
return bleu( counts, hyp_len, ref_len, N, weights );
}
} // namespace
|
