


'''simple docstring'''


import datasets

from .nmt_bleu import compute_bleu  # From: https://github.com/tensorflow/nmt/blob/master/nmt/scripts/bleu.py


lowerCamelCase__    	=     '\\n@INPROCEEDINGS{Papineni02bleu:a,\n    author = {Kishore Papineni and Salim Roukos and Todd Ward and Wei-jing Zhu},\n    title = {BLEU: a Method for Automatic Evaluation of Machine Translation},\n    booktitle = {},\n    year = {2002},\n    pages = {311--318}\n}\n@inproceedings{lin-och-2004-orange,\n    title = "{ORANGE}: a Method for Evaluating Automatic Evaluation Metrics for Machine Translation",\n    author = "Lin, Chin-Yew  and\n      Och, Franz Josef",\n    booktitle = "{COLING} 2004: Proceedings of the 20th International Conference on Computational Linguistics",\n    month = "aug 23{--}aug 27",\n    year = "2004",\n    address = "Geneva, Switzerland",\n    publisher = "COLING",\n    url = "https://www.aclweb.org/anthology/C04-1072",\n    pages = "501--507",\n}\n'

lowerCamelCase__    	=     '\\nBLEU (bilingual evaluation understudy) is an algorithm for evaluating the quality of text which has been machine-translated from one natural language to another.\nQuality is considered to be the correspondence between a machine\'s output and that of a human: "the closer a machine translation is to a professional human translation,\nthe better it is" – this is the central idea behind BLEU. BLEU was one of the first metrics to claim a high correlation with human judgements of quality, and\nremains one of the most popular automated and inexpensive metrics.\n\nScores are calculated for individual translated segments—generally sentences—by comparing them with a set of good quality reference translations.\nThose scores are then averaged over the whole corpus to reach an estimate of the translation\'s overall quality. Intelligibility or grammatical correctness\nare not taken into account[citation needed].\n\nBLEU\'s output is always a number between 0 and 1. This value indicates how similar the candidate text is to the reference texts, with values closer to 1\nrepresenting more similar texts. Few human translations will attain a score of 1, since this would indicate that the candidate is identical to one of the\nreference translations. For this reason, it is not necessary to attain a score of 1. Because there are more opportunities to match, adding additional\nreference translations will increase the BLEU score.\n'

lowerCamelCase__    	=     '\nComputes BLEU score of translated segments against one or more references.\nArgs:\n    predictions: list of translations to score.\n        Each translation should be tokenized into a list of tokens.\n    references: list of lists of references for each translation.\n        Each reference should be tokenized into a list of tokens.\n    max_order: Maximum n-gram order to use when computing BLEU score.\n    smooth: Whether or not to apply Lin et al. 2004 smoothing.\nReturns:\n    \'bleu\': bleu score,\n    \'precisions\': geometric mean of n-gram precisions,\n    \'brevity_penalty\': brevity penalty,\n    \'length_ratio\': ratio of lengths,\n    \'translation_length\': translation_length,\n    \'reference_length\': reference_length\nExamples:\n\n    >>> predictions = [\n    ...     ["hello", "there", "general", "kenobi"],                             # tokenized prediction of the first sample\n    ...     ["foo", "bar", "foobar"]                                             # tokenized prediction of the second sample\n    ... ]\n    >>> references = [\n    ...     [["hello", "there", "general", "kenobi"], ["hello", "there", "!"]],  # tokenized references for the first sample (2 references)\n    ...     [["foo", "bar", "foobar"]]                                           # tokenized references for the second sample (1 reference)\n    ... ]\n    >>> bleu = datasets.load_metric("bleu")\n    >>> results = bleu.compute(predictions=predictions, references=references)\n    >>> print(results["bleu"])\n    1.0\n'






