






'''simple docstring'''



from typing import Dict, List

from nltk.translate import gleu_score

import datasets
from datasets import MetricInfo


__UpperCamelCase   :							Dict         =   """\
@misc{wu2016googles,
      title={Google's Neural Machine Translation System: Bridging the Gap between Human and Machine Translation},
      author={Yonghui Wu and Mike Schuster and Zhifeng Chen and Quoc V. Le and Mohammad Norouzi and Wolfgang Macherey
              and Maxim Krikun and Yuan Cao and Qin Gao and Klaus Macherey and Jeff Klingner and Apurva Shah and Melvin
              Johnson and Xiaobing Liu and Łukasz Kaiser and Stephan Gouws and Yoshikiyo Kato and Taku Kudo and Hideto
              Kazawa and Keith Stevens and George Kurian and Nishant Patil and Wei Wang and Cliff Young and
              Jason Smith and Jason Riesa and Alex Rudnick and Oriol Vinyals and Greg Corrado and Macduff Hughes
              and Jeffrey Dean},
      year={2016},
      eprint={1609.08144},
      archivePrefix={arXiv},
      primaryClass={cs.CL}
}
"""

__UpperCamelCase   :							Optional[Any]         =   """\
The BLEU score has some undesirable properties when used for single
sentences, as it was designed to be a corpus measure. We therefore
use a slightly different score for our RL experiments which we call
the 'GLEU score'. For the GLEU score, we record all sub-sequences of
1, 2, 3 or 4 tokens in output and target sequence (n-grams). We then
compute a recall, which is the ratio of the number of matching n-grams
to the number of total n-grams in the target (ground truth) sequence,
and a precision, which is the ratio of the number of matching n-grams
to the number of total n-grams in the generated output sequence. Then
GLEU score is simply the minimum of recall and precision. This GLEU
score's range is always between 0 (no matches) and 1 (all match) and
it is symmetrical when switching output and target. According to
our experiments, GLEU score correlates quite well with the BLEU
metric on a corpus level but does not have its drawbacks for our per
sentence reward objective.
"""

