




import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging


UpperCamelCase__						=		logging.get_logger(__name__)

UpperCamelCase__						=		{}


class 							__SCREAMING_SNAKE_CASE				(						lowerCamelCase    ):
					_lowerCamelCase						    =					"""fsmt_decoder"""

					def __init__(							self					,			__lowercase=0					,			__lowercase=0   ):







						'''simple docstring'''




						super().__init__()
						lowerCamelCase_				:						Tuple				  =				vocab_size
						lowerCamelCase_				:						Union[str, Any]				  =				bos_token_id


class 							__SCREAMING_SNAKE_CASE				(						lowerCamelCase    ):
					_lowerCamelCase						    =					"""fsmt"""
					_lowerCamelCase						    =					{"""num_attention_heads""": """encoder_attention_heads""", """hidden_size""": """d_model"""}

					def __init__(							self					,			__lowercase=["en", "de"]					,			__lowercase=42_024					,			__lowercase=42_024					,			__lowercase="relu"					,			__lowercase=1_024					,			__lowercase=200					,			__lowercase=1_024					,			__lowercase=4_096					,			__lowercase=12					,			__lowercase=16					,			__lowercase=0.0					,			__lowercase=4_096					,			__lowercase=12					,			__lowercase=16					,			__lowercase=0.0					,			__lowercase=0.0					,			__lowercase=0.1					,			__lowercase=0.0					,			__lowercase=0.02					,			__lowercase=2					,			__lowercase=True					,			__lowercase=True					,			__lowercase=False					,			__lowercase=5					,			__lowercase=1.0					,			__lowercase=False					,			__lowercase=True					,			__lowercase=1					,			__lowercase=0					,			__lowercase=2					,			__lowercase=2					,			**__lowercase					,			):







						'''simple docstring'''




						lowerCamelCase_				:						Any				  =				langs
						lowerCamelCase_				:						Union[str, Any]				  =				src_vocab_size
						lowerCamelCase_				:						Tuple				  =				tgt_vocab_size
						lowerCamelCase_				:						List[Any]				  =				d_model  # encoder_embed_dim and decoder_embed_dim

						lowerCamelCase_				:						str				  =				encoder_ffn_dim
						lowerCamelCase_				:						str				  =				encoder_layers
						lowerCamelCase_				:						Dict				  =				encoder_attention_heads
						lowerCamelCase_				:						Any				  =				encoder_layerdrop
						lowerCamelCase_				:						Union[str, Any]				  =				decoder_layerdrop
						lowerCamelCase_				:						Optional[int]				  =				decoder_ffn_dim
						lowerCamelCase_				:						List[str]				  =				decoder_layers
						lowerCamelCase_				:						int				  =				decoder_attention_heads
						lowerCamelCase_				:						List[str]				  =				max_position_embeddings
						lowerCamelCase_				:						int				  =				init_std  # Normal(0, this parameter)
						lowerCamelCase_				:						Optional[Any]				  =				activation_function

						lowerCamelCase_				:						Union[str, Any]				  =				DecoderConfig(vocab_size=__lowercase					,			bos_token_id=__lowercase   )
						if "decoder" in common_kwargs:
							del common_kwargs["decoder"]

						lowerCamelCase_				:						int				  =				scale_embedding  # scale factor will be sqrt(d_model) if True

						# 3 Types of Dropout
						lowerCamelCase_				:						Optional[int]				  =				attention_dropout
						lowerCamelCase_				:						Union[str, Any]				  =				activation_dropout
						lowerCamelCase_				:						Dict				  =				dropout

						lowerCamelCase_				:						Optional[int]				  =				use_cache
						super().__init__(
						    pad_token_id=__lowercase					,			bos_token_id=__lowercase					,			eos_token_id=__lowercase					,			decoder_start_token_id=__lowercase					,			is_encoder_decoder=__lowercase					,			tie_word_embeddings=__lowercase					,			forced_eos_token_id=__lowercase					,			max_length=__lowercase					,			num_beams=__lowercase					,			length_penalty=__lowercase					,			early_stopping=__lowercase					,			**__lowercase					,			)





					def       lowercase_				(							self   ):







						'''simple docstring'''




						lowerCamelCase_				:						List[Any]				  =				copy.deepcopy(self.__dict__   )
						lowerCamelCase_				:						Optional[int]				  =				self.decoder.to_dict()
						lowerCamelCase_				:						Dict				  =				self.__class__.model_type
						return output

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 				lowerCamelCase			:
      __lowerCamelCase							=					MarianConfig
      __lowerCamelCase							=					{}
      __lowerCamelCase							=					'gelu'






      def __init__(      self  ,		__lowerCamelCase  ,		__lowerCamelCase=13  ,		__lowerCamelCase=7  ,		__lowerCamelCase=True  ,		__lowerCamelCase=False  ,		__lowerCamelCase=99  ,		__lowerCamelCase=32  ,		__lowerCamelCase=2  ,		__lowerCamelCase=4  ,		__lowerCamelCase=37  ,		__lowerCamelCase=0.1  ,		__lowerCamelCase=0.1  ,		__lowerCamelCase=20  ,		__lowerCamelCase=2  ,		__lowerCamelCase=1  ,		__lowerCamelCase=0  ,		)     ->				Any:


          '''simple docstring'''







          snake_case:						Any         =   parent
          snake_case:						List[Any]         =   batch_size
          snake_case:						int         =   seq_length
          snake_case:						Tuple         =   is_training
          snake_case:						Union[str, Any]         =   use_labels
          snake_case:						Union[str, Any]         =   vocab_size
          snake_case:						Dict         =   hidden_size
          snake_case:						Any         =   num_hidden_layers
          snake_case:						List[Any]         =   num_attention_heads
          snake_case:						str         =   intermediate_size

          snake_case:						Union[str, Any]         =   hidden_dropout_prob
          snake_case:						List[Any]         =   attention_probs_dropout_prob
          snake_case:						Tuple         =   max_position_embeddings
          snake_case:						Optional[int]         =   eos_token_id
          snake_case:						Optional[Any]         =   pad_token_id
          snake_case:						Optional[Any]         =   bos_token_id






      def 			lowerCAmelCase_   (      self						)     ->				Optional[int]:


          '''simple docstring'''







          snake_case:						Tuple         =   ids_tensor([self.batch_size, self.seq_length - 1]  ,		self.vocab_size						)
          snake_case:						Union[str, Any]         =   tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size						)  ,		1						)
          snake_case:						int         =   tf.concat([input_ids, eos_tensor]  ,		axis=1						)

          snake_case:						Optional[int]         =   ids_tensor([self.batch_size, self.seq_length]  ,		self.vocab_size						)

          snake_case:						List[str]         =   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  ,		)
          snake_case:						Tuple         =   prepare_marian_inputs_dict(__lowerCamelCase  ,		__lowerCamelCase  ,		__lowerCamelCase						)
          return config, inputs_dict






      def 			lowerCAmelCase_   (      self  ,		__lowerCamelCase  ,		__lowerCamelCase						)     ->				List[str]:


          '''simple docstring'''







          snake_case:						Any         =   TFMarianModel(config=__lowerCamelCase						).get_decoder()
          snake_case:						str         =   inputs_dict["""input_ids"""]

          snake_case:						Union[str, Any]         =   input_ids[:1, :]
          snake_case:						Union[str, Any]         =   inputs_dict["""attention_mask"""][:1, :]
          snake_case:						str         =   inputs_dict["""head_mask"""]
          snake_case:						Optional[Any]         =   1

          # first forward pass
          snake_case:						int         =   model(__lowerCamelCase  ,		attention_mask=__lowerCamelCase  ,		head_mask=__lowerCamelCase  ,		use_cache=__lowerCamelCase						)

          snake_case    , snake_case:						List[str]         =   outputs.to_tuple()

          # create hypothetical next token and extent to next_input_ids
          snake_case:						Optional[int]         =   ids_tensor((self.batch_size, 3)  ,		config.vocab_size						)
          snake_case:						List[Any]         =   tf.cast(ids_tensor((self.batch_size, 3)  ,		2						)  ,		tf.inta						)

          # append to next input_ids and
          snake_case:						Optional[int]         =   tf.concat([input_ids, next_tokens]  ,		axis=-1						)
          snake_case:						Dict         =   tf.concat([attention_mask, next_attn_mask]  ,		axis=-1						)

          snake_case:						Optional[Any]         =   model(__lowerCamelCase  ,		attention_mask=__lowerCamelCase						)[0]
          snake_case:						Any         =   model(__lowerCamelCase  ,		attention_mask=__lowerCamelCase  ,		past_key_values=__lowerCamelCase						)[0]

          self.parent.assertEqual(next_tokens.shape[1]  ,		output_from_past.shape[1]						)

          # select random slice
          snake_case:						str         =   int(ids_tensor((1,)  ,		output_from_past.shape[-1]						)						)
          snake_case:						List[Any]         =   output_from_no_past[:, -3:, random_slice_idx]
          snake_case:						Optional[int]         =   output_from_past[:, :, random_slice_idx]

          # test that outputs are equal for slice
          tf.debugging.assert_near(__lowerCamelCase  ,		__lowerCamelCase  ,		rtol=1e-3						)