@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION    ,       _KWARGS_DESCRIPTION	)
class 	lowerCAmelCase__			(			datasets.Metric	):




			def 							lowerCAmelCase__    (		self  :     Any )   ->Any:



					'''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" ),
					        } )	,  codebase_urls=["https://github.com/tensorflow/nmt/blob/master/nmt/scripts/bleu.py"]	,  reference_urls=[
					        "https://en.wikipedia.org/wiki/BLEU",
					        "https://towardsdatascience.com/evaluating-text-output-in-nlp-bleu-at-your-own-risk-e8609665a213",
					    ]	,  )






			def 							lowerCAmelCase__    (		self  :     int	,  lowerCamelCase__  :     List[str]	,  lowerCamelCase__  :     Union[str, Any]	,  lowerCamelCase__  :     int=4	,  lowerCamelCase__  :     Union[str, Any]=False )   ->Tuple:



					'''simple docstring'''







					_UpperCAmelCase		:       Tuple								=      compute_bleu(
					    reference_corpus=lowerCamelCase__	,  translation_corpus=lowerCamelCase__	,  max_order=lowerCamelCase__	,  smooth=lowerCamelCase__ )
					((_UpperCAmelCase)					,    (_UpperCAmelCase)					,    (_UpperCAmelCase)					,    (_UpperCAmelCase)					,    (_UpperCAmelCase)					,    (_UpperCAmelCase))		:       str								=      score
					return {
					    "bleu": bleu,
					    "precisions": precisions,
					    "brevity_penalty": bp,
					    "length_ratio": ratio,
					    "translation_length": translation_length,
					    "reference_length": reference_length,
					}







'''simple docstring'''


import contextlib
import copy
import random
from typing import Any, Dict, Iterable, Optional, Union

import numpy as np
import torch

from .utils import deprecate, is_transformers_available


if is_transformers_available():
						import transformers






def  __lowerCAmelCase (__lowerCAmelCase   ):
		random.seed(__lowerCAmelCase   )
		np.random.seed(__lowerCAmelCase   )
		torch.manual_seed(__lowerCAmelCase   )
		torch.cuda.manual_seed_all(__lowerCAmelCase   )
		# ^^ safe to call this function even if cuda is not available






class 	lowerCAmelCase__			:




			def __init__(		self  :     List[Any]	,  lowerCamelCase__  :     Iterable[torch.nn.Parameter]	,  lowerCamelCase__  :     float = 0.9_9_9_9	,  lowerCamelCase__  :     float = 0.0	,  lowerCamelCase__  :     int = 0	,  lowerCamelCase__  :     bool = False	,  lowerCamelCase__  :     Union[float, int] = 1.0	,  lowerCamelCase__  :     Union[float, int] = 2 / 3	,  lowerCamelCase__  :     Optional[Any] = None	,  lowerCamelCase__  :     Dict[str, Any] = None	,  **lowerCamelCase__  :     Optional[int]	,  )   ->Optional[Any]:



					'''simple docstring'''







					if isinstance(lowerCamelCase__	,  torch.nn.Module ):
							_UpperCAmelCase		:       List[Any]								=      (
							    "Passing a `torch.nn.Module` to `ExponentialMovingAverage` is deprecated. "
							    "Please pass the parameters of the module instead."
							)
							deprecate(
							    "passing a `torch.nn.Module` to `ExponentialMovingAverage`"	,  "1.0.0"	,  lowerCamelCase__	,  standard_warn=lowerCamelCase__	,  )
							_UpperCAmelCase		:       List[str]								=      parameters.parameters()

							# set use_ema_warmup to True if a torch.nn.Module is passed for backwards compatibility
							_UpperCAmelCase		:       Optional[int]								=      True

					if kwargs.get("max_value"	,  lowerCamelCase__ ) is not None:
							_UpperCAmelCase		:       Tuple								=      "The `max_value` argument is deprecated. Please use `decay` instead."
							deprecate("max_value"	,  "1.0.0"	,  lowerCamelCase__	,  standard_warn=lowerCamelCase__ )
							_UpperCAmelCase		:       str								=      kwargs["max_value"]

					if kwargs.get("min_value"	,  lowerCamelCase__ ) is not None:
							_UpperCAmelCase		:       Optional[int]								=      "The `min_value` argument is deprecated. Please use `min_decay` instead."
							deprecate("min_value"	,  "1.0.0"	,  lowerCamelCase__	,  standard_warn=lowerCamelCase__ )
							_UpperCAmelCase		:       Tuple								=      kwargs["min_value"]

					_UpperCAmelCase		:       Optional[Any]								=      list(lowerCamelCase__ )
					_UpperCAmelCase		:       Dict								=      [p.clone().detach() for p in parameters]

					if kwargs.get("device"	,  lowerCamelCase__ ) is not None:
							_UpperCAmelCase		:       Any								=      "The `device` argument is deprecated. Please use `to` instead."
							deprecate("device"	,  "1.0.0"	,  lowerCamelCase__	,  standard_warn=lowerCamelCase__ )
							self.to(device=kwargs["device"] )

					_UpperCAmelCase		:       Union[str, Any]								=      None

					_UpperCAmelCase		:       int								=      decay
					_UpperCAmelCase		:       Any								=      min_decay
					_UpperCAmelCase		:       Optional[int]								=      update_after_step
					_UpperCAmelCase		:       str								=      use_ema_warmup
					_UpperCAmelCase		:       Union[str, Any]								=      inv_gamma
					_UpperCAmelCase		:       Union[str, Any]								=      power
					_UpperCAmelCase		:       List[str]								=      0
					_UpperCAmelCase		:       List[str]								=      None  # set in `step()`

					_UpperCAmelCase		:       Optional[int]								=      model_cls
					_UpperCAmelCase		:       Union[str, Any]								=      model_config




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     int	,  lowerCamelCase__  :     Tuple	,  lowerCamelCase__  :     int )   ->"EMAModel":



					'''simple docstring'''







					_UpperCAmelCase					,    _UpperCAmelCase		:       Optional[int]								=      model_cls.load_config(lowerCamelCase__	,  return_unused_kwargs=lowerCamelCase__ )
					_UpperCAmelCase		:       Union[str, Any]								=      model_cls.from_pretrained(lowerCamelCase__ )

					_UpperCAmelCase		:       List[str]								=      cls(model.parameters()	,  model_cls=lowerCamelCase__	,  model_config=model.config )

					ema_model.load_state_dict(lowerCamelCase__ )
					return ema_model




			def 							lowerCAmelCase__    (		self  :     Optional[int]	,  lowerCamelCase__  :     int )   ->Dict:



					'''simple docstring'''







					if self.model_cls is None:
							raise ValueError("`save_pretrained` can only be used if `model_cls` was defined at __init__." )

					if self.model_config is None:
							raise ValueError("`save_pretrained` can only be used if `model_config` was defined at __init__." )

					_UpperCAmelCase		:       int								=      self.model_cls.from_config(self.model_config )
					_UpperCAmelCase		:       Union[str, Any]								=      self.state_dict()
					state_dict.pop("shadow_params"	,  lowerCamelCase__ )

					model.register_to_config(**lowerCamelCase__ )
					self.copy_to(model.parameters() )
					model.save_pretrained(lowerCamelCase__ )




			def 							lowerCAmelCase__    (		self  :     List[str]	,  lowerCamelCase__  :     int )   ->float:



					'''simple docstring'''







					_UpperCAmelCase		:       int								=      max(0	,  optimization_step - self.update_after_step - 1 )

					if step <= 0:
							return 0.0

					if self.use_ema_warmup:
							_UpperCAmelCase		:       int								=      1 - (1 + step / self.inv_gamma) ** -self.power
					else:
							_UpperCAmelCase		:       Any								=      (1 + step) / (10 + step)

					_UpperCAmelCase		:       int								=      min(lowerCamelCase__	,  self.decay )
					# make sure decay is not smaller than min_decay
					_UpperCAmelCase		:       Union[str, Any]								=      max(lowerCamelCase__	,  self.min_decay )
					return cur_decay_value




			@torch.no_grad()
			def 							lowerCAmelCase__    (		self  :     str	,  lowerCamelCase__  :     Iterable[torch.nn.Parameter] )   ->Dict:



					'''simple docstring'''







					if isinstance(lowerCamelCase__	,  torch.nn.Module ):
							_UpperCAmelCase		:       Union[str, Any]								=      (
							    "Passing a `torch.nn.Module` to `ExponentialMovingAverage.step` is deprecated. "
							    "Please pass the parameters of the module instead."
							)
							deprecate(
							    "passing a `torch.nn.Module` to `ExponentialMovingAverage.step`"	,  "1.0.0"	,  lowerCamelCase__	,  standard_warn=lowerCamelCase__	,  )
							_UpperCAmelCase		:       Any								=      parameters.parameters()

					_UpperCAmelCase		:       Dict								=      list(lowerCamelCase__ )

					self.optimization_step += 1

					# Compute the decay factor for the exponential moving average.
					_UpperCAmelCase		:       Tuple								=      self.get_decay(self.optimization_step )
					_UpperCAmelCase		:       Any								=      decay
					_UpperCAmelCase		:       Optional[Any]								=      1 - decay

					_UpperCAmelCase		:       Union[str, Any]								=      contextlib.nullcontext
					if is_transformers_available() and transformers.deepspeed.is_deepspeed_zeroa_enabled():
							import deepspeed

					for s_param, param in zip(self.shadow_params	,  lowerCamelCase__ ):
							if is_transformers_available() and transformers.deepspeed.is_deepspeed_zeroa_enabled():
									_UpperCAmelCase		:       str								=      deepspeed.zero.GatheredParameters(lowerCamelCase__	,  modifier_rank=lowerCamelCase__ )

							with context_manager():
									if param.requires_grad:
											s_param.sub_(one_minus_decay * (s_param - param) )
									else:
											s_param.copy_(lowerCamelCase__ )




			def 							lowerCAmelCase__    (		self  :     Optional[int]	,  lowerCamelCase__  :     Iterable[torch.nn.Parameter] )   ->None:



					'''simple docstring'''







					_UpperCAmelCase		:       List[str]								=      list(lowerCamelCase__ )
					for s_param, param in zip(self.shadow_params	,  lowerCamelCase__ ):
							param.data.copy_(s_param.to(param.device ).data )




			def 							lowerCAmelCase__    (		self  :     int	,  lowerCamelCase__  :     Dict=None	,  lowerCamelCase__  :     Optional[int]=None )   ->None:



					'''simple docstring'''







					_UpperCAmelCase		:       str								=      [
					    p.to(device=lowerCamelCase__	,  dtype=lowerCamelCase__ ) if p.is_floating_point() else p.to(device=lowerCamelCase__ )
					    for p in self.shadow_params
					]




			def 							lowerCAmelCase__    (		self  :     List[Any] )   ->dict:



					'''simple docstring'''







					return {
					    "decay": self.decay,
					    "min_decay": self.min_decay,
					    "optimization_step": self.optimization_step,
					    "update_after_step": self.update_after_step,
					    "use_ema_warmup": self.use_ema_warmup,
					    "inv_gamma": self.inv_gamma,
					    "power": self.power,
					    "shadow_params": self.shadow_params,
					}




			def 							lowerCAmelCase__    (		self  :     Optional[int]	,  lowerCamelCase__  :     Iterable[torch.nn.Parameter] )   ->None:



					'''simple docstring'''







					_UpperCAmelCase		:       Tuple								=      [param.detach().cpu().clone() for param in parameters]




			def 							lowerCAmelCase__    (		self  :     List[str]	,  lowerCamelCase__  :     Iterable[torch.nn.Parameter] )   ->None:



					'''simple docstring'''







					if self.temp_stored_params is None:
							raise RuntimeError("This ExponentialMovingAverage has no `store()`ed weights " "to `restore()`" )
					for c_param, param in zip(self.temp_stored_params	,  lowerCamelCase__ ):
							param.data.copy_(c_param.data )

					# Better memory-wise.
					_UpperCAmelCase		:       int								=      None






			def 							lowerCAmelCase__    (		self  :     Union[str, Any]	,  lowerCamelCase__  :     dict )   ->None:



					'''simple docstring'''







					_UpperCAmelCase		:       Optional[Any]								=      copy.deepcopy(lowerCamelCase__ )

					_UpperCAmelCase		:       List[str]								=      state_dict.get("decay"	,  self.decay )
					if self.decay < 0.0 or self.decay > 1.0:
							raise ValueError("Decay must be between 0 and 1" )

					_UpperCAmelCase		:       Union[str, Any]								=      state_dict.get("min_decay"	,  self.min_decay )
					if not isinstance(self.min_decay	,  lowerCamelCase__ ):
							raise ValueError("Invalid min_decay" )

					_UpperCAmelCase		:       List[str]								=      state_dict.get("optimization_step"	,  self.optimization_step )
					if not isinstance(self.optimization_step	,  lowerCamelCase__ ):
							raise ValueError("Invalid optimization_step" )

					_UpperCAmelCase		:       List[Any]								=      state_dict.get("update_after_step"	,  self.update_after_step )
					if not isinstance(self.update_after_step	,  lowerCamelCase__ ):
							raise ValueError("Invalid update_after_step" )

					_UpperCAmelCase		:       str								=      state_dict.get("use_ema_warmup"	,  self.use_ema_warmup )
					if not isinstance(self.use_ema_warmup	,  lowerCamelCase__ ):
							raise ValueError("Invalid use_ema_warmup" )

					_UpperCAmelCase		:       int								=      state_dict.get("inv_gamma"	,  self.inv_gamma )
					if not isinstance(self.inv_gamma	,  (float, int) ):
							raise ValueError("Invalid inv_gamma" )

					_UpperCAmelCase		:       Any								=      state_dict.get("power"	,  self.power )
					if not isinstance(self.power	,  (float, int) ):
							raise ValueError("Invalid power" )

					_UpperCAmelCase		:       List[str]								=      state_dict.get("shadow_params"	,  lowerCamelCase__ )
					if shadow_params is not None:
							_UpperCAmelCase		:       Optional[Any]								=      shadow_params
							if not isinstance(self.shadow_params	,  lowerCamelCase__ ):
									raise ValueError("shadow_params must be a list" )
							if not all(isinstance(lowerCamelCase__	,  torch.Tensor ) for p in self.shadow_params ):
									raise ValueError("shadow_params must all be Tensors" )



