
'''simple docstring'''





from __future__ import annotations

import copy
import os
import tempfile
from importlib import import_module
from math import isnan

from transformers import is_tf_available
from transformers.models.auto import get_values
from transformers.testing_utils import _tf_gpu_memory_limit, require_tf, slow

from ..test_modeling_tf_common import ids_tensor


if is_tf_available():
 import numpy as np
 import tensorflow as tf

 from transformers import (
     TF_MODEL_FOR_CAUSAL_LM_MAPPING,
     TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
     TF_MODEL_FOR_MASKED_LM_MAPPING,
     TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
     TF_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
     TF_MODEL_FOR_PRETRAINING_MAPPING,
     TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
     TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
     TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
     TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
     TFSharedEmbeddings,
 )

 if _tf_gpu_memory_limit is not None:
  a__						:				List[Any]           =    tf.config.list_physical_devices("GPU")
  for gpu in gpus:
   # Restrict TensorFlow to only allocate x GB of memory on the GPUs
   try:
    tf.config.set_logical_device_configuration(
        gpu, [tf.config.LogicalDeviceConfiguration(memory_limit=_tf_gpu_memory_limit)]
    )
    a__						:				str           =    tf.config.list_logical_devices("GPU")
    print("Logical GPUs", logical_gpus)
   except RuntimeError as e:
    # Virtual devices must be set before GPUs have been initialized
    print(e)


