


import sacrebleu as scb
from packaging import version
from sacrebleu import CHRF

import datasets


lowerCAmelCase__  :List[str]             =							'''\
@inproceedings{popovic-2015-chrf,
    title = "chr{F}: character n-gram {F}-score for automatic {MT} evaluation",
    author = "Popovi{\'c}, Maja",
    booktitle = "Proceedings of the Tenth Workshop on Statistical Machine Translation",
    month = sep,
    year = "2015",
    address = "Lisbon, Portugal",
    publisher = "Association for Computational Linguistics",
    url = "https://aclanthology.org/W15-3049",
    doi = "10.18653/v1/W15-3049",
    pages = "392--395",
}
@inproceedings{popovic-2017-chrf,
    title = "chr{F}++: words helping character n-grams",
    author = "Popovi{\'c}, Maja",
    booktitle = "Proceedings of the Second Conference on Machine Translation",
    month = sep,
    year = "2017",
    address = "Copenhagen, Denmark",
    publisher = "Association for Computational Linguistics",
    url = "https://aclanthology.org/W17-4770",
    doi = "10.18653/v1/W17-4770",
    pages = "612--618",
}
@inproceedings{post-2018-call,
    title = "A Call for Clarity in Reporting {BLEU} Scores",
    author = "Post, Matt",
    booktitle = "Proceedings of the Third Conference on Machine Translation: Research Papers",
    month = oct,
    year = "2018",
    address = "Belgium, Brussels",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-6319",
    pages = "186--191",
}
'''

lowerCAmelCase__  :Optional[Any]             =							'''\
ChrF and ChrF++ are two MT evaluation metrics. They both use the F-score statistic for character n-gram matches,
and ChrF++ adds word n-grams as well which correlates more strongly with direct assessment. We use the implementation
that is already present in sacrebleu.

The implementation here is slightly different from sacrebleu in terms of the required input format. The length of
the references and hypotheses lists need to be the same, so you may need to transpose your references compared to
sacrebleu\'s required input format. See https://github.com/huggingface/datasets/issues/3154#issuecomment-950746534

See the README.md file at https://github.com/mjpost/sacreBLEU#chrf--chrf for more information.
'''

lowerCAmelCase__  :Dict             =							'''
Produces ChrF(++) scores for hypotheses given reference translations.

Args:
    predictions (list of str): The predicted sentences.
    references (list of list of str): The references. There should be one reference sub-list for each prediction sentence.
    char_order (int): Character n-gram order. Defaults to `6`.
    word_order (int): Word n-gram order. If equals to `2`, the metric is referred to as chrF++. Defaults to `0`.
    beta (int): Determine the importance of recall w.r.t precision. Defaults to `2`.
    lowercase (bool): if `True`, enables case-insensitivity. Defaults to `False`.
    whitespace (bool): If `True`, include whitespaces when extracting character n-grams.
    eps_smoothing (bool): If `True`, applies epsilon smoothing similar
    to reference chrF++.py, NLTK and Moses implementations. If `False`,
    it takes into account effective match order similar to sacreBLEU < 2.0.0. Defaults to `False`.

Returns:
    \'score\' (float): The chrF (chrF++) score,
    \'char_order\' (int): The character n-gram order,
    \'word_order\' (int): The word n-gram order. If equals to 2, the metric is referred to as chrF++,
    \'beta\' (int): Determine the importance of recall w.r.t precision

Examples:
    Example 1--a simple example of calculating chrF:
        >>> prediction = ["The relationship between cats and dogs is not exactly friendly.", "a good bookshop is just a genteel black hole that knows how to read."]
        >>> reference = [["The relationship between dogs and cats is not exactly friendly."], ["A good bookshop is just a genteel Black Hole that knows how to read."]]
        >>> chrf = datasets.load_metric("chrf")
        >>> results = chrf.compute(predictions=prediction, references=reference)
        >>> print(results)
        {\'score\': 84.64214891738334, \'char_order\': 6, \'word_order\': 0, \'beta\': 2}

    Example 2--the same example, but with the argument word_order=2, to calculate chrF++ instead of chrF:
        >>> prediction = ["The relationship between cats and dogs is not exactly friendly.", "a good bookshop is just a genteel black hole that knows how to read."]
        >>> reference = [["The relationship between dogs and cats is not exactly friendly."], ["A good bookshop is just a genteel Black Hole that knows how to read."]]
        >>> chrf = datasets.load_metric("chrf")
        >>> results = chrf.compute(predictions=prediction,
        ...                         references=reference,
        ...                         word_order=2)
        >>> print(results)
        {\'score\': 82.87263732906315, \'char_order\': 6, \'word_order\': 2, \'beta\': 2}

    Example 3--the same chrF++ example as above, but with `lowercase=True` to normalize all case:
        >>> prediction = ["The relationship between cats and dogs is not exactly friendly.", "a good bookshop is just a genteel black hole that knows how to read."]
        >>> reference = [["The relationship between dogs and cats is not exactly friendly."], ["A good bookshop is just a genteel Black Hole that knows how to read."]]
        >>> chrf = datasets.load_metric("chrf")
        >>> results = chrf.compute(predictions=prediction,
        ...                         references=reference,
        ...                         word_order=2,
        ...                         lowercase=True)
        >>> print(results)
        {\'score\': 92.12853119829202, \'char_order\': 6, \'word_order\': 2, \'beta\': 2}
'''

