code: 
  
  
  from collections import OrderedDict
  from typing import Any, Mapping, Optional
  
  from ... import PreTrainedTokenizer
  from ...configuration_utils import PretrainedConfig
  from ...onnx import OnnxConfig, OnnxConfigWithPast, OnnxSeqaSeqConfigWithPast
  from ...onnx.utils import compute_effective_axis_dimension
  from ...utils import TensorType, is_torch_available, logging
  
  
  UpperCAmelCase      :						str    =		logging.get_logger(__name__)
  
  UpperCAmelCase      :						Optional[int]    =		{
      """facebook/mbart-large-cc25""": """https://huggingface.co/facebook/mbart-large-cc25/resolve/main/config.json""",
      # See all MBART models at https://huggingface.co/models?filter=mbart
  }
  
  
  
  
  
  
  
  class 					__lowercase					(       UpperCAmelCase__     ):
  
  
  
  		"""simple docstring"""
  
  		UpperCamelCase    :				List[str] 					=		'mbart'
  		UpperCamelCase    :				Union[str, Any] 					=		['past_key_values']
  		UpperCamelCase    :				List[str] 					=		{'num_attention_heads': 'encoder_attention_heads', 'hidden_size': 'd_model'}
  
  
  
  
  
  
  
  		def __init__(   self		,			A=5_02_65		,			A=10_24		,			A=12		,			A=40_96		,			A=16		,			A=12		,			A=40_96		,			A=16		,			A=0.0		,			A=0.0		,			A=True		,			A=True		,			A="gelu"		,			A=10_24		,			A=0.1		,			A=0.0		,			A=0.0		,			A=0.02		,			A=0.0		,			A=False		,			A=1		,			A=0		,			A=2		,			A=2		,			**A		,			)     ->   List[Any]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     vocab_size
  					lowerCamelCase								=     max_position_embeddings
  					lowerCamelCase								=     d_model
  					lowerCamelCase								=     encoder_ffn_dim
  					lowerCamelCase								=     encoder_layers
  					lowerCamelCase								=     encoder_attention_heads
  					lowerCamelCase								=     decoder_ffn_dim
  					lowerCamelCase								=     decoder_layers
  					lowerCamelCase								=     decoder_attention_heads
  					lowerCamelCase								=     dropout
  					lowerCamelCase								=     attention_dropout
  					lowerCamelCase								=     activation_dropout
  					lowerCamelCase								=     activation_function
  					lowerCamelCase								=     init_std
  					lowerCamelCase								=     encoder_layerdrop
  					lowerCamelCase								=     decoder_layerdrop
  					lowerCamelCase								=     classifier_dropout
  					lowerCamelCase								=     use_cache
  					lowerCamelCase								=     encoder_layers
  					lowerCamelCase								=     scale_embedding  # scale factor will be sqrt(d_model) if True
  					super().__init__(
  					    pad_token_id=lowerCamelCase__		,			bos_token_id=lowerCamelCase__		,			eos_token_id=lowerCamelCase__		,			is_encoder_decoder=lowerCamelCase__		,			forced_eos_token_id=lowerCamelCase__		,			**lowerCamelCase__		,			)
  
  
  
  
  
  
  
  class 					__lowercase					(       UpperCAmelCase__     ):
  
  
  
  		"""simple docstring"""
  
  		@property
  		def 				__A      (   self  )     ->   Dict:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					if self.task in ["default", "seq2seq-lm"]:
  								lowerCamelCase								=     OrderedDict(
  								    [
  								        ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}),
  								        ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}),
  								    ]  )
  
  								if self.use_past:
  											lowerCamelCase								=     {0: "batch"}
  											lowerCamelCase								=     {0: "batch", 1: "past_decoder_sequence + sequence"}
  								else:
  											lowerCamelCase								=     {0: "batch", 1: "decoder_sequence"}
  											lowerCamelCase								=     {0: "batch", 1: "decoder_sequence"}
  
  								if self.use_past:
  											self.fill_with_past_key_values_(lowerCamelCase__		,			direction="""inputs"""  )
  					elif self.task == "causal-lm":
  								# TODO: figure this case out.
  								lowerCamelCase								=     OrderedDict(
  								    [
  								        ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}),
  								        ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}),
  								    ]  )
  								if self.use_past:
  											lowerCamelCase								=     self.num_layers
  											for i in range(lowerCamelCase__  ):
  														lowerCamelCase								=     {0: "batch", 2: "past_sequence + sequence"}
  														lowerCamelCase								=     {0: "batch", 2: "past_sequence + sequence"}
  					else:
  								lowerCamelCase								=     OrderedDict(
  								    [
  								        ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}),
  								        ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}),
  								        ("""decoder_input_ids""", {0: """batch""", 1: """decoder_sequence"""}),
  								        ("""decoder_attention_mask""", {0: """batch""", 1: """decoder_sequence"""}),
  								    ]  )
  
  					return common_inputs
  
  
  
  
  
  
  
  		@property
  		def 				__A      (   self  )     ->   Optional[Any]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					if self.task in ["default", "seq2seq-lm"]:
  								lowerCamelCase								=     super().outputs
  					else:
  								lowerCamelCase								=     super(lowerCamelCase__		,			self  ).outputs
  								if self.use_past:
  											lowerCamelCase								=     self.num_layers
  											for i in range(lowerCamelCase__  ):
  														lowerCamelCase								=     {0: "batch", 2: "past_sequence + sequence"}
  														lowerCamelCase								=     {0: "batch", 2: "past_sequence + sequence"}
  					return common_outputs
  
  
  
  
  
  
  
  		def 				__A      (   self		,			A		,			A = -1		,			A = -1		,			A = False		,			A = None		,			)     ->   int:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
  					    lowerCamelCase__		,			lowerCamelCase__		,			lowerCamelCase__		,			lowerCamelCase__		,			lowerCamelCase__  )
  
  					# Generate decoder inputs
  					lowerCamelCase								=     seq_length if not self.use_past else 1
  					lowerCamelCase								=     self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
  					    lowerCamelCase__		,			lowerCamelCase__		,			lowerCamelCase__		,			lowerCamelCase__		,			lowerCamelCase__  )
  					lowerCamelCase								=     {F'decoder_{name}': tensor for name, tensor in decoder_inputs.items()}
  					lowerCamelCase								=     dict(**lowerCamelCase__		,			**lowerCamelCase__  )
  
  					if self.use_past:
  								if not is_torch_available():
  											raise ValueError("""Cannot generate dummy past_keys inputs without PyTorch installed."""  )
  								else:
  											import torch
  								lowerCamelCase								=     common_inputs["input_ids"].shape
  								lowerCamelCase								=     common_inputs["decoder_input_ids"].shape[1]
  								lowerCamelCase								=     self.num_attention_heads
  								lowerCamelCase								=     (
  								    batch,
  								    num_encoder_attention_heads,
  								    encoder_seq_length,
  								    self._config.hidden_size // num_encoder_attention_heads,
  								)
  								lowerCamelCase								=     decoder_seq_length + 3
  								lowerCamelCase								=     (
  								    batch,
  								    num_decoder_attention_heads,
  								    decoder_past_length,
  								    self._config.hidden_size // num_decoder_attention_heads,
  								)
  
  								lowerCamelCase								=     torch.cat(
  								    [common_inputs["""decoder_attention_mask"""], torch.ones(lowerCamelCase__		,			lowerCamelCase__  )]		,			dim=1  )
  
  								lowerCamelCase								=     []
  								# If the number of encoder and decoder layers are present in the model configuration, both are considered
  								lowerCamelCase								=     self.num_layers
  								lowerCamelCase								=     min(lowerCamelCase__		,			lowerCamelCase__  )
  								lowerCamelCase								=     max(lowerCamelCase__		,			lowerCamelCase__  ) - min_num_layers
  								lowerCamelCase								=     "encoder" if num_encoder_layers > num_decoder_layers else "decoder"
  
  								for _ in range(lowerCamelCase__  ):
  											common_inputs["past_key_values"].append(
  											    (
  											        torch.zeros(lowerCamelCase__  ),
  											        torch.zeros(lowerCamelCase__  ),
  											        torch.zeros(lowerCamelCase__  ),
  											        torch.zeros(lowerCamelCase__  ),
  											    )  )
  								# TODO: test this.
  								lowerCamelCase								=     encoder_shape if remaining_side_name == "encoder" else decoder_shape
  								for _ in range(lowerCamelCase__		,			lowerCamelCase__  ):
  											common_inputs["past_key_values"].append((torch.zeros(lowerCamelCase__  ), torch.zeros(lowerCamelCase__  ))  )
  					return common_inputs
  
  
  
  
  
  
  
  		def 				__A      (   self		,			A		,			A = -1		,			A = -1		,			A = False		,			A = None		,			)     ->   Union[str, Any]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
  					    lowerCamelCase__		,			lowerCamelCase__		,			lowerCamelCase__		,			lowerCamelCase__		,			lowerCamelCase__  )
  
  					if self.use_past:
  								if not is_torch_available():
  											raise ValueError("""Cannot generate dummy past_keys inputs without PyTorch installed."""  )
  								else:
  											import torch
  								lowerCamelCase								=     common_inputs["input_ids"].shape
  								# Not using the same length for past_key_values
  								lowerCamelCase								=     seqlen + 2
  								lowerCamelCase								=     self.num_layers
  								lowerCamelCase								=     self.num_attention_heads
  								lowerCamelCase								=     (
  								    batch,
  								    num_encoder_attention_heads,
  								    past_key_values_length,
  								    self._config.hidden_size // num_encoder_attention_heads,
  								)
  
  								lowerCamelCase								=     common_inputs["attention_mask"].dtype
  								lowerCamelCase								=     torch.cat(
  								    [common_inputs["""attention_mask"""], torch.ones(lowerCamelCase__		,			lowerCamelCase__		,			dtype=lowerCamelCase__  )]		,			dim=1  )
  								lowerCamelCase								=     [
  								    (torch.zeros(lowerCamelCase__  ), torch.zeros(lowerCamelCase__  )) for _ in range(lowerCamelCase__  )
  								]
  					return common_inputs
  
  
  
  
  
  
  
  		def 				__A      (   self		,			A		,			A = -1		,			A = -1		,			A = False		,			A = None		,			)     ->   List[str]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     compute_effective_axis_dimension(
  					    lowerCamelCase__		,			fixed_dimension=OnnxConfig.default_fixed_batch		,			num_token_to_add=0  )
  
  					# If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
  					lowerCamelCase								=     tokenizer.num_special_tokens_to_add(lowerCamelCase__  )
  					lowerCamelCase								=     compute_effective_axis_dimension(
  					    lowerCamelCase__		,			fixed_dimension=OnnxConfig.default_fixed_sequence		,			num_token_to_add=lowerCamelCase__  )
  
  					# Generate dummy inputs according to compute batch and sequence
  					lowerCamelCase								=     [" ".join([tokenizer.unk_token]  ) * seq_length] * batch_size
  					lowerCamelCase								=     dict(tokenizer(lowerCamelCase__		,			return_tensors=lowerCamelCase__  )  )
  					return common_inputs
  
  
  
  
  
  
  
  		def 				__A      (   self		,			A		,			A = -1		,			A = -1		,			A = False		,			A = None		,			)     ->   str:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					if self.task in ["default", "seq2seq-lm"]:
  								lowerCamelCase								=     self._generate_dummy_inputs_for_default_and_seqaseq_lm(
  								    lowerCamelCase__		,			batch_size=lowerCamelCase__		,			seq_length=lowerCamelCase__		,			is_pair=lowerCamelCase__		,			framework=lowerCamelCase__  )
  
  					elif self.task == "causal-lm":
  								lowerCamelCase								=     self._generate_dummy_inputs_for_causal_lm(
  								    lowerCamelCase__		,			batch_size=lowerCamelCase__		,			seq_length=lowerCamelCase__		,			is_pair=lowerCamelCase__		,			framework=lowerCamelCase__  )
  					else:
  								lowerCamelCase								=     self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
  								    lowerCamelCase__		,			batch_size=lowerCamelCase__		,			seq_length=lowerCamelCase__		,			is_pair=lowerCamelCase__		,			framework=lowerCamelCase__  )
  
  					return common_inputs
  
  
  
  
  
  
  
  		def 				__A      (   self		,			A		,			A		,			A		,			A  )     ->   str:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					if self.task in ["default", "seq2seq-lm"]:
  								lowerCamelCase								=     super()._flatten_past_key_values_(lowerCamelCase__		,			lowerCamelCase__		,			lowerCamelCase__		,			lowerCamelCase__  )
  					else:
  								lowerCamelCase								=     super(lowerCamelCase__		,			self  )._flatten_past_key_values_(
  								    lowerCamelCase__		,			lowerCamelCase__		,			lowerCamelCase__		,			lowerCamelCase__  )
  
  
