summaryrefslogtreecommitdiff
path: root/dtrain/score.h
blob: 0afb62370497e13bf8086957fc0647e4ba1d00ad (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
#ifndef _DTRAIN_SCORE_H_
#define _DTRAIN_SCORE_H_

#include <iostream>
#include <vector>
#include <map>
#include <cassert>
#include <cmath>

#include "wordid.h" // cdec

using namespace std;

namespace dtrain
{


struct NgramCounts
{
  NgramCounts(const size_t N) : N_(N) {
    reset();
  } 
  size_t N_;
  map<size_t, size_t> clipped;
  map<size_t, size_t> sum;

  void
  operator+=(const NgramCounts& rhs)
  {
    assert(N_ == rhs.N_);
    for (size_t i = 0; i < N_; i++) {
      this->clipped[i] += rhs.clipped.find(i)->second;
      this->sum[i] += rhs.sum.find(i)->second;
    }
  }

  const NgramCounts
  operator+(const NgramCounts &other) const
  {
    NgramCounts result = *this;
    result += other;
    return result;
  }

  void
  add(size_t count, size_t ref_count, size_t i)
  {
    assert(i < N_);
    if (count > ref_count) {
      clipped[i] += ref_count;
      sum[i] += count;
    } else {
      clipped[i] += count;
      sum[i] += count;
    }
  }

  void
  reset()
  {
    size_t i;
    for (i = 0; i < N_; i++) {
      clipped[i] = 0;
      sum[i] = 0;
    }
  }

  void
  print()
  {
    for (size_t i = 0; i < N_; i++) {
      cout << i+1 << "grams (clipped):\t" << clipped[i] << endl;
      cout << i+1 << "grams:\t\t\t" << sum[i] << endl;
    }
  }
};

typedef map<vector<WordID>, size_t> Ngrams;
Ngrams make_ngrams(vector<WordID>& s, size_t N);
NgramCounts make_ngram_counts(vector<WordID> hyp, vector<WordID> ref, size_t N);

double brevity_penaly(const size_t hyp_len, const size_t ref_len);
double bleu(NgramCounts& counts, const size_t hyp_len, const size_t ref_len, const size_t N,
             vector<float> weights = vector<float>());
double stupid_bleu(NgramCounts& counts, const size_t hyp_len, const size_t ref_len, size_t N,
                    vector<float> weights = vector<float>());
double smooth_bleu(NgramCounts& counts, const size_t hyp_len, const size_t ref_len, const size_t N,
                    vector<float> weights = vector<float>());
double approx_bleu(NgramCounts& counts, const size_t hyp_len, const size_t ref_len, const size_t N,
                    vector<float> weights = vector<float>());


} // namespace


#endif