@require_tf
class 	UpperCamelCase__					:
 UpperCAmelCase__      :      Any  			=   None
 UpperCAmelCase__      :      Dict  			=   ()
 UpperCAmelCase__      :      Dict  			=   ()
 UpperCAmelCase__      :      Tuple  			=   True
 UpperCAmelCase__      :      Any  			=   True
 UpperCAmelCase__      :      Tuple  			=   True
 UpperCAmelCase__      :      int  			=   False






 def 		lowercase_  (     self					:List[Any]		,			_A					:Optional[int]		,			_A					:Dict		,			_A					:str=False     )			->     List[Any]:







       '''simple docstring'''



       __A    		=     copy.deepcopy(_lowerCamelCase     )

       if model_class in get_values(_lowerCamelCase     ):
             __A    		=     {
                 k: tf.tile(tf.expand_dims(_lowerCamelCase		,			1     )		,			(1, self.model_tester.num_choices) + (1,) * (v.ndim - 1)     )
                 if isinstance(_lowerCamelCase		,			tf.Tensor     ) and v.ndim > 0
                 else v
                 for k, v in inputs_dict.items()
             }

       if return_labels:
             if model_class in get_values(_lowerCamelCase     ):
                   __A    		=     tf.ones(self.model_tester.batch_size		,			dtype=tf.intaa     )
             elif model_class in get_values(_lowerCamelCase     ):
                   __A    		=     tf.zeros(self.model_tester.batch_size		,			dtype=tf.intaa     )
                   __A    		=     tf.zeros(self.model_tester.batch_size		,			dtype=tf.intaa     )
             elif model_class in [
                 *get_values(_lowerCamelCase     ),
                 *get_values(_lowerCamelCase     ),
             ]:
                   __A    		=     tf.zeros(self.model_tester.batch_size		,			dtype=tf.intaa     )
             elif model_class in get_values(_lowerCamelCase     ):
                   __A    		=     tf.zeros(self.model_tester.batch_size		,			dtype=tf.intaa     )
             elif model_class in [
                 *get_values(_lowerCamelCase     ),
                 *get_values(_lowerCamelCase     ),
                 *get_values(_lowerCamelCase     ),
                 *get_values(_lowerCamelCase     ),
                 *get_values(_lowerCamelCase     ),
             ]:
                   __A    		=     tf.zeros(
                       (self.model_tester.batch_size, self.model_tester.seq_length)		,			dtype=tf.intaa     )
       return inputs_dict






 @slow
 def 		lowercase_  (     self					:Optional[Any]     )			->     Dict:







       '''simple docstring'''



       __A		, __A    		=     self.model_tester.prepare_config_and_inputs_for_common()
       for model_class in self.all_model_classes[:2]:
             __A    		=     self._prepare_for_class(_lowerCamelCase		,			_lowerCamelCase     )
             __A    		=     model_class(_lowerCamelCase     )

             @tf.function
             def run_in_graph_mode():
                   return model(_lowerCamelCase     )

             __A    		=     run_in_graph_mode()
             self.assertIsNotNone(_lowerCamelCase     )






 @slow
 def 		lowercase_  (     self					:Union[str, Any]     )			->     List[Any]:







       '''simple docstring'''



       __A		, __A    		=     self.model_tester.prepare_config_and_inputs_for_common()
       for model_class in self.all_model_classes[:2]:
             __A    		=     self._prepare_for_class(_lowerCamelCase		,			_lowerCamelCase     )
             __A    		=     model_class(_lowerCamelCase     )

             @tf.function(experimental_compile=_lowerCamelCase     )
             def run_in_graph_mode():
                   return model(_lowerCamelCase     )

             __A    		=     run_in_graph_mode()
             self.assertIsNotNone(_lowerCamelCase     )






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







       '''simple docstring'''



       __A		, __A    		=     self.model_tester.prepare_config_and_inputs_for_common()
       for model_class in self.all_model_classes[:2]:
             __A    		=     model_class(_lowerCamelCase     )
             if getattr(_lowerCamelCase		,			'hf_compute_loss'		,			_lowerCamelCase     ):
                   # Test that model correctly compute the loss with kwargs
                   __A    		=     self._prepare_for_class(inputs_dict.copy()		,			_lowerCamelCase		,			return_labels=_lowerCamelCase     )
                   # Is there a better way to remove these decoder inputs?
                   __A    		=     {
                       key: val
                       for key, val in prepared_for_class.items()
                       if key not in ('head_mask', 'decoder_head_mask', 'cross_attn_head_mask', 'decoder_input_ids')
                   }

                   __A    		=     {
                       'labels',
                       'label',
                       'label_ids',
                       'start_positions',
                       'start_position',
                       'end_positions',
                       'end_position',
                       'next_sentence_label',
                   }
                   __A    		=     possible_label_cols.intersection(set(_lowerCamelCase     )     )
                   self.assertGreater(len(_lowerCamelCase     )		,			0		,			msg='No matching label names found!'     )
                   __A    		=     {key: val for key, val in prepared_for_class.items() if key in label_names}
                   __A    		=     {key: val for key, val in prepared_for_class.items() if key not in label_names}
                   self.assertGreater(len(_lowerCamelCase     )		,			0     )

                   # Make sure it works with XLA!
                   model.compile(optimizer=tf.keras.optimizers.SGD(0.0     )		,			jit_compile=_lowerCamelCase     )
                   # Make sure the model fits without crashing regardless of where we pass the labels
                   __A    		=     model.fit(
                       _lowerCamelCase		,			validation_data=_lowerCamelCase		,			steps_per_epoch=1		,			validation_steps=1		,			shuffle=_lowerCamelCase		,			verbose=0		,			)
                   __A    		=     history.history['loss'][0]
                   self.assertTrue(not isnan(_lowerCamelCase     )     )
                   __A    		=     history.history['val_loss'][0]
                   self.assertTrue(not isnan(_lowerCamelCase     )     )

                   # Now test it with separate labels, to make sure that path works in XLA too.
                   __A    		=     model_class(_lowerCamelCase     )
                   model.compile(optimizer=tf.keras.optimizers.SGD(0.0     )		,			jit_compile=_lowerCamelCase     )
                   __A    		=     model.fit(
                       _lowerCamelCase		,			_lowerCamelCase		,			validation_data=(inputs_minus_labels, labels)		,			steps_per_epoch=1		,			validation_steps=1		,			shuffle=_lowerCamelCase		,			verbose=0		,			)

                   __A    		=     history.history['loss'][0]
                   self.assertTrue(not isnan(_lowerCamelCase     )     )
                   __A    		=     history.history['val_loss'][0]
                   self.assertTrue(not isnan(_lowerCamelCase     )     )






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







       '''simple docstring'''



       __A		, __A    		=     self.model_tester.prepare_config_and_inputs_for_common()
       __A    		=     True
       __A    		=     True

       if hasattr(_lowerCamelCase		,			'use_cache'     ):
             __A    		=     True

       __A    		=     getattr(self.model_tester		,			'encoder_seq_length'		,			self.model_tester.seq_length     )
       __A    		=     getattr(self.model_tester		,			'key_length'		,			_lowerCamelCase     )

       for model_class in self.all_model_classes[:2]:
             __A    		=     self._prepare_for_class(_lowerCamelCase		,			_lowerCamelCase     )
             __A    		=     model_class(_lowerCamelCase     )
             model.build()
             __A    		=     len(model(_lowerCamelCase     )     )

             for key in list(class_inputs_dict.keys()     ):
                   # Remove keys not in the serving signature, as the SavedModel will not be compiled to deal with them
                   if key not in model.input_signature:
                         del class_inputs_dict[key]
                   # Check it's a tensor, in case the inputs dict has some bools in it too
                   elif isinstance(class_inputs_dict[key]		,			tf.Tensor     ) and class_inputs_dict[key].dtype.is_integer:
                         __A    		=     tf.cast(class_inputs_dict[key]		,			tf.intaa     )

             if set(class_inputs_dict.keys()     ) != set(model.input_signature.keys()     ):
                   continue  # Some models have inputs that the preparation functions don't create, we skip those

             with tempfile.TemporaryDirectory() as tmpdirname:
                   model.save_pretrained(_lowerCamelCase		,			saved_model=_lowerCamelCase     )
                   __A    		=     os.path.join(_lowerCamelCase		,			'saved_model'		,			'1'     )
                   __A    		=     tf.keras.models.load_model(_lowerCamelCase     )
                   __A    		=     model(_lowerCamelCase     )

                   if self.is_encoder_decoder:
                         __A    		=     outputs['encoder_hidden_states']
                         __A    		=     outputs['encoder_attentions']
                   else:
                         __A    		=     outputs['hidden_states']
                         __A    		=     outputs['attentions']

                   self.assertEqual(len(_lowerCamelCase     )		,			_lowerCamelCase     )

                   __A    		=     getattr(
                       self.model_tester		,			'expected_num_hidden_layers'		,			self.model_tester.num_hidden_layers + 1     )

                   self.assertEqual(len(_lowerCamelCase     )		,			_lowerCamelCase     )
                   self.assertListEqual(
                       list(output_hidden_states[0].shape[-2:]     )		,			[self.model_tester.seq_length, self.model_tester.hidden_size]		,			)

                   self.assertEqual(len(_lowerCamelCase     )		,			self.model_tester.num_hidden_layers     )
                   self.assertListEqual(
                       list(output_attentions[0].shape[-3:]     )		,			[self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length]		,			)






 @slow
 def 		lowercase_  (     self					:str     )			->     Union[str, Any]:







       '''simple docstring'''



       tf.keras.mixed_precision.set_global_policy('mixed_float16'     )

       # try/finally block to ensure subsequent tests run in float32
       try:
             __A		, __A    		=     self.model_tester.prepare_config_and_inputs_for_common()
             for model_class in self.all_model_classes[:2]:
                   __A    		=     self._prepare_for_class(_lowerCamelCase		,			_lowerCamelCase     )
                   __A    		=     model_class(_lowerCamelCase     )
                   __A    		=     model(_lowerCamelCase     )

                   self.assertIsNotNone(_lowerCamelCase     )
       finally:
             tf.keras.mixed_precision.set_global_policy('float32'     )






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







       '''simple docstring'''



       __A		, __A    		=     self.model_tester.prepare_config_and_inputs_for_common()
       # head_mask and decoder_head_mask has different shapes than other input args
       if "head_mask" in inputs_dict:
             del inputs_dict["head_mask"]
       if "decoder_head_mask" in inputs_dict:
             del inputs_dict["decoder_head_mask"]
       if "cross_attn_head_mask" in inputs_dict:
             del inputs_dict["cross_attn_head_mask"]
       __A    		=     {
           module_member
           for model_class in self.all_model_classes
           for module in (import_module(model_class.__module__     ),)
           for module_member_name in dir(_lowerCamelCase     )
           if module_member_name.endswith('MainLayer'     )
           for module_member in (getattr(_lowerCamelCase		,			_lowerCamelCase     ),)
           if isinstance(_lowerCamelCase		,			_lowerCamelCase     )
           and tf.keras.layers.Layer in module_member.__bases__
           and getattr(_lowerCamelCase		,			'_keras_serializable'		,			_lowerCamelCase     )
       }

       for main_layer_class in tf_main_layer_classes:
             # T5MainLayer needs an embed_tokens parameter when called without the inputs_embeds parameter
             if "T5" in main_layer_class.__name__:
                   # Take the same values than in TFT5ModelTester for this shared layer
                   __A    		=     TFSharedEmbeddings(self.model_tester.vocab_size		,			self.model_tester.hidden_size		,			name='shared'     )
                   __A    		=     False
                   __A    		=     main_layer_class(_lowerCamelCase		,			embed_tokens=_lowerCamelCase     )
             else:
                   __A    		=     main_layer_class(_lowerCamelCase     )

             __A    		=     {
                 name: tf.keras.Input(tensor.shape[1:]		,			dtype=tensor.dtype     ) for name, tensor in inputs_dict.items()
             }

             if hasattr(self.model_tester		,			'num_labels'     ):
                   __A    		=     self.model_tester.num_labels
             else:
                   __A    		=     2

             __A    		=     tf.data.Dataset.from_tensor_slices(
                 (inputs_dict, np.ones((self.model_tester.batch_size, self.model_tester.seq_length, num_labels, 1)     ))     ).batch(1     )

             __A    		=     main_layer(_lowerCamelCase     )[0]
             __A    		=     tf.keras.layers.Dense(_lowerCamelCase		,			activation='softmax'		,			name='outputs'     )(_lowerCamelCase     )
             __A    		=     tf.keras.models.Model(inputs=_lowerCamelCase		,			outputs=[outputs]     )

             model.compile(loss='binary_crossentropy'		,			optimizer='adam'		,			metrics=['binary_accuracy']     )
             model.fit(_lowerCamelCase		,			epochs=1     )

             with tempfile.TemporaryDirectory() as tmpdirname:
                   __A    		=     os.path.join(_lowerCamelCase		,			'keras_model.h5'     )
                   model.save(_lowerCamelCase     )
                   if "T5" in main_layer_class.__name__:
                         __A    		=     tf.keras.models.load_model(
                             _lowerCamelCase		,			custom_objects={
                                 main_layer_class.__name__: main_layer_class,
                                 'TFSharedEmbeddings': TFSharedEmbeddings,
                             }		,			)
                   else:
                         __A    		=     tf.keras.models.load_model(
                             _lowerCamelCase		,			custom_objects={main_layer_class.__name__: main_layer_class}     )
                   assert isinstance(_lowerCamelCase		,			tf.keras.Model     )
                   model(_lowerCamelCase     )






 @slow
 def 		lowercase_  (     self					:Optional[int]     )			->     Dict:







       '''simple docstring'''



       __A		, __A    		=     self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes[:2]:
             __A    		=     model_class(_lowerCamelCase     )

             __A    		=     copy.deepcopy(_lowerCamelCase     )

             if not self.is_encoder_decoder:
                   __A    		=     inputs['input_ids']
                   del inputs["input_ids"]
             else:
                   __A    		=     inputs['input_ids']
                   __A    		=     inputs.get('decoder_input_ids'		,			_lowerCamelCase     )
                   del inputs["input_ids"]
                   inputs.pop('decoder_input_ids'		,			_lowerCamelCase     )

             if not self.is_encoder_decoder:
                   __A    		=     model.get_input_embeddings()(_lowerCamelCase     )
             else:
                   __A    		=     model.get_input_embeddings()(_lowerCamelCase     )
                   __A    		=     model.get_input_embeddings()(_lowerCamelCase     )

             __A    		=     self._prepare_for_class(_lowerCamelCase		,			_lowerCamelCase     )

             @tf.function
             def run_in_graph_mode():
                   return model(_lowerCamelCase     )

             __A    		=     run_in_graph_mode()
             self.assertIsNotNone(_lowerCamelCase     )






 def 		lowercase_  (     self					:int		,			_A					:Any		,			_A					:Union[str, Any]     )			->     Any:







       '''simple docstring'''



       __A    		=     []
       if model.config.bos_token_id is not None:
             special_tokens.append(model.config.bos_token_id     )
       if model.config.pad_token_id is not None:
             special_tokens.append(model.config.pad_token_id     )
       if model.config.eos_token_id is not None:
             special_tokens.append(model.config.eos_token_id     )

       # create random bad tokens that are not special tokens
       __A    		=     []
       while len(_lowerCamelCase     ) < num_bad_tokens:
             __A    		=     tf.squeeze(ids_tensor((1, 1)		,			self.model_tester.vocab_size     )		,			0     ).numpy()[0]
             if token not in special_tokens:
                   bad_tokens.append(_lowerCamelCase     )
       return bad_tokens






 def 		lowercase_  (     self					:Any		,			_A					:Optional[int]     )			->     List[str]:







       '''simple docstring'''



       for token_id in output_ids[0].numpy().tolist():
             self.assertGreaterEqual(_lowerCamelCase		,			0     )
             self.assertLess(_lowerCamelCase		,			self.model_tester.vocab_size     )






 def 		lowercase_  (     self					:List[str]		,			_A					:Optional[int]		,			_A					:List[str]     )			->     Tuple:







       '''simple docstring'''



       for bad_word_ids in bad_words_ids:
             # for all slices in batch
             for generated_ids_slice in generated_ids:
                   # for all word idx
                   for i in range(len(_lowerCamelCase     )		,			len(_lowerCamelCase     )     ):
                         # if tokens match
                         if generated_ids_slice[i - len(_lowerCamelCase     ) : i] == bad_word_ids:
                               return True
       return False






