blob: a7878f3e718ea47474c834960f5c3d0050787875 (
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
|
#ifndef MERT_REFERENCE_H_
#define MERT_REFERENCE_H_
#include <algorithm>
#include <climits>
#include <vector>
#include "Ngram.h"
namespace MosesTuning
{
/**
* Reference class represents reference translations for an output
* translation used in calculating BLEU score.
*/
class Reference
{
public:
// for m_length
typedef std::vector<std::size_t>::iterator iterator;
typedef std::vector<std::size_t>::const_iterator const_iterator;
Reference() : m_counts(new NgramCounts) { }
~Reference() {
delete m_counts;
}
NgramCounts* get_counts() {
return m_counts;
}
const NgramCounts* get_counts() const {
return m_counts;
}
iterator begin() {
return m_length.begin();
}
const_iterator begin() const {
return m_length.begin();
}
iterator end() {
return m_length.end();
}
const_iterator end() const {
return m_length.end();
}
void push_back(std::size_t len) {
m_length.push_back(len);
}
std::size_t num_references() const {
return m_length.size();
}
int CalcAverage() const;
int CalcClosest(std::size_t length) const;
int CalcShortest() const;
void clear() {
m_length.clear();
m_counts->clear();
}
private:
NgramCounts* m_counts;
// multiple reference lengths
std::vector<std::size_t> m_length;
};
// TODO(tetsuok): fix this function and related stuff.
// "average" reference length should not be calculated at sentence-level unlike "closest".
inline int Reference::CalcAverage() const
{
int total = 0;
for (std::size_t i = 0; i < m_length.size(); ++i) {
total += m_length[i];
}
return static_cast<int>(
static_cast<float>(total) / m_length.size());
}
inline int Reference::CalcClosest(std::size_t length) const
{
int min_diff = INT_MAX;
int closest_ref_id = 0; // an index of the closest reference translation
for (std::size_t i = 0; i < m_length.size(); ++i) {
const int ref_length = m_length[i];
const int length_diff = abs(ref_length - static_cast<int>(length));
const int abs_min_diff = abs(min_diff);
// Look for the closest reference
if (length_diff < abs_min_diff) {
min_diff = ref_length - length;
closest_ref_id = i;
// if two references has the same closest length, take the shortest
} else if (length_diff == abs_min_diff) {
if (ref_length < static_cast<int>(m_length[closest_ref_id])) {
closest_ref_id = i;
}
}
}
return static_cast<int>(m_length[closest_ref_id]);
}
inline int Reference::CalcShortest() const
{
return *std::min_element(m_length.begin(), m_length.end());
}
}
#endif // MERT_REFERENCE_H_
|
