





'''simple docstring'''

from __future__ import annotations

import unittest

import numpy as np

from transformers import LayoutLMConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
   import tensorflow as tf

   from transformers.models.layoutlm.modeling_tf_layoutlm import (
       TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST,
       TFLayoutLMForMaskedLM,
       TFLayoutLMForQuestionAnswering,
       TFLayoutLMForSequenceClassification,
       TFLayoutLMForTokenClassification,
       TFLayoutLMModel,
   )
class     __lowerCAmelCase					:






       """simple docstring"""





       def __init__(							self       :		Optional[int]	,			lowerCAmelCase__       :		Dict	,			lowerCAmelCase__       :		Any=13	,			lowerCAmelCase__       :		Optional[Any]=7	,			lowerCAmelCase__       :		Optional[int]=True	,			lowerCAmelCase__       :		Union[str, Any]=True	,			lowerCAmelCase__       :		int=True	,			lowerCAmelCase__       :		Tuple=True	,			lowerCAmelCase__       :		Tuple=99	,			lowerCAmelCase__       :		Tuple=32	,			lowerCAmelCase__       :		Union[str, Any]=2	,			lowerCAmelCase__       :		Union[str, Any]=4	,			lowerCAmelCase__       :		Any=37	,			lowerCAmelCase__       :		Union[str, Any]="gelu"	,			lowerCAmelCase__       :		str=0.1	,			lowerCAmelCase__       :		int=0.1	,			lowerCAmelCase__       :		Tuple=512	,			lowerCAmelCase__       :		Optional[Any]=16	,			lowerCAmelCase__       :		int=2	,			lowerCAmelCase__       :		List[Any]=0.02	,			lowerCAmelCase__       :		Optional[int]=3	,			lowerCAmelCase__       :		Dict=4	,			lowerCAmelCase__       :		Dict=None	,			lowerCAmelCase__       :		Optional[int]=1000	,			)   ->					str:

            '''simple docstring'''




            _UpperCamelCase       =	parent
            _UpperCamelCase       =	batch_size
            _UpperCamelCase       =	seq_length
            _UpperCamelCase       =	is_training
            _UpperCamelCase       =	use_input_mask
            _UpperCamelCase       =	use_token_type_ids
            _UpperCamelCase       =	use_labels
            _UpperCamelCase       =	vocab_size
            _UpperCamelCase       =	hidden_size
            _UpperCamelCase       =	num_hidden_layers
            _UpperCamelCase       =	num_attention_heads
            _UpperCamelCase       =	intermediate_size
            _UpperCamelCase       =	hidden_act
            _UpperCamelCase       =	hidden_dropout_prob
            _UpperCamelCase       =	attention_probs_dropout_prob
            _UpperCamelCase       =	max_position_embeddings
            _UpperCamelCase       =	type_vocab_size
            _UpperCamelCase       =	type_sequence_label_size
            _UpperCamelCase       =	initializer_range
            _UpperCamelCase       =	num_labels
            _UpperCamelCase       =	num_choices
            _UpperCamelCase       =	scope
            _UpperCamelCase       =	range_bbox





       def snake_case__						(							self       :		List[Any]					)   ->					List[str]:

            '''simple docstring'''




            _UpperCamelCase       =	ids_tensor([self.batch_size, self.seq_length]	,			self.vocab_size					)

            # convert bbox to numpy since TF does not support item assignment
            _UpperCamelCase       =	ids_tensor([self.batch_size, self.seq_length, 4]	,			self.range_bbox					).numpy()
            # Ensure that bbox is legal
            for i in range(bbox.shape[0]					):
                 for j in range(bbox.shape[1]					):
                      if bbox[i, j, 3] < bbox[i, j, 1]:
                           _UpperCamelCase       =	bbox[i, j, 3]
                           _UpperCamelCase       =	bbox[i, j, 1]
                           _UpperCamelCase       =	t
                      if bbox[i, j, 2] < bbox[i, j, 0]:
                           _UpperCamelCase       =	bbox[i, j, 2]
                           _UpperCamelCase       =	bbox[i, j, 0]
                           _UpperCamelCase       =	t
            _UpperCamelCase       =	tf.convert_to_tensor(lowerCAmelCase__					)

            _UpperCamelCase       =	None
            if self.use_input_mask:
                 _UpperCamelCase       =	random_attention_mask([self.batch_size, self.seq_length]					)

            _UpperCamelCase       =	None
            if self.use_token_type_ids:
                 _UpperCamelCase       =	ids_tensor([self.batch_size, self.seq_length]	,			self.type_vocab_size					)

            _UpperCamelCase       =	None
            _UpperCamelCase       =	None
            _UpperCamelCase       =	None
            if self.use_labels:
                 _UpperCamelCase       =	ids_tensor([self.batch_size]	,			self.type_sequence_label_size					)
                 _UpperCamelCase       =	ids_tensor([self.batch_size, self.seq_length]	,			self.num_labels					)
                 _UpperCamelCase       =	ids_tensor([self.batch_size]	,			self.num_choices					)

            _UpperCamelCase       =	LayoutLMConfig(
                vocab_size=self.vocab_size	,			hidden_size=self.hidden_size	,			num_hidden_layers=self.num_hidden_layers	,			num_attention_heads=self.num_attention_heads	,			intermediate_size=self.intermediate_size	,			hidden_act=self.hidden_act	,			hidden_dropout_prob=self.hidden_dropout_prob	,			attention_probs_dropout_prob=self.attention_probs_dropout_prob	,			max_position_embeddings=self.max_position_embeddings	,			type_vocab_size=self.type_vocab_size	,			initializer_range=self.initializer_range	,			)

            return config, input_ids, bbox, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels





       def snake_case__						(							self       :		int	,			lowerCAmelCase__       :		List[str]	,			lowerCAmelCase__       :		List[Any]	,			lowerCAmelCase__       :		Tuple	,			lowerCAmelCase__       :		Dict	,			lowerCAmelCase__       :		Optional[int]	,			lowerCAmelCase__       :		Optional[Any]	,			lowerCAmelCase__       :		int	,			lowerCAmelCase__       :		List[Any]					)   ->					Optional[Any]:

            '''simple docstring'''




            _UpperCamelCase       =	TFLayoutLMModel(config=lowerCAmelCase__					)

            _UpperCamelCase       =	model(lowerCAmelCase__	,			lowerCAmelCase__	,			attention_mask=lowerCAmelCase__	,			token_type_ids=lowerCAmelCase__					)
            _UpperCamelCase       =	model(lowerCAmelCase__	,			lowerCAmelCase__	,			token_type_ids=lowerCAmelCase__					)
            _UpperCamelCase       =	model(lowerCAmelCase__	,			lowerCAmelCase__					)
            self.parent.assertEqual(result.last_hidden_state.shape	,			(self.batch_size, self.seq_length, self.hidden_size)					)
            self.parent.assertEqual(result.pooler_output.shape	,			(self.batch_size, self.hidden_size)					)





       def snake_case__						(							self       :		Any	,			lowerCAmelCase__       :		List[str]	,			lowerCAmelCase__       :		int	,			lowerCAmelCase__       :		Optional[Any]	,			lowerCAmelCase__       :		List[Any]	,			lowerCAmelCase__       :		List[Any]	,			lowerCAmelCase__       :		List[str]	,			lowerCAmelCase__       :		Union[str, Any]	,			lowerCAmelCase__       :		Union[str, Any]					)   ->					Any:

            '''simple docstring'''




            _UpperCamelCase       =	TFLayoutLMForMaskedLM(config=lowerCAmelCase__					)

            _UpperCamelCase       =	model(lowerCAmelCase__	,			lowerCAmelCase__	,			attention_mask=lowerCAmelCase__	,			token_type_ids=lowerCAmelCase__	,			labels=lowerCAmelCase__					)
            self.parent.assertEqual(result.logits.shape	,			(self.batch_size, self.seq_length, self.vocab_size)					)





       def snake_case__						(							self       :		Union[str, Any]	,			lowerCAmelCase__       :		List[str]	,			lowerCAmelCase__       :		Union[str, Any]	,			lowerCAmelCase__       :		int	,			lowerCAmelCase__       :		Tuple	,			lowerCAmelCase__       :		Optional[Any]	,			lowerCAmelCase__       :		str	,			lowerCAmelCase__       :		Dict	,			lowerCAmelCase__       :		int					)   ->					Optional[Any]:

            '''simple docstring'''




            _UpperCamelCase       =	self.num_labels
            _UpperCamelCase       =	TFLayoutLMForSequenceClassification(config=lowerCAmelCase__					)

            _UpperCamelCase       =	model(lowerCAmelCase__	,			lowerCAmelCase__	,			attention_mask=lowerCAmelCase__	,			token_type_ids=lowerCAmelCase__					)
            self.parent.assertEqual(result.logits.shape	,			(self.batch_size, self.num_labels)					)





       def snake_case__						(							self       :		Optional[int]	,			lowerCAmelCase__       :		List[Any]	,			lowerCAmelCase__       :		List[Any]	,			lowerCAmelCase__       :		Tuple	,			lowerCAmelCase__       :		List[Any]	,			lowerCAmelCase__       :		str	,			lowerCAmelCase__       :		int	,			lowerCAmelCase__       :		Optional[int]	,			lowerCAmelCase__       :		Optional[int]					)   ->					List[Any]:

            '''simple docstring'''




            _UpperCamelCase       =	self.num_labels
            _UpperCamelCase       =	TFLayoutLMForTokenClassification(config=lowerCAmelCase__					)

            _UpperCamelCase       =	model(lowerCAmelCase__	,			lowerCAmelCase__	,			attention_mask=lowerCAmelCase__	,			token_type_ids=lowerCAmelCase__	,			labels=lowerCAmelCase__					)
            self.parent.assertEqual(result.logits.shape	,			(self.batch_size, self.seq_length, self.num_labels)					)





       def snake_case__						(							self       :		int	,			lowerCAmelCase__       :		Optional[int]	,			lowerCAmelCase__       :		Tuple	,			lowerCAmelCase__       :		Optional[Any]	,			lowerCAmelCase__       :		Any	,			lowerCAmelCase__       :		Optional[Any]	,			lowerCAmelCase__       :		Dict	,			lowerCAmelCase__       :		Dict	,			lowerCAmelCase__       :		Optional[int]					)   ->					List[Any]:

            '''simple docstring'''




            _UpperCamelCase       =	TFLayoutLMForQuestionAnswering(config=lowerCAmelCase__					)

            _UpperCamelCase       =	model(lowerCAmelCase__	,			lowerCAmelCase__	,			attention_mask=lowerCAmelCase__	,			token_type_ids=lowerCAmelCase__					)
            self.parent.assertEqual(result.start_logits.shape	,			(self.batch_size, self.seq_length)					)
            self.parent.assertEqual(result.end_logits.shape	,			(self.batch_size, self.seq_length)					)







       def snake_case__						(							self       :		List[Any]					)   ->					List[Any]:

            '''simple docstring'''




            _UpperCamelCase       =	self.prepare_config_and_inputs()
            (
                (
                _UpperCamelCase
            )   ,    (
                _UpperCamelCase
            )   ,    (
                _UpperCamelCase
            )   ,    (
                _UpperCamelCase
            )   ,    (
                _UpperCamelCase
            )   ,    (
                _UpperCamelCase
            )   ,    (
                _UpperCamelCase
            )   ,    (
                _UpperCamelCase
            )   ,    
            )       =	config_and_inputs
            _UpperCamelCase       =	{
                '''input_ids''': input_ids,
                '''bbox''': bbox,
                '''token_type_ids''': token_type_ids,
                '''attention_mask''': input_mask,
            }
            return config, inputs_dict