'''simple docstring'''





import collections
import inspect
import unittest

from transformers import DonutSwinConfig
from transformers.testing_utils import require_torch, slow, torch_device
from transformers.utils import is_torch_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
 import torch
 from torch import nn

 from transformers import DonutSwinModel
 from transformers.models.donut.modeling_donut_swin import DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST


class 	UpperCamelCase__					:






 def __init__(     self					:int		,			_A					:int		,			_A					:List[Any]=13		,			_A					:Any=32		,			_A					:List[str]=2		,			_A					:str=3		,			_A					:Optional[Any]=16		,			_A					:List[Any]=[1, 2, 1]		,			_A					:int=[2, 2, 4]		,			_A					:Optional[Any]=2		,			_A					:Optional[Any]=2.0		,			_A					:int=True		,			_A					:Any=0.0		,			_A					:Tuple=0.0		,			_A					:Union[str, Any]=0.1		,			_A					:str="gelu"		,			_A					:Tuple=False		,			_A					:List[str]=True		,			_A					:Union[str, Any]=0.02		,			_A					:List[str]=1E-5		,			_A					:List[Any]=True		,			_A					:int=None		,			_A					:Union[str, Any]=True		,			_A					:int=10		,			_A					:Optional[int]=8		,			)			->     Optional[int]:







       '''simple docstring'''



       __A    		=     parent
       __A    		=     batch_size
       __A    		=     image_size
       __A    		=     patch_size
       __A    		=     num_channels
       __A    		=     embed_dim
       __A    		=     depths
       __A    		=     num_heads
       __A    		=     window_size
       __A    		=     mlp_ratio
       __A    		=     qkv_bias
       __A    		=     hidden_dropout_prob
       __A    		=     attention_probs_dropout_prob
       __A    		=     drop_path_rate
       __A    		=     hidden_act
       __A    		=     use_absolute_embeddings
       __A    		=     patch_norm
       __A    		=     layer_norm_eps
       __A    		=     initializer_range
       __A    		=     is_training
       __A    		=     scope
       __A    		=     use_labels
       __A    		=     type_sequence_label_size
       __A    		=     encoder_stride






 def 		lowercase_  (     self					:Any     )			->     Optional[Any]:







       '''simple docstring'''



       __A    		=     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )

       __A    		=     None
       if self.use_labels:
             __A    		=     ids_tensor([self.batch_size]		,			self.type_sequence_label_size     )

       __A    		=     self.get_config()

       return config, pixel_values, labels






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







       '''simple docstring'''



       return DonutSwinConfig(
           image_size=self.image_size		,			patch_size=self.patch_size		,			num_channels=self.num_channels		,			embed_dim=self.embed_dim		,			depths=self.depths		,			num_heads=self.num_heads		,			window_size=self.window_size		,			mlp_ratio=self.mlp_ratio		,			qkv_bias=self.qkv_bias		,			hidden_dropout_prob=self.hidden_dropout_prob		,			attention_probs_dropout_prob=self.attention_probs_dropout_prob		,			drop_path_rate=self.drop_path_rate		,			hidden_act=self.hidden_act		,			use_absolute_embeddings=self.use_absolute_embeddings		,			path_norm=self.patch_norm		,			layer_norm_eps=self.layer_norm_eps		,			initializer_range=self.initializer_range		,			encoder_stride=self.encoder_stride		,			)






 def 		lowercase_  (     self					:List[str]		,			_A					:Any		,			_A					:List[str]		,			_A					:List[str]     )			->     int:







       '''simple docstring'''



       __A    		=     DonutSwinModel(config=_A     )
       model.to(_A     )
       model.eval()
       __A    		=     model(_A     )

       __A    		=     ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths     ) - 1))
       __A    		=     int(config.embed_dim * 2 ** (len(config.depths     ) - 1)     )

       self.parent.assertEqual(result.last_hidden_state.shape		,			(self.batch_size, expected_seq_len, expected_dim)     )






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







       '''simple docstring'''



       __A    		=     self.prepare_config_and_inputs()
       (
           (
           __A
       )		, (
           __A
       )		, (
           __A
       )		, 
       )    		=     config_and_inputs
       __A    		=     {'pixel_values': pixel_values}
       return config, inputs_dict