style_context: 
  
  
  import unittest
  
  from cer import CER
  
  
  UpperCAmelCase      :						Union[str, Any]    =		CER()
  
  
  
  
  
  
  
  class 					__lowercase					(       unittest.TestCase     ):
  
  
  
  		"""simple docstring"""
  
  		def 				__A      (   self  )     ->   Optional[int]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     ["""White House"""]
  					lowerCamelCase								=     ["""white house"""]
  					# S = 2, D = 0, I = 0, N = 11, CER = 2 / 11
  					lowerCamelCase								=     cer.compute(predictions=A		,			references=A  )
  					self.assertTrue(abs(char_error_rate - 0.1818181818  ) < 1e-6  )
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   List[str]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     ["""were wolf"""]
  					lowerCamelCase								=     ["""werewolf"""]
  					# S = 0, D = 0, I = 1, N = 9, CER = 1 / 9
  					lowerCamelCase								=     cer.compute(predictions=A		,			references=A  )
  					self.assertTrue(abs(char_error_rate - 0.1111111  ) < 1e-6  )
  
  					lowerCamelCase								=     ["""werewolf"""]
  					lowerCamelCase								=     ["""weae     wolf"""]
  					# S = 1, D = 1, I = 0, N = 8, CER = 0.25
  					lowerCamelCase								=     cer.compute(predictions=A		,			references=A  )
  					self.assertTrue(abs(char_error_rate - 0.25  ) < 1e-6  )
  
  					# consecutive whitespaces case 1
  					lowerCamelCase								=     ["""were wolf"""]
  					lowerCamelCase								=     ["""were               wolf"""]
  					# S = 0, D = 0, I = 0, N = 9, CER = 0
  					lowerCamelCase								=     cer.compute(predictions=A		,			references=A  )
  					self.assertTrue(abs(char_error_rate - 0.0  ) < 1e-6  )
  
  					# consecutive whitespaces case 2
  					lowerCamelCase								=     ["""were   wolf"""]
  					lowerCamelCase								=     ["""were               wolf"""]
  					# S = 0, D = 0, I = 0, N = 9, CER = 0
  					lowerCamelCase								=     cer.compute(predictions=A		,			references=A  )
  					self.assertTrue(abs(char_error_rate - 0.0  ) < 1e-6  )
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   str:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     ["""werewolf"""]
  					lowerCamelCase								=     ["""weaewolf"""]
  					# S = 1, D = 0, I = 0, N = 8, CER = 0.125
  					lowerCamelCase								=     cer.compute(predictions=A		,			references=A  )
  					self.assertTrue(abs(char_error_rate - 0.125  ) < 1e-6  )
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   Tuple:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     ["""werewolf"""]
  					lowerCamelCase								=     ["""wereawolf"""]
  					# S = 0, D = 1, I = 0, N = 8, CER = 0.125
  					lowerCamelCase								=     cer.compute(predictions=A		,			references=A  )
  					self.assertTrue(abs(char_error_rate - 0.125  ) < 1e-6  )
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   List[Any]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     ["""werewolf"""]
  					lowerCamelCase								=     ["""wereolf"""]
  					# S = 0, D = 0, I = 1, N = 8, CER = 0.125
  					lowerCamelCase								=     cer.compute(predictions=A		,			references=A  )
  					self.assertTrue(abs(char_error_rate - 0.125  ) < 1e-6  )
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   Tuple:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     ["""werewolf"""]
  					lowerCamelCase								=     cer.compute(predictions=A		,			references=A  )
  					self.assertEqual(A		,			0.0  )
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   List[str]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     ["""werewolf""", """I am your father"""]
  					lowerCamelCase								=     cer.compute(predictions=A		,			references=A  )
  					self.assertEqual(A		,			0.0  )
  
  					lowerCamelCase								=     ["""werewolf""", """I am your father""", """doge"""]
  					lowerCamelCase								=     ["""werxwolf""", """I       am your father""", """doge"""]
  					# S = 1, D = 0, I = 0, N = 28, CER = 1 / 28
  					lowerCamelCase								=     cer.compute(predictions=A		,			references=A  )
  					self.assertTrue(abs(char_error_rate - 0.03571428  ) < 1e-6  )
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   List[Any]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     ["""My hovercraft""", """is full of eels"""]
  					lowerCamelCase								=     ["""My hovercraft is full""", """ of eels"""]
  					# S = 0, D = 0, I = 2, N = 28, CER = 2 / 28
  					# whitespace at the front of " of eels" will be strip during preporcessing
  					# so need to insert 2 whitespaces
  					lowerCamelCase								=     cer.compute(predictions=A		,			references=A		,			concatenate_texts=A  )
  					self.assertTrue(abs(char_error_rate - 0.071428  ) < 1e-6  )
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   Optional[int]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     ["""我能吞下玻璃而不伤身体"""]
  					lowerCamelCase								=     [""" 能吞虾玻璃而 不霜身体啦"""]
  					# S = 3, D = 2, I = 0, N = 11, CER = 5 / 11
  					lowerCamelCase								=     cer.compute(predictions=A		,			references=A  )
  					self.assertTrue(abs(char_error_rate - 0.4545454545  ) < 1e-6  )
  
  					lowerCamelCase								=     ["""我能吞下玻璃""", """而不伤身体"""]
  					lowerCamelCase								=     ["""我    能 吞 下 玻 璃""", """而不伤身体"""]
  					# S = 0, D = 5, I = 0, N = 11, CER = 5 / 11
  					lowerCamelCase								=     cer.compute(predictions=A		,			references=A  )
  					self.assertTrue(abs(char_error_rate - 0.454545454545  ) < 1e-6  )
  
  					lowerCamelCase								=     ["""我能吞下玻璃而不伤身体"""]
  					lowerCamelCase								=     cer.compute(predictions=A		,			references=A  )
  					self.assertFalse(A		,			0.0  )
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   Optional[int]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     [""""""]
  					lowerCamelCase								=     ["""Hypothesis"""]
  					with self.assertRaises(A  ):
  								cer.compute(predictions=A		,			references=A  )
  
  
  if __name__ == "__main__":
  		unittest.main()
  
  