code: 
  
  
  from __future__ import annotations
  
  import unittest
  import warnings
  
  from transformers import AutoTokenizer, MarianConfig, MarianTokenizer, TranslationPipeline, is_tf_available
  from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow
  from transformers.utils import cached_property
  
  from ...test_configuration_common import ConfigTester
  from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor
  from ...test_pipeline_mixin import PipelineTesterMixin
  
  
  if is_tf_available():
  		import tensorflow as tf
  
  		from transformers import TFAutoModelForSeqaSeqLM, TFMarianModel, TFMarianMTModel
  
  
  
  
  
  
  
  @require_tf
  class 					__lowercase					:
  
  
  
  		"""simple docstring"""
  
  		UpperCamelCase    :				Optional[Any] 					=		MarianConfig
  		UpperCamelCase    :				Dict 					=		{}
  		UpperCamelCase    :				Union[str, Any] 					=		"gelu"
  
  
  
  
  
  
  
  		def __init__(   self		,			A		,			A=13		,			A=7		,			A=True		,			A=False		,			A=99		,			A=32		,			A=2		,			A=4		,			A=37		,			A=0.1		,			A=0.1		,			A=20		,			A=2		,			A=1		,			A=0		,			)     ->   Any:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     parent
  					lowerCamelCase								=     batch_size
  					lowerCamelCase								=     seq_length
  					lowerCamelCase								=     is_training
  					lowerCamelCase								=     use_labels
  					lowerCamelCase								=     vocab_size
  					lowerCamelCase								=     hidden_size
  					lowerCamelCase								=     num_hidden_layers
  					lowerCamelCase								=     num_attention_heads
  					lowerCamelCase								=     intermediate_size
  
  					lowerCamelCase								=     hidden_dropout_prob
  					lowerCamelCase								=     attention_probs_dropout_prob
  					lowerCamelCase								=     max_position_embeddings
  					lowerCamelCase								=     eos_token_id
  					lowerCamelCase								=     pad_token_id
  					lowerCamelCase								=     bos_token_id
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   Union[str, Any]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     ids_tensor([self.batch_size, self.seq_length - 1]		,			self.vocab_size  )
  					lowerCamelCase								=     tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size  )		,			1  )
  					lowerCamelCase								=     tf.concat([input_ids, eos_tensor]		,			axis=1  )
  
  					lowerCamelCase								=     ids_tensor([self.batch_size, self.seq_length]		,			self.vocab_size  )
  
  					lowerCamelCase								=     self.config_cls(
  					    vocab_size=self.vocab_size		,			d_model=self.hidden_size		,			encoder_layers=self.num_hidden_layers		,			decoder_layers=self.num_hidden_layers		,			encoder_attention_heads=self.num_attention_heads		,			decoder_attention_heads=self.num_attention_heads		,			encoder_ffn_dim=self.intermediate_size		,			decoder_ffn_dim=self.intermediate_size		,			dropout=self.hidden_dropout_prob		,			attention_dropout=self.attention_probs_dropout_prob		,			max_position_embeddings=self.max_position_embeddings		,			eos_token_ids=[2]		,			bos_token_id=self.bos_token_id		,			pad_token_id=self.pad_token_id		,			decoder_start_token_id=self.pad_token_id		,			**self.config_updates		,			)
  					lowerCamelCase								=     prepare_marian_inputs_dict(A		,			A		,			A  )
  					return config, inputs_dict
  
  
  
  
  
  
  
  		def 				__A      (   self		,			A		,			A  )     ->   Optional[Any]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     TFMarianModel(config=A  ).get_decoder()
  					lowerCamelCase								=     inputs_dict["""input_ids"""]
  
  					lowerCamelCase								=     input_ids[:1, :]
  					lowerCamelCase								=     inputs_dict["""attention_mask"""][:1, :]
  					lowerCamelCase								=     inputs_dict["""head_mask"""]
  					lowerCamelCase								=     1
  
  					# first forward pass
  					lowerCamelCase								=     model(A		,			attention_mask=A		,			head_mask=A		,			use_cache=A  )
  
  					lowerCamelCase		,		lowerCamelCase								=     outputs.to_tuple()
  
  					# create hypothetical next token and extent to next_input_ids
  					lowerCamelCase								=     ids_tensor((self.batch_size, 3)		,			config.vocab_size  )
  					lowerCamelCase								=     tf.cast(ids_tensor((self.batch_size, 3)		,			2  )		,			tf.inta  )
  
  					# append to next input_ids and
  					lowerCamelCase								=     tf.concat([input_ids, next_tokens]		,			axis=-1  )
  					lowerCamelCase								=     tf.concat([attention_mask, next_attn_mask]		,			axis=-1  )
  
  					lowerCamelCase								=     model(A		,			attention_mask=A  )[0]
  					lowerCamelCase								=     model(A		,			attention_mask=A		,			past_key_values=A  )[0]
  
  					self.parent.assertEqual(next_tokens.shape[1]		,			output_from_past.shape[1]  )
  
  					# select random slice
  					lowerCamelCase								=     int(ids_tensor((1,)		,			output_from_past.shape[-1]  )  )
  					lowerCamelCase								=     output_from_no_past[:, -3:, random_slice_idx]
  					lowerCamelCase								=     output_from_past[:, :, random_slice_idx]
  
  					# test that outputs are equal for slice
  					tf.debugging.assert_near(A		,			A		,			rtol=1e-3  )
  
  
  
  
  
  
  def   __lowerCamelCase	(       lowerCamelCase__		:	List[str]     ,       lowerCamelCase__		:	Optional[Any]     ,       lowerCamelCase__		:	Tuple     ,       lowerCamelCase__		:	Optional[Any]=None     ,       lowerCamelCase__		:	Dict=None     ,       lowerCamelCase__		:	List[Any]=None     ,       lowerCamelCase__		:	int=None     ,       lowerCamelCase__		:	Dict=None     ,       ):
  
  
  
  
  
  			'''simple docstring'''
  
  
  
  
  			if attention_mask is None:
  						lowerCamelCase								=     tf.cast(tf.math.not_equal(lowerCamelCase__     ,       config.pad_token_id			)     ,       tf.inta			)
  			if decoder_attention_mask is None:
  						lowerCamelCase								=     tf.concat(
  						    [
  						        tf.ones(decoder_input_ids[:, :1].shape     ,       dtype=tf.inta			),
  						        tf.cast(tf.math.not_equal(decoder_input_ids[:, 1:]     ,       config.pad_token_id			)     ,       tf.inta			),
  						    ]     ,       axis=-1     ,       )
  			if head_mask is None:
  						lowerCamelCase								=     tf.ones((config.encoder_layers, config.encoder_attention_heads)			)
  			if decoder_head_mask is None:
  						lowerCamelCase								=     tf.ones((config.decoder_layers, config.decoder_attention_heads)			)
  			if cross_attn_head_mask is None:
  						lowerCamelCase								=     tf.ones((config.decoder_layers, config.decoder_attention_heads)			)
  			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,
  			}
  
  
  
  
  
  
  
  @require_tf
  class 					__lowercase					(       a_ ,       a_ ,       unittest.TestCase     ):
  
  
  
  		"""simple docstring"""
  
  		UpperCamelCase    :				Optional[int] 					=		(TFMarianMTModel, TFMarianModel) if is_tf_available() else ()
  		UpperCamelCase    :				List[str] 					=		(TFMarianMTModel,) if is_tf_available() else ()
  		UpperCamelCase    :				Any 					=		(
  		    {
  		        "conversational": TFMarianMTModel,
  		        "feature-extraction": TFMarianModel,
  		        "summarization": TFMarianMTModel,
  		        "text2text-generation": TFMarianMTModel,
  		        "translation": TFMarianMTModel,
  		    }
  		    if is_tf_available()
  		    else {}
  		)
  		UpperCamelCase    :				Any 					=		True
  		UpperCamelCase    :				str 					=		False
  		UpperCamelCase    :				str 					=		False
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   Optional[int]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     TFMarianModelTester(self  )
  					lowerCamelCase								=     ConfigTester(self		,			config_class=A  )
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   Any:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					self.config_tester.run_common_tests()
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   Optional[int]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     self.model_tester.prepare_config_and_inputs_for_common()
  					self.model_tester.check_decoder_model_past_large_inputs(*A  )
  
  
  
  
  
  
  
  @require_tf
  class 					__lowercase					(       unittest.TestCase     ):
  
  
  
  		"""simple docstring"""
  
  		UpperCamelCase    :				List[str] 					=		1_0_0_0  # show more chars for failing integration tests
  
  
  
  
  
  
  
  		@classmethod
  		def 				__A      (   cls  )     ->   None:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     F'Helsinki-NLP/opus-mt-{cls.src}-{cls.tgt}'
  					return cls
  
  
  
  
  
  
  
  		@cached_property
  		def 				__A      (   self  )     ->   MarianTokenizer:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					return AutoTokenizer.from_pretrained(self.model_name  )
  
  
  
  
  
  
  
  		@property
  		def 				__A      (   self  )     ->   int:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					return self.tokenizer.eos_token_id
  
  
  
  
  
  
  
  		@cached_property
  		def 				__A      (   self  )     ->   Optional[Any]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					warnings.simplefilter("""error"""  )
  					lowerCamelCase								=     TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name  )
  					assert isinstance(A		,			A  )
  					lowerCamelCase								=     model.config
  					self.assertListEqual(c.bad_words_ids		,			[[c.pad_token_id]]  )
  					self.assertEqual(c.max_length		,			5_12  )
  					self.assertEqual(c.decoder_start_token_id		,			c.pad_token_id  )
  					return model
  
  
  
  
  
  
  
  		def 				__A      (   self		,			**A  )     ->   Dict:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     self.translate_src_text(**A  )
  					self.assertListEqual(self.expected_text		,			A  )
  
  
  
  
  
  
  
  		def 				__A      (   self		,			**A  )     ->   Optional[Any]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     self.tokenizer(self.src_text		,			**A		,			padding=A		,			return_tensors="""tf"""  )
  					lowerCamelCase								=     self.model.generate(
  					    model_inputs.input_ids		,			attention_mask=model_inputs.attention_mask		,			num_beams=2		,			max_length=1_28  )
  					lowerCamelCase								=     self.tokenizer.batch_decode(generated_ids.numpy()		,			skip_special_tokens=A  )
  					return generated_words
  
  
  
  
  
  
  
  @require_sentencepiece
  @require_tokenizers
  @require_tf
  class 					__lowercase					(       a_     ):
  
  
  
  		"""simple docstring"""
  
  		UpperCamelCase    :				Dict 					=		"mt"
  		UpperCamelCase    :				List[Any] 					=		"en"
  		UpperCamelCase    :				Optional[Any] 					=		["Billi messu b'mod ġentili, Ġesù fejjaq raġel li kien milqut bil - marda kerha tal - ġdiem."]
  		UpperCamelCase    :				Any 					=		["Touching gently, Jesus healed a man who was affected by the sad disease of leprosy."]
  
  
  
  
  
  
  
  		@unittest.skip("""Skipping until #12647 is resolved."""  )
  		@slow
  		def 				__A      (   self  )     ->   List[str]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					self._assert_generated_batch_equal_expected()
  
  
  
  
  
  
  
  @require_sentencepiece
  @require_tokenizers
  @require_tf
  class 					__lowercase					(       a_     ):
  
  
  
  		"""simple docstring"""
  
  		UpperCamelCase    :				Union[str, Any] 					=		"en"
  		UpperCamelCase    :				Tuple 					=		"zh"
  		UpperCamelCase    :				Optional[Any] 					=		["My name is Wolfgang and I live in Berlin"]
  		UpperCamelCase    :				int 					=		["我叫沃尔夫冈 我住在柏林"]
  
  
  
  
  
  
  
  		@unittest.skip("""Skipping until #12647 is resolved."""  )
  		@slow
  		def 				__A      (   self  )     ->   Dict:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					self._assert_generated_batch_equal_expected()
  
  
  
  
  
  
  
  @require_sentencepiece
  @require_tokenizers
  @require_tf
  class 					__lowercase					(       a_     ):
  
  
  
  		"""simple docstring"""
  
  		UpperCamelCase    :				Optional[int] 					=		"en"
  		UpperCamelCase    :				List[str] 					=		"ROMANCE"
  		UpperCamelCase    :				Optional[int] 					=		[
  		    ">>fr<< Don't spend so much time watching TV.",
  		    ">>pt<< Your message has been sent.",
  		    ">>es<< He's two years older than me.",
  		]
  		UpperCamelCase    :				Union[str, Any] 					=		[
  		    "Ne passez pas autant de temps à regarder la télé.",
  		    "A sua mensagem foi enviada.",
  		    "Es dos años más viejo que yo.",
  		]
  
  
  
  
  
  
  
  		@unittest.skip("""Skipping until #12647 is resolved."""  )
  		@slow
  		def 				__A      (   self  )     ->   Tuple:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					self._assert_generated_batch_equal_expected()
  
  
  
  
  
  
  
  		@unittest.skip("""Skipping until #12647 is resolved."""  )
  		@slow
  		def 				__A      (   self  )     ->   int:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     TranslationPipeline(self.model		,			self.tokenizer		,			framework="""tf"""  )
  					lowerCamelCase								=     pipeline(self.src_text  )
  					self.assertEqual(self.expected_text		,			[x["""translation_text"""] for x in output]  )
  
  