@require_torch
class 	UpperCamelCase__					(      SCREAMING_SNAKE_CASE ,       SCREAMING_SNAKE_CASE ,       unittest.TestCase):
 UpperCAmelCase__      :      List[str]  			=   (DonutSwinModel,) if is_torch_available() else ()
 UpperCAmelCase__      :      Optional[Any]  			=   {'feature-extraction': DonutSwinModel} if is_torch_available() else {}
 UpperCAmelCase__      :      Dict  			=   True

 UpperCAmelCase__      :      int  			=   False
 UpperCAmelCase__      :      List[Any]  			=   False
 UpperCAmelCase__      :      Tuple  			=   False






 def 		lowercase_  (     self					:Union[str, Any]     )			->     int:







       '''simple docstring'''



       __A    		=     DonutSwinModelTester(self     )
       __A    		=     ConfigTester(self		,			config_class=_A		,			embed_dim=37     )






 def 		lowercase_  (     self					:Dict     )			->     Union[str, Any]:







       '''simple docstring'''



       self.create_and_test_config_common_properties()
       self.config_tester.create_and_test_config_to_json_string()
       self.config_tester.create_and_test_config_to_json_file()
       self.config_tester.create_and_test_config_from_and_save_pretrained()
       self.config_tester.create_and_test_config_with_num_labels()
       self.config_tester.check_config_can_be_init_without_params()
       self.config_tester.check_config_arguments_init()






 def 		lowercase_  (     self					:Tuple     )			->     str:







       '''simple docstring'''



       return






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







       '''simple docstring'''



       __A    		=     self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*_A     )






 def 		lowercase_  (     self					:int     )			->     int:







       '''simple docstring'''



       pass






 def 		lowercase_  (     self					:Any     )			->     Tuple:







       '''simple docstring'''



       __A		, __A    		=     self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
             __A    		=     model_class(_A     )
             self.assertIsInstance(model.get_input_embeddings()		,			(nn.Module)     )
             __A    		=     model.get_output_embeddings()
             self.assertTrue(x is None or isinstance(_A		,			nn.Linear     )     )






 def 		lowercase_  (     self					:Any     )			->     Dict:







       '''simple docstring'''



       __A		, __A    		=     self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
             __A    		=     model_class(_A     )
             __A    		=     inspect.signature(model.forward     )
             # signature.parameters is an OrderedDict => so arg_names order is deterministic
             __A    		=     [*signature.parameters.keys()]

             __A    		=     ['pixel_values']
             self.assertListEqual(arg_names[:1]		,			_A     )






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







       '''simple docstring'''



       __A		, __A    		=     self.model_tester.prepare_config_and_inputs_for_common()
       __A    		=     True

       for model_class in self.all_model_classes:
             __A    		=     True
             __A    		=     False
             __A    		=     True
             __A    		=     model_class(_A     )
             model.to(_A     )
             model.eval()
             with torch.no_grad():
                   __A    		=     model(**self._prepare_for_class(_A		,			_A     )     )
             __A    		=     outputs.attentions
             __A    		=     len(self.model_tester.depths     )
             self.assertEqual(len(_A     )		,			_A     )

             # check that output_attentions also work using config
             del inputs_dict["output_attentions"]
             __A    		=     True
             __A    		=     config.window_size**2
             __A    		=     model_class(_A     )
             model.to(_A     )
             model.eval()
             with torch.no_grad():
                   __A    		=     model(**self._prepare_for_class(_A		,			_A     )     )
             __A    		=     outputs.attentions
             self.assertEqual(len(_A     )		,			_A     )

             self.assertListEqual(
                 list(attentions[0].shape[-3:]     )		,			[self.model_tester.num_heads[0], window_size_squared, window_size_squared]		,			)
             __A    		=     len(_A     )

             # Check attention is always last and order is fine
             __A    		=     True
             __A    		=     True
             __A    		=     model_class(_A     )
             model.to(_A     )
             model.eval()
             with torch.no_grad():
                   __A    		=     model(**self._prepare_for_class(_A		,			_A     )     )

             if hasattr(self.model_tester		,			'num_hidden_states_types'     ):
                   __A    		=     self.model_tester.num_hidden_states_types
             else:
                   # also another +1 for reshaped_hidden_states
                   __A    		=     2
             self.assertEqual(out_len + added_hidden_states		,			len(_A     )     )

             __A    		=     outputs.attentions

             self.assertEqual(len(_A     )		,			_A     )

             self.assertListEqual(
                 list(self_attentions[0].shape[-3:]     )		,			[self.model_tester.num_heads[0], window_size_squared, window_size_squared]		,			)






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







       '''simple docstring'''



       __A    		=     model_class(_A     )
       model.to(_A     )
       model.eval()

       with torch.no_grad():
             __A    		=     model(**self._prepare_for_class(_A		,			_A     )     )

       __A    		=     outputs.hidden_states

       __A    		=     getattr(
           self.model_tester		,			'expected_num_hidden_layers'		,			len(self.model_tester.depths     ) + 1     )
       self.assertEqual(len(_A     )		,			_A     )

       # DonutSwin has a different seq_length
       __A    		=     (
           config.patch_size
           if isinstance(config.patch_size		,			collections.abc.Iterable     )
           else (config.patch_size, config.patch_size)
       )

       __A    		=     (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

       self.assertListEqual(
           list(hidden_states[0].shape[-2:]     )		,			[num_patches, self.model_tester.embed_dim]		,			)

       __A    		=     outputs.reshaped_hidden_states
       self.assertEqual(len(_A     )		,			_A     )

       __A		, __A		, __A		, __A    		=     reshaped_hidden_states[0].shape
       __A    		=     (
           reshaped_hidden_states[0].view(_A		,			_A		,			height * width     ).permute(0		,			2		,			1     )
       )
       self.assertListEqual(
           list(reshaped_hidden_states.shape[-2:]     )		,			[num_patches, self.model_tester.embed_dim]		,			)






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







       '''simple docstring'''



       __A		, __A    		=     self.model_tester.prepare_config_and_inputs_for_common()

       __A    		=     (
           self.model_tester.image_size
           if isinstance(self.model_tester.image_size		,			collections.abc.Iterable     )
           else (self.model_tester.image_size, self.model_tester.image_size)
       )

       for model_class in self.all_model_classes:
             __A    		=     True
             self.check_hidden_states_output(_A		,			_A		,			_A		,			_A     )

             # check that output_hidden_states also work using config
             del inputs_dict["output_hidden_states"]
             __A    		=     True

             self.check_hidden_states_output(_A		,			_A		,			_A		,			_A     )






 def 		lowercase_  (     self					:Dict     )			->     Optional[int]:







       '''simple docstring'''



       __A		, __A    		=     self.model_tester.prepare_config_and_inputs_for_common()
       __A    		=     3

       __A    		=     (
           self.model_tester.image_size
           if isinstance(self.model_tester.image_size		,			collections.abc.Iterable     )
           else (self.model_tester.image_size, self.model_tester.image_size)
       )
       __A    		=     (
           config.patch_size
           if isinstance(config.patch_size		,			collections.abc.Iterable     )
           else (config.patch_size, config.patch_size)
       )

       __A    		=     image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
       __A    		=     image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

       for model_class in self.all_model_classes:
             __A    		=     True
             self.check_hidden_states_output(_A		,			_A		,			_A		,			(padded_height, padded_width)     )

             # check that output_hidden_states also work using config
             del inputs_dict["output_hidden_states"]
             __A    		=     True
             self.check_hidden_states_output(_A		,			_A		,			_A		,			(padded_height, padded_width)     )






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







       '''simple docstring'''



       for model_name in DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             __A    		=     DonutSwinModel.from_pretrained(_A     )
             self.assertIsNotNone(_A     )






 def 		lowercase_  (     self					:Tuple     )			->     Union[str, Any]:







       '''simple docstring'''



       __A		, __A    		=     self.model_tester.prepare_config_and_inputs_for_common()

       __A    		=     _config_zero_init(_A     )
       for model_class in self.all_model_classes:
             __A    		=     model_class(config=_A     )
             for name, param in model.named_parameters():
                   if "embeddings" not in name and param.requires_grad:
                         self.assertIn(
                             ((param.data.mean() * 1E9).round() / 1E9).item()		,			[0.0, 1.0]		,			msg=F'Parameter {name} of model {model_class} seems not properly initialized'		,			)