__UpperCamelCase   :							str         =   """\
Computes corpus-level Google BLEU (GLEU) score of translated segments against one or more references.
Instead of averaging the sentence level GLEU scores (i.e. macro-average precision), Wu et al. (2016) sum up the matching
tokens and the max of hypothesis and reference tokens for each sentence, then compute using the aggregate values.

Args:
    predictions (list of str): list of translations to score.
        Each translation should be tokenized into a list of tokens.
    references (list of list of str): list of lists of references for each translation.
        Each reference should be tokenized into a list of tokens.
    min_len (int): The minimum order of n-gram this function should extract. Defaults to 1.
    max_len (int): The maximum order of n-gram this function should extract. Defaults to 4.

Returns:
    'google_bleu': google_bleu score

Examples:
    Example 1:
        >>> hyp1 = ['It', 'is', 'a', 'guide', 'to', 'action', 'which',
        ...         'ensures', 'that', 'the', 'rubber', 'duck', 'always',
        ...         'disobeys', 'the', 'commands', 'of', 'the', 'cat']
        >>> ref1a = ['It', 'is', 'the', 'guiding', 'principle', 'which',
        ...          'guarantees', 'the', 'rubber', 'duck', 'forces', 'never',
        ...          'being', 'under', 'the', 'command', 'of', 'the', 'cat']

        >>> hyp2 = ['he', 'read', 'the', 'book', 'because', 'he', 'was',
        ...         'interested', 'in', 'world', 'history']
        >>> ref2a = ['he', 'was', 'interested', 'in', 'world', 'history',
        ...          'because', 'he', 'read', 'the', 'book']

        >>> list_of_references = [[ref1a], [ref2a]]
        >>> hypotheses = [hyp1, hyp2]
        >>> google_bleu = datasets.load_metric(\"google_bleu\")
        >>> results = google_bleu.compute(predictions=hypotheses, references=list_of_references)
        >>> print(round(results[\"google_bleu\"], 2))
        0.44

    Example 2:
        >>> hyp1 = ['It', 'is', 'a', 'guide', 'to', 'action', 'which',
        ...         'ensures', 'that', 'the', 'rubber', 'duck', 'always',
        ...         'disobeys', 'the', 'commands', 'of', 'the', 'cat']
        >>> ref1a = ['It', 'is', 'the', 'guiding', 'principle', 'which',
        ...          'guarantees', 'the', 'rubber', 'duck', 'forces', 'never',
        ...          'being', 'under', 'the', 'command', 'of', 'the', 'cat']
        >>> ref1b = ['It', 'is', 'a', 'guide', 'to', 'action', 'that',
        ...          'ensures', 'that', 'the', 'rubber', 'duck', 'will', 'never',
        ...          'heed', 'the', 'cat', 'commands']
        >>> ref1c = ['It', 'is', 'the', 'practical', 'guide', 'for', 'the',
        ...          'rubber', 'duck', 'army', 'never', 'to', 'heed', 'the', 'directions',
        ...          'of', 'the', 'cat']

        >>> hyp2 = ['he', 'read', 'the', 'book', 'because', 'he', 'was',
        ...         'interested', 'in', 'world', 'history']
        >>> ref2a = ['he', 'was', 'interested', 'in', 'world', 'history',
        ...          'because', 'he', 'read', 'the', 'book']

        >>> list_of_references = [[ref1a, ref1b, ref1c], [ref2a]]
        >>> hypotheses = [hyp1, hyp2]
        >>> google_bleu = datasets.load_metric(\"google_bleu\")
        >>> results = google_bleu.compute(predictions=hypotheses, references=list_of_references)
        >>> print(round(results[\"google_bleu\"], 2))
        0.61

    Example 3:
        >>> hyp1 = ['It', 'is', 'a', 'guide', 'to', 'action', 'which',
        ...         'ensures', 'that', 'the', 'rubber', 'duck', 'always',
        ...         'disobeys', 'the', 'commands', 'of', 'the', 'cat']
        >>> ref1a = ['It', 'is', 'the', 'guiding', 'principle', 'which',
        ...          'guarantees', 'the', 'rubber', 'duck', 'forces', 'never',
        ...          'being', 'under', 'the', 'command', 'of', 'the', 'cat']
        >>> ref1b = ['It', 'is', 'a', 'guide', 'to', 'action', 'that',
        ...          'ensures', 'that', 'the', 'rubber', 'duck', 'will', 'never',
        ...          'heed', 'the', 'cat', 'commands']
        >>> ref1c = ['It', 'is', 'the', 'practical', 'guide', 'for', 'the',
        ...          'rubber', 'duck', 'army', 'never', 'to', 'heed', 'the', 'directions',
        ...          'of', 'the', 'cat']

        >>> hyp2 = ['he', 'read', 'the', 'book', 'because', 'he', 'was',
        ...         'interested', 'in', 'world', 'history']
        >>> ref2a = ['he', 'was', 'interested', 'in', 'world', 'history',
        ...          'because', 'he', 'read', 'the', 'book']

        >>> list_of_references = [[ref1a, ref1b, ref1c], [ref2a]]
        >>> hypotheses = [hyp1, hyp2]
        >>> google_bleu = datasets.load_metric(\"google_bleu\")
        >>> results = google_bleu.compute(predictions=hypotheses, references=list_of_references, min_len=2)
        >>> print(round(results[\"google_bleu\"], 2))
        0.53

    Example 4:
        >>> hyp1 = ['It', 'is', 'a', 'guide', 'to', 'action', 'which',
        ...         'ensures', 'that', 'the', 'rubber', 'duck', 'always',
        ...         'disobeys', 'the', 'commands', 'of', 'the', 'cat']
        >>> ref1a = ['It', 'is', 'the', 'guiding', 'principle', 'which',
        ...          'guarantees', 'the', 'rubber', 'duck', 'forces', 'never',
        ...          'being', 'under', 'the', 'command', 'of', 'the', 'cat']
        >>> ref1b = ['It', 'is', 'a', 'guide', 'to', 'action', 'that',
        ...          'ensures', 'that', 'the', 'rubber', 'duck', 'will', 'never',
        ...          'heed', 'the', 'cat', 'commands']
        >>> ref1c = ['It', 'is', 'the', 'practical', 'guide', 'for', 'the',
        ...          'rubber', 'duck', 'army', 'never', 'to', 'heed', 'the', 'directions',
        ...          'of', 'the', 'cat']

        >>> hyp2 = ['he', 'read', 'the', 'book', 'because', 'he', 'was',
        ...         'interested', 'in', 'world', 'history']
        >>> ref2a = ['he', 'was', 'interested', 'in', 'world', 'history',
        ...          'because', 'he', 'read', 'the', 'book']

        >>> list_of_references = [[ref1a, ref1b, ref1c], [ref2a]]
        >>> hypotheses = [hyp1, hyp2]
        >>> google_bleu = datasets.load_metric(\"google_bleu\")
        >>> results = google_bleu.compute(predictions=hypotheses,references=list_of_references, min_len=2, max_len=6)
        >>> print(round(results[\"google_bleu\"], 2))
        0.4
"""
@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION   ,   _KWARGS_DESCRIPTION  )
class 				__SCREAMING_SNAKE_CASE							(				datasets.Metric  ):




      def 			__UpperCamelCase				(	self   )				->MetricInfo:



         '''simple docstring'''
         return datasets.MetricInfo(
             description=_DESCRIPTION			, citation=_CITATION			, inputs_description=_KWARGS_DESCRIPTION			, features=datasets.Features(
                 {
                     'predictions': datasets.Sequence(datasets.Value('string'			, id='token'   )			, id='sequence'   ),
                     'references': datasets.Sequence(
                         datasets.Sequence(datasets.Value('string'			, id='token'   )			, id='sequence'   )			, id='references'   ),
                 }   )			, )






      def 			__UpperCamelCase				(	self			, lowerCamelCase			, lowerCamelCase			, lowerCamelCase = 1			, lowerCamelCase = 4			, )				->Dict[str, float]:



         '''simple docstring'''
         return {
             "google_bleu": gleu_score.corpus_gleu(
                 list_of_references=lowerCamelCase			, hypotheses=lowerCamelCase			, min_len=lowerCamelCase			, max_len=lowerCamelCase   )
         }