style_context: 
  
  
  from typing import TYPE_CHECKING
  
  from ...utils import (
      OptionalDependencyNotAvailable,
      _LazyModule,
      is_flax_available,
      is_sentencepiece_available,
      is_tf_available,
      is_tokenizers_available,
      is_torch_available,
  )
  
  
  UpperCAmelCase      :						List[str]    =		{
      "configuration_big_bird": ["BIG_BIRD_PRETRAINED_CONFIG_ARCHIVE_MAP", "BigBirdConfig", "BigBirdOnnxConfig"],
  }
  
  try:
  		if not is_sentencepiece_available():
  				raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
  		pass
  else:
  		UpperCAmelCase      :						str    =		["BigBirdTokenizer"]
  
  try:
  		if not is_tokenizers_available():
  				raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
  		pass
  else:
  		UpperCAmelCase      :						str    =		["BigBirdTokenizerFast"]
  
  try:
  		if not is_torch_available():
  				raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
  		pass
  else:
  		UpperCAmelCase      :						Dict    =		[
  		    "BIG_BIRD_PRETRAINED_MODEL_ARCHIVE_LIST",
  		    "BigBirdForCausalLM",
  		    "BigBirdForMaskedLM",
  		    "BigBirdForMultipleChoice",
  		    "BigBirdForPreTraining",
  		    "BigBirdForQuestionAnswering",
  		    "BigBirdForSequenceClassification",
  		    "BigBirdForTokenClassification",
  		    "BigBirdLayer",
  		    "BigBirdModel",
  		    "BigBirdPreTrainedModel",
  		    "load_tf_weights_in_big_bird",
  		]
  
  try:
  		if not is_flax_available():
  				raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
  		pass
  else:
  		UpperCAmelCase      :						Dict    =		[
  		    "FlaxBigBirdForCausalLM",
  		    "FlaxBigBirdForMaskedLM",
  		    "FlaxBigBirdForMultipleChoice",
  		    "FlaxBigBirdForPreTraining",
  		    "FlaxBigBirdForQuestionAnswering",
  		    "FlaxBigBirdForSequenceClassification",
  		    "FlaxBigBirdForTokenClassification",
  		    "FlaxBigBirdModel",
  		    "FlaxBigBirdPreTrainedModel",
  		]
  
  if TYPE_CHECKING:
  		from .configuration_big_bird import BIG_BIRD_PRETRAINED_CONFIG_ARCHIVE_MAP, BigBirdConfig, BigBirdOnnxConfig
  
  		try:
  				if not is_sentencepiece_available():
  						raise OptionalDependencyNotAvailable()
  		except OptionalDependencyNotAvailable:
  				pass
  		else:
  				from .tokenization_big_bird import BigBirdTokenizer
  
  		try:
  				if not is_tokenizers_available():
  						raise OptionalDependencyNotAvailable()
  		except OptionalDependencyNotAvailable:
  				pass
  		else:
  				from .tokenization_big_bird_fast import BigBirdTokenizerFast
  
  		try:
  				if not is_torch_available():
  						raise OptionalDependencyNotAvailable()
  		except OptionalDependencyNotAvailable:
  				pass
  		else:
  				from .modeling_big_bird import (
  				    BIG_BIRD_PRETRAINED_MODEL_ARCHIVE_LIST,
  				    BigBirdForCausalLM,
  				    BigBirdForMaskedLM,
  				    BigBirdForMultipleChoice,
  				    BigBirdForPreTraining,
  				    BigBirdForQuestionAnswering,
  				    BigBirdForSequenceClassification,
  				    BigBirdForTokenClassification,
  				    BigBirdLayer,
  				    BigBirdModel,
  				    BigBirdPreTrainedModel,
  				    load_tf_weights_in_big_bird,
  				)
  
  		try:
  				if not is_flax_available():
  						raise OptionalDependencyNotAvailable()
  		except OptionalDependencyNotAvailable:
  				pass
  		else:
  				from .modeling_flax_big_bird import (
  				    FlaxBigBirdForCausalLM,
  				    FlaxBigBirdForMaskedLM,
  				    FlaxBigBirdForMultipleChoice,
  				    FlaxBigBirdForPreTraining,
  				    FlaxBigBirdForQuestionAnswering,
  				    FlaxBigBirdForSequenceClassification,
  				    FlaxBigBirdForTokenClassification,
  				    FlaxBigBirdModel,
  				    FlaxBigBirdPreTrainedModel,
  				)
  
  else:
  		import sys
  
  		UpperCAmelCase      :						Dict    =		_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
  
  