Update metrics/bleu.py

metrics/bleu.py

@@ -1,122 +1,39 @@
-# Copied from https://github.com/tensorflow/nmt/blob/0be864257a76c151eef20ea689755f08bc1faf4e/nmt/scripts/bleu.py
-
-# Copyright 2017 Google Inc. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ==============================================================================
-
-"""Python implementation of BLEU and smooth-BLEU.
-
-This module provides a Python implementation of BLEU and smooth-BLEU.
-Smooth BLEU is computed following the method outlined in the paper:
-Chin-Yew Lin, Franz Josef Och. ORANGE: a method for evaluating automatic
-evaluation metrics for machine translation. COLING 2004.
-"""
-
-import collections
-import math
-
-
-def _get_ngrams(segment, max_order):
-    """Extracts all n-grams upto a given maximum order from an input segment.
-
-    Args:
-      segment: text segment from which n-grams will be extracted.
-      max_order: maximum length in tokens of the n-grams returned by this
-          methods.
-
-    Returns:
-      The Counter containing all n-grams upto max_order in segment
-      with a count of how many times each n-gram occurred.
-    """
-    ngram_counts = collections.Counter()
-    for order in range(1, max_order + 1):
-        for i in range(0, len(segment) - order + 1):
-            ngram = tuple(segment[i : i + order])
-            ngram_counts[ngram] += 1
-    return ngram_counts
-
-
-def compute_bleu(translation_corpus, reference_corpus, max_order=4, smooth=False):
-    """Computes BLEU score of translated segments against one or more references.
-
-    Args:
-      translation_corpus: list of translations to score. Each translation
-          should be tokenized into a list of tokens.
-      reference_corpus: list of lists of references for each translation. Each
-          reference should be tokenized into a list of tokens.
-      max_order: Maximum n-gram order to use when computing BLEU score.
-      smooth: Whether or not to apply Lin et al. 2004 smoothing.
-
-    Returns:
-      3-Tuple with the BLEU score, n-gram precisions, geometric mean of n-gram
-      precisions and brevity penalty.
-    """
-    matches_by_order = [0] * max_order
-    possible_matches_by_order = [0] * max_order
-    reference_length = 0
-    translation_length = 0
-    for (references, translation) in zip(reference_corpus, translation_corpus):
-        reference_length += min(len(r) for r in references)
-        translation_length += len(translation)
-
-        merged_ref_ngram_counts = collections.Counter()
-        for reference in references:
-            merged_ref_ngram_counts |= _get_ngrams(reference, max_order)
-        translation_ngram_counts = _get_ngrams(translation, max_order)
-        overlap = translation_ngram_counts & merged_ref_ngram_counts
-        for ngram in overlap:
-            matches_by_order[len(ngram) - 1] += overlap[ngram]
-        for order in range(1, max_order + 1):
-            possible_matches = len(translation) - order + 1
-            if possible_matches > 0:
-                possible_matches_by_order[order - 1] += possible_matches
-
-    precisions = [0] * max_order
-    for i in range(0, max_order):
-        if smooth:
-            precisions[i] = (matches_by_order[i] + 1.0) / (possible_matches_by_order[i] + 1.0)
-        else:
-            if possible_matches_by_order[i] > 0:
-                precisions[i] = float(matches_by_order[i]) / possible_matches_by_order[i]
-            else:
-                precisions[i] = 0.0
-
-    if min(precisions) > 0:
-        p_log_sum = sum((1.0 / max_order) * math.log(p) for p in precisions)
-        geo_mean = math.exp(p_log_sum)
-    else:
-        geo_mean = 0
-
-    ratio = float(translation_length) / reference_length
-
-    if ratio > 1.0:
-        bp = 1.0
-    else:
-        bp = math.exp(1 - 1.0 / ratio)
-
-    bleu = geo_mean * bp
-
-    return {
-        "bleu": bleu,
-        **{f"precision-{i+1}": round(p, 4) for i, p in enumerate(precisions)},
-        "brevity_penalty": bp,
-        "length_ratio": ratio,
-        "translation_length": translation_length,
-        "reference_length": reference_length,
+# Copied from https://github.com/huggingface/datasets/blob/76bb45964df1e62d1411b0a9e9fc673e9a791c9a/metrics/sacrebleu/sacrebleu.py
+
+import sacrebleu as scb
+
+
+def compute_bleu(
+    predictions,
+    references,
+    smooth_method="exp",
+    smooth_value=None,
+    force=False,
+    lowercase=False,
+    tokenize=None,
+    use_effective_order=False,
+):
+    references_per_prediction = len(references[0])
+    if any(len(refs) != references_per_prediction for refs in references):
+        raise ValueError("Sacrebleu requires the same number of references for each prediction")
+    transformed_references = [[refs[i] for refs in references] for i in range(references_per_prediction)]
+    output = scb.corpus_bleu(
+        predictions,
+        transformed_references,
+        smooth_method=smooth_method,
+        smooth_value=smooth_value,
+        force=force,
+        lowercase=lowercase,
+        use_effective_order=use_effective_order,
+        **(dict(tokenize=tokenize) if tokenize else {}),
+    )
+    output_dict = {
+        "score": output.score,
+        "counts": output.counts,
+        "totals": output.totals,
+        "precisions": output.precisions,
+        "bp": output.bp,
+        "sys_len": output.sys_len,
+        "ref_len": output.ref_len,
     }
-
-
-def postprocess_text(text):
-    # TODO: Tokenize properly
-    return text.split()
+    return output_dict