'''simple docstring'''



from collections import OrderedDict
from typing import TYPE_CHECKING, Any, Mapping, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxSeqaSeqConfigWithPast
from ...utils import logging


if TYPE_CHECKING:
 from ...feature_extraction_utils import FeatureExtractionMixin
 from ...tokenization_utils_base import PreTrainedTokenizerBase
 from ...utils import TensorType

__UpperCamelCase   :							List[str]         =   logging.get_logger(__name__)

__UpperCamelCase   :							Optional[int]         =   {
    """openai/whisper-base""": """https://huggingface.co/openai/whisper-base/resolve/main/config.json""",
}

# fmt: off
__UpperCamelCase   :							Optional[Any]         =   [
    1, 2, 7, 8, 9, 10, 14, 25,
    26, 27, 28, 29, 31, 58, 59, 60, 61, 62,
    63, 90, 91, 92, 93, 357, 366, 438, 532, 685,
    705, 796, 930, 1058, 1220, 1267, 1279, 1303, 1343, 1377,
    1391, 1635, 1782, 1875, 2162, 2361, 2488, 3467, 4008, 4211,
    4600, 4808, 5299, 5855, 6329, 7203, 9609, 9959, 10563, 10786,
    11420, 11709, 11907, 13163, 13697, 13700, 14808, 15306, 16410, 16791,
    17992, 19203, 19510, 20724, 22305, 22935, 27007, 30109, 30420, 33409,
    34949, 40283, 40493, 40549, 47282, 49146, 50257, 50359, 50360, 50361
]
__UpperCamelCase   :							List[str]         =   [
    1, 2, 7, 8, 9, 10, 14, 25,
    26, 27, 28, 29, 31, 58, 59, 60, 61, 62,
    63, 90, 91, 92, 93, 359, 503, 522, 542, 873,
    893, 902, 918, 922, 931, 1350, 1853, 1982, 2460, 2627,
    3246, 3253, 3268, 3536, 3846, 3961, 4183, 4667, 6585, 6647,
    7273, 9061, 9383, 10428, 10929, 11938, 12033, 12331, 12562, 13793,
    14157, 14635, 15265, 15618, 16553, 16604, 18362, 18956, 20075, 21675,
    22520, 26130, 26161, 26435, 28279, 29464, 31650, 32302, 32470, 36865,
    42863, 47425, 49870, 50254, 50258, 50360, 50361, 50362
]
class 				__SCREAMING_SNAKE_CASE							(				_lowerCAmelCase  ):
      __a	       ="whisper"
      __a	       =["past_key_values"]
      __a	       ={"num_attention_heads": "encoder_attention_heads", "hidden_size": "d_model"}




      def __init__(	self			, lowerCamelCase=5_1865			, lowerCamelCase=80			, lowerCamelCase=6			, lowerCamelCase=4			, lowerCamelCase=6			, lowerCamelCase=4			, lowerCamelCase=1536			, lowerCamelCase=1536			, lowerCamelCase=0.0			, lowerCamelCase=0.0			, lowerCamelCase=5_0257			, lowerCamelCase=True			, lowerCamelCase=True			, lowerCamelCase="gelu"			, lowerCamelCase=256			, lowerCamelCase=0.0			, lowerCamelCase=0.0			, lowerCamelCase=0.0			, lowerCamelCase=0.02			, lowerCamelCase=False			, lowerCamelCase=1500			, lowerCamelCase=448			, lowerCamelCase=5_0256			, lowerCamelCase=5_0256			, lowerCamelCase=5_0256			, lowerCamelCase=None			, lowerCamelCase=[220, 5_0256]			, lowerCamelCase=False			, lowerCamelCase=256			, lowerCamelCase=False			, lowerCamelCase=0.05			, lowerCamelCase=10			, lowerCamelCase=2			, lowerCamelCase=0.0			, lowerCamelCase=10			, lowerCamelCase=0			, lowerCamelCase=7			, **lowerCamelCase			, )				->Any:



         '''simple docstring'''
         __a					  =     vocab_size
         __a					  =     num_mel_bins
         __a					  =     d_model
         __a					  =     encoder_layers
         __a					  =     encoder_attention_heads
         __a					  =     decoder_layers
         __a					  =     decoder_attention_heads
         __a					  =     decoder_ffn_dim
         __a					  =     encoder_ffn_dim
         __a					  =     dropout
         __a					  =     attention_dropout
         __a					  =     activation_dropout
         __a					  =     activation_function
         __a					  =     init_std
         __a					  =     encoder_layerdrop
         __a					  =     decoder_layerdrop
         __a					  =     use_cache
         __a					  =     encoder_layers
         __a					  =     scale_embedding  # scale factor will be sqrt(d_model) if True
         __a					  =     max_source_positions
         __a					  =     max_target_positions

         # Audio Classification-specific parameters. Feel free to ignore for other classes.
         __a					  =     classifier_proj_size
         __a					  =     use_weighted_layer_sum

         # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
         __a					  =     apply_spec_augment
         __a					  =     mask_time_prob
         __a					  =     mask_time_length
         __a					  =     mask_time_min_masks
         __a					  =     mask_feature_prob
         __a					  =     mask_feature_length
         __a					  =     mask_feature_min_masks

         __a					  =     median_filter_width

         super().__init__(
             pad_token_id=lowerCamelCase			, bos_token_id=lowerCamelCase			, eos_token_id=lowerCamelCase			, is_encoder_decoder=lowerCamelCase			, decoder_start_token_id=lowerCamelCase			, suppress_tokens=lowerCamelCase			, begin_suppress_tokens=lowerCamelCase			, **lowerCamelCase			, )