@require_tf
class     __lowerCAmelCase					(   __magic_name__						,						__magic_name__						,						unittest.TestCase			):






       """simple docstring"""
       _snake_case     :					int						    =   (
           (
               TFLayoutLMModel,
               TFLayoutLMForMaskedLM,
               TFLayoutLMForTokenClassification,
               TFLayoutLMForSequenceClassification,
               TFLayoutLMForQuestionAnswering,
           )
           if is_tf_available()
           else ()
       )
       _snake_case     :					Tuple						    =   (
           {
               'feature-extraction': TFLayoutLMModel,
               'fill-mask': TFLayoutLMForMaskedLM,
               'text-classification': TFLayoutLMForSequenceClassification,
               'token-classification': TFLayoutLMForTokenClassification,
               'zero-shot': TFLayoutLMForSequenceClassification,
           }
           if is_tf_available()
           else {}
       )
       _snake_case     :					Optional[int]						    =   False
       _snake_case     :					List[str]						    =   True
       _snake_case     :					Any						    =   1_0





       def snake_case__						(							self       :		List[str]					)   ->					Dict:

            '''simple docstring'''




            _UpperCamelCase       =	TFLayoutLMModelTester(self					)
            _UpperCamelCase       =	ConfigTester(self	,			config_class=lowerCAmelCase__	,			hidden_size=37					)





       def snake_case__						(							self       :		List[str]					)   ->					str:

            '''simple docstring'''




            self.config_tester.run_common_tests()





       def snake_case__						(							self       :		Optional[int]					)   ->					List[str]:

            '''simple docstring'''




            _UpperCamelCase       =	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*lowerCAmelCase__					)





       def snake_case__						(							self       :		Tuple					)   ->					List[str]:

            '''simple docstring'''




            _UpperCamelCase       =	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_masked_lm(*lowerCAmelCase__					)





       def snake_case__						(							self       :		Tuple					)   ->					Optional[Any]:

            '''simple docstring'''




            _UpperCamelCase       =	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_sequence_classification(*lowerCAmelCase__					)





       def snake_case__						(							self       :		Dict					)   ->					int:

            '''simple docstring'''




            _UpperCamelCase       =	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_token_classification(*lowerCAmelCase__					)





       def snake_case__						(							self       :		List[Any]					)   ->					Optional[Any]:

            '''simple docstring'''




            _UpperCamelCase       =	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_question_answering(*lowerCAmelCase__					)





       @slow
       def snake_case__						(							self       :		List[str]					)   ->					List[Any]:

            '''simple docstring'''




            for model_name in TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 _UpperCamelCase       =	TFLayoutLMModel.from_pretrained(lowerCAmelCase__					)
                 self.assertIsNotNone(lowerCAmelCase__					)







       @unittest.skip('''Onnx compliancy broke with TF 2.10'''					)
       def snake_case__						(							self       :		Optional[int]					)   ->					int:

            '''simple docstring'''




            pass







