code: def compute_bleu(
      reference_corpus: List,
      translation_corpus: List,
      max_order: int = 4,
      smooth: bool = False,
  ):
      """
      Computes BLEU score of translated segments against one or more references.
      Args:
          reference_corpus: list of lists of references for each translation. Each
              reference should be tokenized into a list of tokens.
          translation_corpus: list of translations to score. Each translation
              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 reference, translation in zip(
          reference_corpus, translation_corpus
      ):
          reference_length += len(reference)
          translation_length += len(translation)
  
          merged_ref_ngram_counts = collections.Counter()
          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
      elif ratio > 0.0:
          bp = math.exp(1 - 1.0 / ratio)
      else:
          bp = 0
  
      bleu = geo_mean * bp
  
      return (
          bleu,
          precisions,
          bp,
          ratio,
          translation_length,
          reference_length,
      )
  
imports: import collections
  import math
  from typing import List
label_desc: Use image node_id 2 for calling a global function with example usage: compute_bleu(reference_corpus, translation_corpus, max_order, smooth) and returns: bleu,  precisions,  bp,  ratio,  translation_length,  reference_length