class 				__SCREAMING_SNAKE_CASE							(				_lowerCAmelCase  ):




      @property
      def 			__UpperCamelCase				(	self   )				->Mapping[str, Mapping[int, str]]:



         '''simple docstring'''
         __a					  =     OrderedDict(
             [
                 ('input_features', {0: 'batch', 1: 'feature_size', 2: 'encoder_sequence'}),
             ]   )
         if self.use_past:
            __a					  =     {0: 'batch'}
         else:
            __a					  =     {0: 'batch', 1: 'decoder_sequence'}

         if self.use_past:
            self.fill_with_past_key_values_(lowerCamelCase			, direction='inputs'   )

         return common_inputs




      def 			__UpperCamelCase				(	self			, lowerCamelCase			, lowerCamelCase = -1			, lowerCamelCase = -1			, lowerCamelCase = False			, lowerCamelCase = None			, lowerCamelCase = 2_2050			, lowerCamelCase = 5.0			, lowerCamelCase = 220			, )				->Mapping[str, Any]:



         '''simple docstring'''
         __a					  =     OrderedDict()
         __a					  =     OnnxConfig.generate_dummy_inputs(
             self			, preprocessor=preprocessor.feature_extractor			, batch_size=lowerCamelCase			, framework=lowerCamelCase			, sampling_rate=lowerCamelCase			, time_duration=lowerCamelCase			, frequency=lowerCamelCase			, )
         __a					  =     encoder_inputs['input_features'].shape[2]
         __a					  =     encoder_sequence_length // 2 if self.use_past else seq_length

         __a					  =     super().generate_dummy_inputs(
             preprocessor.tokenizer			, lowerCamelCase			, lowerCamelCase			, lowerCamelCase			, lowerCamelCase   )

         __a					  =     encoder_inputs.pop('input_features'   )
         __a					  =     decoder_inputs.pop('decoder_input_ids'   )

         if "past_key_values" in decoder_inputs:
            __a					  =     decoder_inputs.pop('past_key_values'   )

         return dummy_inputs






      @property
      def 			__UpperCamelCase				(	self   )				->float:



         '''simple docstring'''
         return 1e-3