def  a__    (    )		->		str:





     """simple docstring"""

     _UpperCamelCase       =	tf.convert_to_tensor([[101,1019,1014,1016,1037,12849,4747,1004,14246,2278,5439,4524,5002,2930,2193,2930,4341,3208,1005,1055,2171,2848,11300,3531,102],[101,4070,4034,7020,1024,3058,1015,1013,2861,1013,6070,19274,2772,6205,27814,16147,16147,4343,2047,10283,10969,14389,1012,2338,102]]				)  # noqa: E231
     _UpperCamelCase       =	tf.convert_to_tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],]				)  # noqa: E231
     _UpperCamelCase       =	tf.convert_to_tensor([[[0,0,0,0],[423,237,440,251],[427,272,441,287],[419,115,437,129],[961,885,992,912],[256,38,330,58],[256,38,330,58],[336,42,353,57],[360,39,401,56],[360,39,401,56],[411,39,471,59],[479,41,528,59],[533,39,630,60],[67,113,134,131],[141,115,209,132],[68,149,133,166],[141,149,187,164],[195,148,287,165],[195,148,287,165],[195,148,287,165],[295,148,349,165],[441,149,492,166],[497,149,546,164],[64,201,125,218],[1000,1000,1000,1000]],[[0,0,0,0],[662,150,754,166],[665,199,742,211],[519,213,554,228],[519,213,554,228],[134,433,187,454],[130,467,204,480],[130,467,204,480],[130,467,204,480],[130,467,204,480],[130,467,204,480],[314,469,376,482],[504,684,582,706],[941,825,973,900],[941,825,973,900],[941,825,973,900],[941,825,973,900],[610,749,652,765],[130,659,168,672],[176,657,237,672],[238,657,312,672],[443,653,628,672],[443,653,628,672],[716,301,825,317],[1000,1000,1000,1000]]]				)  # noqa: E231
     _UpperCamelCase       =	tf.convert_to_tensor([[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]				)  # noqa: E231
     # these are sequence labels (i.e. at the token level)
     _UpperCamelCase       =	tf.convert_to_tensor([[-100,10,10,10,9,1,-100,7,7,-100,7,7,4,2,5,2,8,8,-100,-100,5,0,3,2,-100],[-100,12,12,12,-100,12,10,-100,-100,-100,-100,10,12,9,-100,-100,-100,10,10,10,9,12,-100,10,-100]]				)  # noqa: E231
     # fmt: on

     return input_ids, attention_mask, bbox, token_type_ids, labels




@require_tf
class     __lowerCAmelCase					(   unittest.TestCase			):






       """simple docstring"""





       @slow
       def snake_case__						(							self       :		Optional[Any]					)   ->					int:

            '''simple docstring'''




            _UpperCamelCase       =	TFLayoutLMModel.from_pretrained('''microsoft/layoutlm-base-uncased'''					)

            _UpperCamelCase   ,    _UpperCamelCase   ,    _UpperCamelCase   ,    _UpperCamelCase   ,    _UpperCamelCase       =	prepare_layoutlm_batch_inputs()

            # forward pass
            _UpperCamelCase       =	model(input_ids=lowerCAmelCase__	,			bbox=lowerCAmelCase__	,			attention_mask=lowerCAmelCase__	,			token_type_ids=lowerCAmelCase__					)

            # test the sequence output on [0, :3, :3]
            _UpperCamelCase       =	tf.convert_to_tensor(
                [[0.1785, -0.1947, -0.0425], [-0.3254, -0.2807, 0.2553], [-0.5391, -0.3322, 0.3364]]	,			)

            self.assertTrue(np.allclose(outputs.last_hidden_state[0, :3, :3]	,			lowerCAmelCase__	,			atol=1e-3					)					)

            # test the pooled output on [1, :3]
            _UpperCamelCase       =	tf.convert_to_tensor([-0.6580, -0.0214, 0.8552]					)

            self.assertTrue(np.allclose(outputs.pooler_output[1, :3]	,			lowerCAmelCase__	,			atol=1e-3					)					)





       @slow
       def snake_case__						(							self       :		List[Any]					)   ->					Any:

            '''simple docstring'''




            _UpperCamelCase       =	TFLayoutLMForSequenceClassification.from_pretrained('''microsoft/layoutlm-base-uncased'''	,			num_labels=2					)

            _UpperCamelCase   ,    _UpperCamelCase   ,    _UpperCamelCase   ,    _UpperCamelCase   ,    _UpperCamelCase       =	prepare_layoutlm_batch_inputs()

            # forward pass
            _UpperCamelCase       =	model(
                input_ids=lowerCAmelCase__	,			bbox=lowerCAmelCase__	,			attention_mask=lowerCAmelCase__	,			token_type_ids=lowerCAmelCase__	,			labels=tf.convert_to_tensor([1, 1]					)	,			)

            # test whether we get a loss as a scalar
            _UpperCamelCase       =	outputs.loss
            _UpperCamelCase       =	(2,)
            self.assertEqual(loss.shape	,			lowerCAmelCase__					)

            # test the shape of the logits
            _UpperCamelCase       =	outputs.logits
            _UpperCamelCase       =	(2, 2)
            self.assertEqual(logits.shape	,			lowerCAmelCase__					)





       @slow
       def snake_case__						(							self       :		Tuple					)   ->					List[Any]:

            '''simple docstring'''




            _UpperCamelCase       =	TFLayoutLMForTokenClassification.from_pretrained('''microsoft/layoutlm-base-uncased'''	,			num_labels=13					)

            _UpperCamelCase   ,    _UpperCamelCase   ,    _UpperCamelCase   ,    _UpperCamelCase   ,    _UpperCamelCase       =	prepare_layoutlm_batch_inputs()

            # forward pass
            _UpperCamelCase       =	model(
                input_ids=lowerCAmelCase__	,			bbox=lowerCAmelCase__	,			attention_mask=lowerCAmelCase__	,			token_type_ids=lowerCAmelCase__	,			labels=lowerCAmelCase__					)

            # test the shape of the logits
            _UpperCamelCase       =	outputs.logits
            _UpperCamelCase       =	tf.convert_to_tensor((2, 25, 13)					)
            self.assertEqual(logits.shape	,			lowerCAmelCase__					)







       @slow
       def snake_case__						(							self       :		Any					)   ->					Any:

            '''simple docstring'''




            _UpperCamelCase       =	TFLayoutLMForQuestionAnswering.from_pretrained('''microsoft/layoutlm-base-uncased'''					)

            _UpperCamelCase   ,    _UpperCamelCase   ,    _UpperCamelCase   ,    _UpperCamelCase   ,    _UpperCamelCase       =	prepare_layoutlm_batch_inputs()

            # forward pass
            _UpperCamelCase       =	model(input_ids=lowerCAmelCase__	,			bbox=lowerCAmelCase__	,			attention_mask=lowerCAmelCase__	,			token_type_ids=lowerCAmelCase__					)

            # test the shape of the logits
            _UpperCamelCase       =	tf.convert_to_tensor((2, 25)					)
            self.assertEqual(outputs.start_logits.shape	,			lowerCAmelCase__					)
            self.assertEqual(outputs.end_logits.shape	,			lowerCAmelCase__					)










'''simple docstring'''

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


lowercase__						:      List[Any]	=    logging.get_logger(__name__)

lowercase__						:      Tuple	=    {
    'microsoft/trocr-base-handwritten': (
        'https://huggingface.co/microsoft/trocr-base-handwritten/resolve/main/config.json'
    ),
    # See all TrOCR models at https://huggingface.co/models?filter=trocr
}
class     __lowerCAmelCase					(   __magic_name__			):






       """simple docstring"""
       _snake_case     :					int						    =   'trocr'
       _snake_case     :					List[str]						    =   ['past_key_values']
       _snake_case     :					Tuple						    =   {
           'num_attention_heads': 'decoder_attention_heads',
           'hidden_size': 'd_model',
           'num_hidden_layers': 'decoder_layers',
       }





       def __init__(							self       :		Tuple	,			lowerCAmelCase__       :		Union[str, Any]=50265	,			lowerCAmelCase__       :		List[Any]=1024	,			lowerCAmelCase__       :		List[str]=12	,			lowerCAmelCase__       :		int=16	,			lowerCAmelCase__       :		List[Any]=4096	,			lowerCAmelCase__       :		Optional[int]="gelu"	,			lowerCAmelCase__       :		int=512	,			lowerCAmelCase__       :		Optional[Any]=0.1	,			lowerCAmelCase__       :		Optional[int]=0.0	,			lowerCAmelCase__       :		Dict=0.0	,			lowerCAmelCase__       :		Tuple=2	,			lowerCAmelCase__       :		Dict=0.02	,			lowerCAmelCase__       :		Tuple=0.0	,			lowerCAmelCase__       :		int=True	,			lowerCAmelCase__       :		Optional[Any]=False	,			lowerCAmelCase__       :		Any=True	,			lowerCAmelCase__       :		Dict=True	,			lowerCAmelCase__       :		Optional[int]=1	,			lowerCAmelCase__       :		List[Any]=0	,			lowerCAmelCase__       :		Any=2	,			**lowerCAmelCase__       :		Optional[int]	,			)   ->					Any:

            '''simple docstring'''




            _UpperCamelCase       =	vocab_size
            _UpperCamelCase       =	d_model
            _UpperCamelCase       =	decoder_layers
            _UpperCamelCase       =	decoder_attention_heads
            _UpperCamelCase       =	decoder_ffn_dim
            _UpperCamelCase       =	activation_function
            _UpperCamelCase       =	max_position_embeddings
            _UpperCamelCase       =	dropout
            _UpperCamelCase       =	attention_dropout
            _UpperCamelCase       =	activation_dropout
            _UpperCamelCase       =	init_std
            _UpperCamelCase       =	decoder_layerdrop
            _UpperCamelCase       =	use_cache
            _UpperCamelCase       =	scale_embedding
            _UpperCamelCase       =	use_learned_position_embeddings
            _UpperCamelCase       =	layernorm_embedding

            super().__init__(
                pad_token_id=lowerCAmelCase__	,			bos_token_id=lowerCAmelCase__	,			eos_token_id=lowerCAmelCase__	,			decoder_start_token_id=lowerCAmelCase__	,			**lowerCAmelCase__	,			)