def   a_					(_lowerCAmelCase  :   Union[str, Any]			,	_lowerCAmelCase  :   Tuple			,	_lowerCAmelCase  :   int			,	_lowerCAmelCase  :   Tuple=None			,	_lowerCAmelCase  :   Optional[int]=None			,	_lowerCAmelCase  :   Optional[int]=None			,	_lowerCAmelCase  :   Optional[Any]=None			,	_lowerCAmelCase  :   List[str]=None			,	)->				Any:
    if attention_mask is None:
        snake_case:						str         =   tf.cast(tf.math.not_equal(_lowerCAmelCase			,	config.pad_token_id       )			,	tf.inta       )
    if decoder_attention_mask is None:
        snake_case:						Dict         =   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:
        snake_case:						Union[str, Any]         =   tf.ones((config.encoder_layers, config.encoder_attention_heads)       )
    if decoder_head_mask is None:
        snake_case:						Optional[Any]         =   tf.ones((config.decoder_layers, config.decoder_attention_heads)       )
    if cross_attn_head_mask is None:
        snake_case:						Optional[int]         =   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 				lowerCamelCase			(							__snake_case				,     __snake_case				,     unittest.TestCase					):
      __lowerCamelCase							=					(TFMarianMTModel, TFMarianModel) if is_tf_available() else ()
      __lowerCamelCase							=					(TFMarianMTModel,) if is_tf_available() else ()
      __lowerCamelCase							=					(
          {
              'conversational': TFMarianMTModel,
              'feature-extraction': TFMarianModel,
              'summarization': TFMarianMTModel,
              'text2text-generation': TFMarianMTModel,
              'translation': TFMarianMTModel,
          }
          if is_tf_available()
          else {}
      )
      __lowerCamelCase							=					True
      __lowerCamelCase							=					False
      __lowerCamelCase							=					False






      def 			lowerCAmelCase_   (      self						)     ->				Dict:


          '''simple docstring'''







          snake_case:						int         =   TFMarianModelTester(self						)
          snake_case:						Tuple         =   ConfigTester(self  ,		config_class=__lowerCamelCase						)






      def 			lowerCAmelCase_   (      self						)     ->				int:


          '''simple docstring'''







          self.config_tester.run_common_tests()






      def 			lowerCAmelCase_   (      self						)     ->				Any:


          '''simple docstring'''







          snake_case:						int         =   self.model_tester.prepare_config_and_inputs_for_common()
          self.model_tester.check_decoder_model_past_large_inputs(*__lowerCamelCase						)