@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION   ,				_KWARGS_DESCRIPTION      )
class 		__a				(    datasets.Metric      ):
		def      UpperCAmelCase__    (      self						)			->	str:




									"""simple docstring"""





									if version.parse(scb.__version__						) < version.parse('1.4.12'						):
																raise ImportWarning(
																    'To use `sacrebleu`, the module `sacrebleu>=1.4.12` is required, and the current version of `sacrebleu` doesn\'t match this condition.\n'
																    'You can install it with `pip install "sacrebleu>=1.4.12"`.'						)
									return datasets.MetricInfo(
									    description=_DESCRIPTION      ,   citation=_CITATION      ,   homepage='https://github.com/mjpost/sacreBLEU#chrf--chrf'      ,   inputs_description=_KWARGS_DESCRIPTION      ,   features=datasets.Features(
									        {
									            'predictions': datasets.Value('string'      ,   id='sequence'						),
									            'references': datasets.Sequence(datasets.Value('string'      ,   id='sequence'						)      ,   id='references'						),
									        }						)      ,   codebase_urls=['https://github.com/mjpost/sacreBLEU#chrf--chrf']      ,   reference_urls=[
									        'https://github.com/m-popovic/chrF',
									    ]      ,   )






		def      UpperCAmelCase__    (      self      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE = CHRF.CHAR_ORDER      ,   _SCREAMING_SNAKE_CASE = CHRF.WORD_ORDER      ,   _SCREAMING_SNAKE_CASE = CHRF.BETA      ,   _SCREAMING_SNAKE_CASE = False      ,   _SCREAMING_SNAKE_CASE = False      ,   _SCREAMING_SNAKE_CASE = False      ,   )			->	Optional[Any]:




									"""simple docstring"""





									_UpperCAmelCase					=      len(references[0]						)
									if any(len(_SCREAMING_SNAKE_CASE						) != references_per_prediction for refs in references						):
																raise ValueError('Sacrebleu requires the same number of references for each prediction'						)
									_UpperCAmelCase					=      [[refs[i] for refs in references] for i in range(_SCREAMING_SNAKE_CASE						)]

									_UpperCAmelCase					=      CHRF(_SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE						)
									_UpperCAmelCase					=      sb_chrf.corpus_score(_SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE						)

									return {
									    "score": output.score,
									    "char_order": output.char_order,
									    "word_order": output.word_order,
									    "beta": output.beta,
									}




import tempfile
import unittest

from transformers import TaConfig, is_torch_available
from transformers.testing_utils import (
    require_sentencepiece,
    require_tokenizers,
    require_torch,
    slow,
    torch_device,
)

