



from typing import Dict, List

from nltk.translate import gleu_score

import datasets
from datasets import MetricInfo


__A       =						'''\
@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}
}
'''

__A       =						'''\
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.
'''

__A       =						'''\
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 		lowercase						(			datasets.Metric):






	"""simple docstring"""


	def   _SCREAMING_SNAKE_CASE		(     self     :						Union[str, Any]					)      ->			MetricInfo:
							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   _SCREAMING_SNAKE_CASE		(     self     :						Any						,  __UpperCAmelCase     :						List[List[List[str]]]						,  __UpperCAmelCase     :						List[List[str]]						,  __UpperCAmelCase     :						int = 1						,  __UpperCAmelCase     :						int = 4						,  )      ->			Dict[str, float]:
							return {
							    "google_bleu": gleu_score.corpus_gleu(
							        list_of_references=__UpperCAmelCase						,  hypotheses=__UpperCAmelCase						,  min_len=__UpperCAmelCase						,  max_len=__UpperCAmelCase					)
							}









import dataclasses
import json
import warnings
from dataclasses import dataclass, field
from time import time
from typing import List

from ..utils import logging


__A       =						logging.get_logger(__name__)



def 	__a					(   lowerCAmelCase_       : Tuple=None      ,lowerCAmelCase_       : Optional[Any]=None    )				->			Tuple:






						'''simple docstring'''



						return field(default_factory=lambda: default      ,metadata=lowerCAmelCase_    )






@dataclass
class 		lowercase						:






	"""simple docstring"""


	a__				: List[str]		       =							list_field(
	    default=[]			,   metadata={
	        "help": (
	            "Model checkpoints to be provided to the AutoModel classes. Leave blank to benchmark the base version"
	            " of all available models"
	        )
	    }			,   )

	a__				: List[int]		       =							list_field(
	    default=[8]			,   metadata={"help": "List of batch sizes for which memory and time performance will be evaluated"})

	a__				: List[int]		       =							list_field(
	    default=[8, 32, 128, 512]			,   metadata={"help": "List of sequence lengths for which memory and time performance will be evaluated"}			,   )

	a__				: bool		       =							field(
	    default=snake_case__			,   metadata={"help": "Whether to benchmark inference of model. Inference can be disabled via --no-inference."}			,   )
	a__				: bool		       =							field(
	    default=snake_case__			,   metadata={"help": "Whether to run on available cuda devices. Cuda can be disabled via --no-cuda."}			,   )
	a__				: bool		       =							field(
	    default=snake_case__			,   metadata={"help": "Whether to run on available tpu devices. TPU can be disabled via --no-tpu."})
	a__				: bool		       =							field(default=snake_case__			,   metadata={"help": "Use FP16 to accelerate inference."})
	a__				: bool		       =							field(default=snake_case__			,   metadata={"help": "Benchmark training of model"})
	a__				: bool		       =							field(default=snake_case__			,   metadata={"help": "Verbose memory tracing"})
	a__				: bool		       =							field(
	    default=snake_case__			,   metadata={"help": "Whether to perform speed measurements. Speed measurements can be disabled via --no-speed."}			,   )
	a__				: bool		       =							field(
	    default=snake_case__			,   metadata={
	        "help": "Whether to perform memory measurements. Memory measurements can be disabled via --no-memory"
	    }			,   )
	a__				: bool		       =							field(default=snake_case__			,   metadata={"help": "Trace memory line by line"})
	a__				: bool		       =							field(default=snake_case__			,   metadata={"help": "Save result to a CSV file"})
	a__				: bool		       =							field(default=snake_case__			,   metadata={"help": "Save all print statements in a log file"})
	a__				: bool		       =							field(default=snake_case__			,   metadata={"help": "Whether to print environment information"})
	a__				: bool		       =							field(
	    default=snake_case__			,   metadata={
	        "help": (
	            "Whether to use multiprocessing for memory and speed measurement. It is highly recommended to use"
	            " multiprocessing for accurate CPU and GPU memory measurements. This option should only be disabled"
	            " for debugging / testing and on TPU."
	        )
	    }			,   )
	a__				: str		       =							field(
	    default=F'inference_time_{round(time())}.csv'			,   metadata={"help": "CSV filename used if saving time results to csv."}			,   )
	a__				: str		       =							field(
	    default=F'inference_memory_{round(time())}.csv'			,   metadata={"help": "CSV filename used if saving memory results to csv."}			,   )
	a__				: str		       =							field(
	    default=F'train_time_{round(time())}.csv'			,   metadata={"help": "CSV filename used if saving time results to csv for training."}			,   )
	a__				: str		       =							field(
	    default=F'train_memory_{round(time())}.csv'			,   metadata={"help": "CSV filename used if saving memory results to csv for training."}			,   )
	a__				: str		       =							field(
	    default=F'env_info_{round(time())}.csv'			,   metadata={"help": "CSV filename used if saving environment information."}			,   )
	a__				: str		       =							field(
	    default=F'log_{round(time())}.csv'			,   metadata={"help": "Log filename used if print statements are saved in log."}			,   )
	a__				: int		       =							field(default=3			,   metadata={"help": "Times an experiment will be run."})
	a__				: bool		       =							field(
	    default=snake_case__			,   metadata={
	        "help": (
	            "Instead of loading the model as defined in `config.architectures` if exists, just load the pretrain"
	            " model weights."
	        )
	    }			,   )




	def   _SCREAMING_SNAKE_CASE		(     self     :						Optional[int]					)      ->			str:
							warnings.warn(
							    F"""The class {self.__class__} is deprecated. Hugging Face Benchmarking utils"""
							    """ are deprecated in general and it is advised to use external Benchmarking libraries """
							    """ to benchmark Transformer models."""						,  __UpperCAmelCase						,  )




	def   _SCREAMING_SNAKE_CASE		(     self     :						Dict					)      ->			List[str]:
							return json.dumps(dataclasses.asdict(self					)						,  indent=2					)




	@property
	def   _SCREAMING_SNAKE_CASE		(     self     :						List[Any]					)      ->			List[str]:
							if len(self.models					) <= 0:
													raise ValueError(
													    """Please make sure you provide at least one model name / model identifier, *e.g.* `--models"""
													    """ bert-base-cased` or `args.models = ['bert-base-cased']."""					)
							return self.models




	@property
	def   _SCREAMING_SNAKE_CASE		(     self     :						Union[str, Any]					)      ->			Tuple:
							if not self.multi_process:
													return False
							elif self.is_tpu:
													logger.info("""Multiprocessing is currently not possible on TPU."""					)
													return False
							else:
													return True