@require_tf
class 				lowerCamelCase			(							unittest.TestCase					):
      __lowerCamelCase							=					1_000  # show more chars for failing integration tests






      @classmethod
      def 			lowerCAmelCase_   (      cls						)     ->				None:


          '''simple docstring'''







          snake_case:						Any         =   F"Helsinki-NLP/opus-mt-{cls.src}-{cls.tgt}"
          return cls






      @cached_property
      def 			lowerCAmelCase_   (      self						)     ->				MarianTokenizer:


          '''simple docstring'''







          return AutoTokenizer.from_pretrained(self.model_name						)






      @property
      def 			lowerCAmelCase_   (      self						)     ->				int:


          '''simple docstring'''







          return self.tokenizer.eos_token_id






      @cached_property
      def 			lowerCAmelCase_   (      self						)     ->				Tuple:


          '''simple docstring'''







          warnings.simplefilter("""error"""						)
          snake_case:						TFMarianMTModel         =   TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name						)
          assert isinstance(__lowerCamelCase  ,		__lowerCamelCase						)
          snake_case:						Optional[Any]         =   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 			lowerCAmelCase_   (      self  ,		**__lowerCamelCase						)     ->				Optional[int]:


          '''simple docstring'''







          snake_case:						Union[str, Any]         =   self.translate_src_text(**__lowerCamelCase						)
          self.assertListEqual(self.expected_text  ,		__lowerCamelCase						)






      def 			lowerCAmelCase_   (      self  ,		**__lowerCamelCase						)     ->				Dict:


          '''simple docstring'''







          snake_case:						Any         =   self.tokenizer(self.src_text  ,		**__lowerCamelCase  ,		padding=__lowerCamelCase  ,		return_tensors="""tf"""						)
          snake_case:						int         =   self.model.generate(
              model_inputs.input_ids  ,		attention_mask=model_inputs.attention_mask  ,		num_beams=2  ,		max_length=1_28						)
          snake_case:						Any         =   self.tokenizer.batch_decode(generated_ids.numpy()  ,		skip_special_tokens=__lowerCamelCase						)
          return generated_words