from ...generation.test_utils import GenerationTesterMixin
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
		import torch

		from transformers import AutoTokenizer, UMTaForConditionalGeneration, UMTaForQuestionAnswering, UMTaModel

class 		__a				:
		def __init__(      self      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE=99      ,   _SCREAMING_SNAKE_CASE=13      ,   _SCREAMING_SNAKE_CASE=7      ,   _SCREAMING_SNAKE_CASE=9      ,   _SCREAMING_SNAKE_CASE=True      ,   _SCREAMING_SNAKE_CASE=True      ,   _SCREAMING_SNAKE_CASE=False      ,   _SCREAMING_SNAKE_CASE=32      ,   _SCREAMING_SNAKE_CASE=5      ,   _SCREAMING_SNAKE_CASE=4      ,   _SCREAMING_SNAKE_CASE=37      ,   _SCREAMING_SNAKE_CASE=8      ,   _SCREAMING_SNAKE_CASE=0.1      ,   _SCREAMING_SNAKE_CASE=0.002      ,   _SCREAMING_SNAKE_CASE=1      ,   _SCREAMING_SNAKE_CASE=0      ,   _SCREAMING_SNAKE_CASE=0      ,   _SCREAMING_SNAKE_CASE=None      ,   _SCREAMING_SNAKE_CASE=None      ,   )			->	Tuple:




									"""simple docstring"""





									_UpperCAmelCase					=      parent
									_UpperCAmelCase					=      batch_size
									_UpperCAmelCase					=      encoder_seq_length
									_UpperCAmelCase					=      decoder_seq_length
									# For common tests
									_UpperCAmelCase					=      self.decoder_seq_length
									_UpperCAmelCase					=      is_training
									_UpperCAmelCase					=      use_attention_mask
									_UpperCAmelCase					=      use_labels
									_UpperCAmelCase					=      vocab_size
									_UpperCAmelCase					=      hidden_size
									_UpperCAmelCase					=      num_hidden_layers
									_UpperCAmelCase					=      num_attention_heads
									_UpperCAmelCase					=      d_ff
									_UpperCAmelCase					=      relative_attention_num_buckets
									_UpperCAmelCase					=      dropout_rate
									_UpperCAmelCase					=      initializer_factor
									_UpperCAmelCase					=      eos_token_id
									_UpperCAmelCase					=      pad_token_id
									_UpperCAmelCase					=      decoder_start_token_id
									_UpperCAmelCase					=      None
									_UpperCAmelCase					=      decoder_layers
		def      UpperCAmelCase__    (      self						)			->	List[str]:




									"""simple docstring"""





									return TaConfig.from_pretrained('google/umt5-base'						)
		def      UpperCAmelCase__    (      self      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE=None      ,   _SCREAMING_SNAKE_CASE=None      ,   _SCREAMING_SNAKE_CASE=None      ,   _SCREAMING_SNAKE_CASE=None      ,   _SCREAMING_SNAKE_CASE=None      ,   )			->	List[str]:




									"""simple docstring"""





									if attention_mask is None:
																_UpperCAmelCase					=      input_ids.ne(config.pad_token_id						)
									if decoder_attention_mask is None:
																_UpperCAmelCase					=      decoder_input_ids.ne(config.pad_token_id						)
									if head_mask is None:
																_UpperCAmelCase					=      torch.ones(config.num_hidden_layers      ,   config.num_attention_heads      ,   device=_SCREAMING_SNAKE_CASE						)
									if decoder_head_mask is None:
																_UpperCAmelCase					=      torch.ones(config.num_decoder_layers      ,   config.num_attention_heads      ,   device=_SCREAMING_SNAKE_CASE						)
									if cross_attn_head_mask is None:
																_UpperCAmelCase					=      torch.ones(
																    config.num_decoder_layers      ,   config.num_attention_heads      ,   device=_SCREAMING_SNAKE_CASE						)
									return {
									    "input_ids": input_ids,
									    "decoder_input_ids": decoder_input_ids,
									    "attention_mask": attention_mask,
									    "decoder_attention_mask": decoder_attention_mask,
									    "head_mask": head_mask,
									    "decoder_head_mask": decoder_head_mask,
									    "cross_attn_head_mask": cross_attn_head_mask,
									}
		def      UpperCAmelCase__    (      self						)			->	Union[str, Any]:




									"""simple docstring"""





									_UpperCAmelCase					=      ids_tensor([self.batch_size, self.encoder_seq_length]      ,   self.vocab_size						)
									_UpperCAmelCase					=      ids_tensor([self.batch_size, self.decoder_seq_length]      ,   self.vocab_size						)

									# we need to clamp the input ids here to avoid having pad token in between
									# this is because for NllbMoe the position_ids are prepared such that
									# all pad tokens have pos id = 2 and rest are between 2..seq_length
									# and the seq_length here is seq_length - num_pad_tokens
									# but when using past, there is no way of knowing if the past input ids had
									# pad tokens in them, which results in incorrect seq_lenth and which in turn results in
									# position_ids being off by num_pad_tokens in past input
									_UpperCAmelCase					=      input_ids.clamp(self.pad_token_id + 1						)
									_UpperCAmelCase					=      decoder_input_ids.clamp(self.pad_token_id + 1						)

									_UpperCAmelCase					=      self.get_config()
									_UpperCAmelCase					=      config.num_attention_heads
									_UpperCAmelCase					=      self.prepare_inputs_dict(_SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE						)
									return config, input_dict
		def      UpperCAmelCase__    (      self						)			->	Any:




									"""simple docstring"""





									_UpperCAmelCase		,	_UpperCAmelCase					=      self.prepare_config_and_inputs()
									return config, inputs_dict
		def      UpperCAmelCase__    (      self						)			->	Dict:




									"""simple docstring"""





									return TaConfig(
									    vocab_size=166      ,   d_model=self.hidden_size      ,   d_ff=self.d_ff      ,   d_kv=self.hidden_size // self.num_attention_heads      ,   num_layers=self.num_hidden_layers      ,   num_decoder_layers=self.decoder_layers      ,   num_heads=self.num_attention_heads      ,   relative_attention_num_buckets=self.relative_attention_num_buckets      ,   dropout_rate=self.dropout_rate      ,   initializer_factor=self.initializer_factor      ,   eos_token_id=self.eos_token_id      ,   bos_token_id=self.pad_token_id      ,   pad_token_id=self.pad_token_id      ,   decoder_start_token_id=self.decoder_start_token_id      ,   )
		def      UpperCAmelCase__    (      self						)			->	List[Any]:




									"""simple docstring"""





									return TaConfig(
									    vocab_size=self.vocab_size      ,   d_model=self.hidden_size      ,   d_ff=self.d_ff      ,   d_kv=self.hidden_size // self.num_attention_heads      ,   num_layers=self.num_hidden_layers      ,   num_decoder_layers=self.decoder_layers      ,   num_heads=self.num_attention_heads      ,   relative_attention_num_buckets=self.relative_attention_num_buckets      ,   dropout_rate=self.dropout_rate      ,   initializer_factor=self.initializer_factor      ,   eos_token_id=self.eos_token_id      ,   bos_token_id=self.pad_token_id      ,   pad_token_id=self.pad_token_id      ,   decoder_start_token_id=self.decoder_start_token_id      ,   )
		def      UpperCAmelCase__    (      self      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   )			->	str:




									"""simple docstring"""





									_UpperCAmelCase					=      UMTaModel(config=_SCREAMING_SNAKE_CASE						)
									model.to(_SCREAMING_SNAKE_CASE						)
									model.eval()
									_UpperCAmelCase					=      model(
									    input_ids=_SCREAMING_SNAKE_CASE      ,   decoder_input_ids=_SCREAMING_SNAKE_CASE      ,   attention_mask=_SCREAMING_SNAKE_CASE      ,   decoder_attention_mask=_SCREAMING_SNAKE_CASE      ,   )
									_UpperCAmelCase					=      model(input_ids=_SCREAMING_SNAKE_CASE      ,   decoder_input_ids=_SCREAMING_SNAKE_CASE						)
									_UpperCAmelCase					=      result.last_hidden_state
									_UpperCAmelCase					=      result.past_key_values
									_UpperCAmelCase					=      result.encoder_last_hidden_state

									self.parent.assertEqual(encoder_output.size()      ,   (self.batch_size, self.encoder_seq_length, self.hidden_size)						)
									self.parent.assertEqual(decoder_output.size()      ,   (self.batch_size, self.decoder_seq_length, self.hidden_size)						)
									# There should be `num_layers` key value embeddings stored in decoder_past
									self.parent.assertEqual(len(_SCREAMING_SNAKE_CASE						)      ,   config.num_layers						)
									# There should be a self attn key, a self attn value, a cross attn key and a cross attn value stored in each decoder_past tuple
									self.parent.assertEqual(len(decoder_past[0]						)      ,   4						)
		def      UpperCAmelCase__    (      self      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   )			->	Optional[int]:




									"""simple docstring"""





									_UpperCAmelCase					=      UMTaModel(config=_SCREAMING_SNAKE_CASE						).get_decoder().to(_SCREAMING_SNAKE_CASE						).eval()
									# first forward pass
									_UpperCAmelCase					=      model(_SCREAMING_SNAKE_CASE      ,   use_cache=_SCREAMING_SNAKE_CASE						)
									_UpperCAmelCase					=      model(_SCREAMING_SNAKE_CASE						)
									_UpperCAmelCase					=      model(_SCREAMING_SNAKE_CASE      ,   use_cache=_SCREAMING_SNAKE_CASE						)

									self.parent.assertTrue(len(_SCREAMING_SNAKE_CASE						) == len(_SCREAMING_SNAKE_CASE						)						)
									self.parent.assertTrue(len(_SCREAMING_SNAKE_CASE						) == len(_SCREAMING_SNAKE_CASE						) + 1						)

									_UpperCAmelCase		,	_UpperCAmelCase					=      outputs.to_tuple()

									# create hypothetical next token and extent to next_input_ids
									_UpperCAmelCase					=      ids_tensor((self.batch_size, 1)      ,   config.vocab_size						)

									# append to next input_ids and
									_UpperCAmelCase					=      torch.cat([input_ids, next_tokens]      ,   dim=-1						)

									_UpperCAmelCase					=      model(_SCREAMING_SNAKE_CASE						)['last_hidden_state']
									_UpperCAmelCase					=      model(_SCREAMING_SNAKE_CASE      ,   past_key_values=_SCREAMING_SNAKE_CASE						)['last_hidden_state']

									# select random slice
									_UpperCAmelCase					=      ids_tensor((1,)      ,   output_from_past.shape[-1]						).item()
									_UpperCAmelCase					=      output_from_no_past[:, -1, random_slice_idx].detach()
									_UpperCAmelCase					=      output_from_past[:, 0, random_slice_idx].detach()

									# test that outputs are equal for slice
									self.parent.assertTrue(torch.allclose(_SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   atol=1e-3						)						)






		def      UpperCAmelCase__    (      self      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   )			->	List[str]:




									"""simple docstring"""





									_UpperCAmelCase					=      UMTaModel(config=_SCREAMING_SNAKE_CASE						).to(_SCREAMING_SNAKE_CASE						).half().eval()
									_UpperCAmelCase					=      model(**_SCREAMING_SNAKE_CASE						)['last_hidden_state']
									self.parent.assertFalse(torch.isnan(_SCREAMING_SNAKE_CASE						).any().item()						)



@require_torch
class 		__a				(    UpperCAmelCase   ,				UpperCAmelCase   ,				UpperCAmelCase   ,				unittest.TestCase      ):
		_a     :  Union[str, Any]           =     (
		    (UMTaModel, UMTaForConditionalGeneration, UMTaForQuestionAnswering) if is_torch_available() else ()
		)
		_a     :  List[Any]           =     (UMTaForConditionalGeneration,) if is_torch_available() else ()
		_a     :  Tuple           =     (
		    {
		        'conversational': UMTaForConditionalGeneration,
		        'feature-extraction': UMTaModel,
		        'summarization': UMTaForConditionalGeneration,
		        'text2text-generation': UMTaForConditionalGeneration,
		        'translation': UMTaForConditionalGeneration,
		        'question-answering': UMTaForQuestionAnswering,
		    }
		    if is_torch_available()
		    else {}
		)
		_a     :  List[str]           =     True
		_a     :  List[Any]           =     False
		_a     :  Tuple           =     False
		_a     :  List[Any]           =     True
		_a     :  str           =     True
		# The small UMT5 model needs higher percentages for CPU/MP tests
		_a     :  Tuple           =     [0.8, 0.9]
		def      UpperCAmelCase__    (      self						)			->	List[str]:




									"""simple docstring"""





									_UpperCAmelCase					=      UMTaModelTester(self						)
		@unittest.skip('Test has a segmentation fault on torch 1.8.0'						)
		def      UpperCAmelCase__    (      self						)			->	Union[str, Any]:




									"""simple docstring"""





									_UpperCAmelCase					=      self.model_tester.prepare_config_and_inputs()
									_UpperCAmelCase					=      UMTaModel(config_and_inputs[0]						).to(_SCREAMING_SNAKE_CASE						)
									with tempfile.TemporaryDirectory() as tmpdirname:
																torch.onnx.export(
																    _SCREAMING_SNAKE_CASE      ,   (config_and_inputs[1], config_and_inputs[3], config_and_inputs[2])      ,   f'''{tmpdirname}/t5_test.onnx'''      ,   export_params=_SCREAMING_SNAKE_CASE      ,   opset_version=9      ,   input_names=['input_ids', 'decoder_input_ids']      ,   )
		@unittest.skipIf(torch_device == 'cpu'      ,   'Cant do half precision'						)
		def      UpperCAmelCase__    (      self						)			->	Tuple:




									"""simple docstring"""





									_UpperCAmelCase					=      self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model_fpaa_forward(*_SCREAMING_SNAKE_CASE						)
		def      UpperCAmelCase__    (      self						)			->	int:




									"""simple docstring"""





									_UpperCAmelCase					=      ['encoder_attentions', 'decoder_attentions', 'cross_attentions']
									_UpperCAmelCase					=      self.model_tester.prepare_config_and_inputs()
									_UpperCAmelCase					=      config_and_inputs[0]
									_UpperCAmelCase					=      UMTaForConditionalGeneration(_SCREAMING_SNAKE_CASE						).eval()
									model.to(_SCREAMING_SNAKE_CASE						)

									_UpperCAmelCase					=      {
									    'head_mask': torch.zeros(config.num_layers      ,   config.num_heads      ,   device=_SCREAMING_SNAKE_CASE						),
									    'decoder_head_mask': torch.zeros(config.num_decoder_layers      ,   config.num_heads      ,   device=_SCREAMING_SNAKE_CASE						),
									    'cross_attn_head_mask': torch.zeros(config.num_decoder_layers      ,   config.num_heads      ,   device=_SCREAMING_SNAKE_CASE						),
									}

									for attn_name, (name, mask) in zip(_SCREAMING_SNAKE_CASE      ,   head_masking.items()						):
																_UpperCAmelCase					=      {name: mask}
																# Explicitly pass decoder_head_mask as it is required from T5 model when head_mask specified
																if name == "head_mask":
																							_UpperCAmelCase					=      torch.ones(
																							    config.num_decoder_layers      ,   config.num_heads      ,   device=_SCREAMING_SNAKE_CASE						)

																_UpperCAmelCase					=      model.generate(
																    config_and_inputs[1]['input_ids']      ,   num_beams=1      ,   max_length=3      ,   output_attentions=_SCREAMING_SNAKE_CASE      ,   return_dict_in_generate=_SCREAMING_SNAKE_CASE      ,   **_SCREAMING_SNAKE_CASE      ,   )
																# We check the state of decoder_attentions and cross_attentions just from the last step
																_UpperCAmelCase					=      out[attn_name] if attn_name == attention_names[0] else out[attn_name][-1]
																self.assertEqual(sum([w.sum().item() for w in attn_weights]						)      ,   0.0						)






		@unittest.skip('Does not work on the tiny model as we keep hitting edge cases.'						)
		def      UpperCAmelCase__    (      self						)			->	int:




									"""simple docstring"""





									pass



@require_torch
@require_sentencepiece
@require_tokenizers
class 		__a				(    unittest.TestCase      ):
		@slow
		@unittest.skip(
		    'Unless we stop stripping left and right by default for all special tokens, the expected ids obtained here will not match the original ones. Wait for https://github.com/huggingface/transformers/pull/23909 to be merged'						)
		def      UpperCAmelCase__    (      self						)			->	List[str]:




									"""simple docstring"""





									_UpperCAmelCase					=      UMTaForConditionalGeneration.from_pretrained('google/umt5-small'      ,   return_dict=_SCREAMING_SNAKE_CASE						).to(_SCREAMING_SNAKE_CASE						)
									_UpperCAmelCase					=      AutoTokenizer.from_pretrained('google/umt5-small'      ,   use_fast=_SCREAMING_SNAKE_CASE      ,   legacy=_SCREAMING_SNAKE_CASE						)
									_UpperCAmelCase					=      [
									    'Bonjour monsieur <extra_id_0> bien <extra_id_1>.',
									    'No se como puedo <extra_id_0>.',
									    'This is the reason why we <extra_id_0> them.',
									    'The <extra_id_0> walks in <extra_id_1>, seats',
									    'A <extra_id_0> walks into a bar and orders a <extra_id_1> with <extra_id_2> pinch of <extra_id_3>.',
									]
									_UpperCAmelCase					=      tokenizer(_SCREAMING_SNAKE_CASE      ,   return_tensors='pt'      ,   padding=_SCREAMING_SNAKE_CASE						).input_ids
									# fmt: off
									_UpperCAmelCase					=      torch.tensor(
									    [
									        [ 38530, 210703, 256299, 1410, 256298, 274, 1, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0],
									        [   826, 321, 671, 25922, 256299, 274, 1, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0],
									        [  1460, 339, 312, 19014, 10620, 758, 256299, 2355,274, 1, 0, 0, 0, 0, 0, 0,0, 0],
									        [   517, 256299, 14869, 281, 301, 256298, 275, 119983,1, 0, 0, 0, 0, 0, 0, 0,0, 0],
									        [   320, 256299, 14869, 281, 2234, 289, 2275, 333,61391, 289, 256298, 543, 256297, 168714, 329, 256296,274, 1],
									    ]						)
									# fmt: on
									torch.testing.assert_allclose(_SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE						)

									_UpperCAmelCase					=      model.generate(input_ids.to(_SCREAMING_SNAKE_CASE						)						)
									_UpperCAmelCase					=      [
									    '<pad><extra_id_0> et<extra_id_1> [eod] <extra_id_2><extra_id_55>.. [eod] 💐 💐 💐 💐 💐 💐 💐 💐 💐 💐 💐 <extra_id_56>ajšietosto<extra_id_56>lleux<extra_id_19><extra_id_6>ajšie</s>',
									    '<pad><extra_id_0>.<extra_id_1>.,<0x0A>...spech <0x0A><extra_id_20> <extra_id_21></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>',
									    '<pad><extra_id_0> are not going to be a part of the world. We are not going to be a part of<extra_id_1> and<extra_id_2><0x0A><extra_id_48>.<extra_id_48></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>',
									    '<pad><extra_id_0> door<extra_id_1>, the door<extra_id_2> 피해[/</s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>',
									    '<pad><extra_id_0>nyone who<extra_id_1> drink<extra_id_2> a<extra_id_3> alcohol<extra_id_4> A<extra_id_5> A. This<extra_id_6> I<extra_id_7><extra_id_52><extra_id_53></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>',
									]
									_UpperCAmelCase					=      tokenizer.batch_decode(_SCREAMING_SNAKE_CASE						)
									self.assertEqual(_SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE						)