@require_sentencepiece
@require_tokenizers
@require_tf
class 				lowerCamelCase			(							__snake_case					):
      __lowerCamelCase							=					'mt'
      __lowerCamelCase							=					'en'
      __lowerCamelCase							=					['Billi messu b\'mod ġentili, Ġesù fejjaq raġel li kien milqut bil - marda kerha tal - ġdiem.']
      __lowerCamelCase							=					['Touching gently, Jesus healed a man who was affected by the sad disease of leprosy.']






      @unittest.skip("""Skipping until #12647 is resolved."""						)
      @slow
      def 			lowerCAmelCase_   (      self						)     ->				Optional[int]:


          '''simple docstring'''







          self._assert_generated_batch_equal_expected()





@require_sentencepiece
@require_tokenizers
@require_tf
class 				lowerCamelCase			(							__snake_case					):
      __lowerCamelCase							=					'en'
      __lowerCamelCase							=					'zh'
      __lowerCamelCase							=					['My name is Wolfgang and I live in Berlin']
      __lowerCamelCase							=					['我叫沃尔夫冈 我住在柏林']






      @unittest.skip("""Skipping until #12647 is resolved."""						)
      @slow
      def 			lowerCAmelCase_   (      self						)     ->				str:


          '''simple docstring'''







          self._assert_generated_batch_equal_expected()





@require_sentencepiece
@require_tokenizers
@require_tf
class 				lowerCamelCase			(							__snake_case					):
      __lowerCamelCase							=					'en'
      __lowerCamelCase							=					'ROMANCE'
      __lowerCamelCase							=					[
          '>>fr<< Don\'t spend so much time watching TV.',
          '>>pt<< Your message has been sent.',
          '>>es<< He\'s two years older than me.',
      ]
      __lowerCamelCase							=					[
          '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 			lowerCAmelCase_   (      self						)     ->				Dict:


          '''simple docstring'''







          self._assert_generated_batch_equal_expected()






      @unittest.skip("""Skipping until #12647 is resolved."""						)
      @slow
      def 			lowerCAmelCase_   (      self						)     ->				int:


          '''simple docstring'''







          snake_case:						List[str]         =   TranslationPipeline(self.model  ,		self.tokenizer  ,		framework="""tf"""						)
          snake_case:						List[Any]         =   pipeline(self.src_text						)
          self.assertEqual(self.expected_text  ,		[x["""translation_text"""] for x in output]						)


