

'''simple docstring'''
from __future__ import annotations

import unittest

from transformers import AlbertConfig, is_tf_available
from transformers.models.auto import get_values
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 import TF_MODEL_FOR_PRETRAINING_MAPPING
					from transformers.models.albert.modeling_tf_albert import (
					    TF_ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
					    TFAlbertForMaskedLM,
					    TFAlbertForMultipleChoice,
					    TFAlbertForPreTraining,
					    TFAlbertForQuestionAnswering,
					    TFAlbertForSequenceClassification,
					    TFAlbertForTokenClassification,
					    TFAlbertModel,
					)
class  _snake_case						:






			def __init__(   self       ,_snake_case       ,_snake_case=13       ,_snake_case=7       ,_snake_case=True       ,_snake_case=True       ,_snake_case=True       ,_snake_case=True       ,_snake_case=99       ,_snake_case=16       ,_snake_case=32       ,_snake_case=2       ,_snake_case=4       ,_snake_case=37       ,_snake_case="gelu"       ,_snake_case=0.1       ,_snake_case=0.1       ,_snake_case=5_12       ,_snake_case=16       ,_snake_case=2       ,_snake_case=0.02       ,_snake_case=3       ,_snake_case=4       ,_snake_case=None       ,):
				UpperCAmelCase_			:	List[str]      =   parent
				UpperCAmelCase_			:	str      =   13
				UpperCAmelCase_			:	Optional[int]      =   7
				UpperCAmelCase_			:	int      =   True
				UpperCAmelCase_			:	str      =   True
				UpperCAmelCase_			:	Optional[Any]      =   True
				UpperCAmelCase_			:	List[str]      =   True
				UpperCAmelCase_			:	int      =   99
				UpperCAmelCase_			:	List[Any]      =   16
				UpperCAmelCase_			:	Dict      =   32
				UpperCAmelCase_			:	Dict      =   2
				UpperCAmelCase_			:	Dict      =   4
				UpperCAmelCase_			:	Optional[Any]      =   37
				UpperCAmelCase_			:	List[str]      =   "gelu"
				UpperCAmelCase_			:	Tuple      =   0.1
				UpperCAmelCase_			:	str      =   0.1
				UpperCAmelCase_			:	List[Any]      =   5_12
				UpperCAmelCase_			:	Tuple      =   16
				UpperCAmelCase_			:	Dict      =   2
				UpperCAmelCase_			:	List[Any]      =   0.02
				UpperCAmelCase_			:	Tuple      =   3
				UpperCAmelCase_			:	List[str]      =   4
				UpperCAmelCase_			:	Tuple      =   None






			def 						UpperCamelCase__				(   self			):
				UpperCAmelCase_			:	Union[str, Any]      =   ids_tensor([self.batch_size, self.seq_length]       ,self.vocab_size			)

				UpperCAmelCase_			:	Tuple      =   None
				if self.use_input_mask:
					UpperCAmelCase_			:	Optional[Any]      =   random_attention_mask([self.batch_size, self.seq_length]			)

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

				UpperCAmelCase_			:	Optional[Any]      =   None
				UpperCAmelCase_			:	Optional[Any]      =   None
				UpperCAmelCase_			:	Optional[int]      =   None
				if self.use_labels:
					UpperCAmelCase_			:	int      =   ids_tensor([self.batch_size]       ,self.type_sequence_label_size			)
					UpperCAmelCase_			:	Optional[int]      =   ids_tensor([self.batch_size, self.seq_length]       ,self.num_labels			)
					UpperCAmelCase_			:	str      =   ids_tensor([self.batch_size]       ,self.num_choices			)

				UpperCAmelCase_			:	Any      =   AlbertConfig(
				    vocab_size=self.vocab_size       ,hidden_size=self.hidden_size       ,embedding_size=self.embedding_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, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels






			def 						UpperCamelCase__				(   self       ,_snake_case       ,_snake_case       ,_snake_case       ,_snake_case       ,_snake_case       ,_snake_case       ,_snake_case			):
				UpperCAmelCase_			:	Tuple      =   TFAlbertModel(config=_snake_case			)
				# inputs = {'input_ids': input_ids,
				#           'attention_mask': input_mask,
				#           'token_type_ids': token_type_ids}
				# sequence_output, pooled_output = model(**inputs)
				UpperCAmelCase_			:	str      =   {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
				UpperCAmelCase_			:	List[str]      =   model(_snake_case			)

				UpperCAmelCase_			:	Dict      =   [input_ids, input_mask]
				UpperCAmelCase_			:	Dict      =   model(_snake_case			)

				UpperCAmelCase_			:	List[str]      =   model(_snake_case			)

				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 						UpperCamelCase__				(   self       ,_snake_case       ,_snake_case       ,_snake_case       ,_snake_case       ,_snake_case       ,_snake_case       ,_snake_case			):
				UpperCAmelCase_			:	Any      =   self.num_labels
				UpperCAmelCase_			:	Any      =   TFAlbertForPreTraining(config=_snake_case			)
				UpperCAmelCase_			:	List[Any]      =   {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
				UpperCAmelCase_			:	List[str]      =   model(_snake_case			)
				self.parent.assertEqual(result.prediction_logits.shape       ,(self.batch_size, self.seq_length, self.vocab_size)			)
				self.parent.assertEqual(result.sop_logits.shape       ,(self.batch_size, self.num_labels)			)






			def 						UpperCamelCase__				(   self       ,_snake_case       ,_snake_case       ,_snake_case       ,_snake_case       ,_snake_case       ,_snake_case       ,_snake_case			):
				UpperCAmelCase_			:	Dict      =   TFAlbertForMaskedLM(config=_snake_case			)
				UpperCAmelCase_			:	Tuple      =   {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
				UpperCAmelCase_			:	Dict      =   model(_snake_case			)
				self.parent.assertEqual(result.logits.shape       ,(self.batch_size, self.seq_length, self.vocab_size)			)






			def 						UpperCamelCase__				(   self       ,_snake_case       ,_snake_case       ,_snake_case       ,_snake_case       ,_snake_case       ,_snake_case       ,_snake_case			):
				UpperCAmelCase_			:	List[Any]      =   self.num_labels
				UpperCAmelCase_			:	Union[str, Any]      =   TFAlbertForSequenceClassification(config=_snake_case			)
				UpperCAmelCase_			:	str      =   {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
				UpperCAmelCase_			:	List[Any]      =   model(_snake_case			)
				self.parent.assertEqual(result.logits.shape       ,(self.batch_size, self.num_labels)			)






			def 						UpperCamelCase__				(   self       ,_snake_case       ,_snake_case       ,_snake_case       ,_snake_case       ,_snake_case       ,_snake_case       ,_snake_case			):
				UpperCAmelCase_			:	Union[str, Any]      =   TFAlbertForQuestionAnswering(config=_snake_case			)
				UpperCAmelCase_			:	Union[str, Any]      =   {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
				UpperCAmelCase_			:	Any      =   model(_snake_case			)
				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 						UpperCamelCase__				(   self       ,_snake_case       ,_snake_case       ,_snake_case       ,_snake_case       ,_snake_case       ,_snake_case       ,_snake_case			):
				UpperCAmelCase_			:	Tuple      =   self.num_choices
				UpperCAmelCase_			:	List[str]      =   TFAlbertForMultipleChoice(config=_snake_case			)
				UpperCAmelCase_			:	List[Any]      =   tf.tile(tf.expand_dims(_snake_case       ,1			)       ,(1, self.num_choices, 1)			)
				UpperCAmelCase_			:	Union[str, Any]      =   tf.tile(tf.expand_dims(_snake_case       ,1			)       ,(1, self.num_choices, 1)			)
				UpperCAmelCase_			:	Optional[int]      =   tf.tile(tf.expand_dims(_snake_case       ,1			)       ,(1, self.num_choices, 1)			)
				UpperCAmelCase_			:	Dict      =   {
				    "input_ids": multiple_choice_inputs_ids,
				    "attention_mask": multiple_choice_input_mask,
				    "token_type_ids": multiple_choice_token_type_ids,
				}
				UpperCAmelCase_			:	Union[str, Any]      =   model(_snake_case			)
				self.parent.assertListEqual(list(result["logits"].shape			)       ,[self.batch_size, self.num_choices]			)






			def 						UpperCamelCase__				(   self       ,_snake_case       ,_snake_case       ,_snake_case       ,_snake_case       ,_snake_case       ,_snake_case       ,_snake_case			):
				UpperCAmelCase_			:	List[Any]      =   self.num_labels
				UpperCAmelCase_			:	List[str]      =   TFAlbertForTokenClassification(config=_snake_case			)
				UpperCAmelCase_			:	int      =   {
				    "input_ids": input_ids,
				    "attention_mask": input_mask,
				    "token_type_ids": token_type_ids,
				}
				UpperCAmelCase_			:	List[str]      =   model(_snake_case			)
				self.parent.assertListEqual(list(result["logits"].shape			)       ,[self.batch_size, self.seq_length, self.num_labels]			)






			def 						UpperCamelCase__				(   self			):
				UpperCAmelCase_			:	List[Any]      =   self.prepare_config_and_inputs()
				(
				    (
				    UpperCAmelCase_
				) , (
				    UpperCAmelCase_
				) , (
				    UpperCAmelCase_
				) , (
				    UpperCAmelCase_
				) , (
				    UpperCAmelCase_
				) , (
				    UpperCAmelCase_
				) , (
				    UpperCAmelCase_
				) , 
				)			:	Union[str, Any]      =   config_and_inputs
				UpperCAmelCase_			:	Optional[int]      =   {"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
				return config, inputs_dict




@require_tf
class  _snake_case						(__SCREAMING_SNAKE_CASE       ,       __SCREAMING_SNAKE_CASE       ,       unittest.TestCase):
			__A   :     Tuple          =(
			    (
			        TFAlbertModel,
			        TFAlbertForPreTraining,
			        TFAlbertForMaskedLM,
			        TFAlbertForSequenceClassification,
			        TFAlbertForQuestionAnswering,
			        TFAlbertForTokenClassification,
			        TFAlbertForMultipleChoice,
			    )
			    if is_tf_available()
			    else ()
			)
			__A   :     List[str]          =(
			    {
			        "feature-extraction": TFAlbertModel,
			        "fill-mask": TFAlbertForMaskedLM,
			        "question-answering": TFAlbertForQuestionAnswering,
			        "text-classification": TFAlbertForSequenceClassification,
			        "token-classification": TFAlbertForTokenClassification,
			        "zero-shot": TFAlbertForSequenceClassification,
			    }
			    if is_tf_available()
			    else {}
			)
			__A   :     List[str]          =False
			__A   :     Dict          =False






			def 						UpperCamelCase__				(   self       ,_snake_case       ,_snake_case       ,_snake_case=False			):
				UpperCAmelCase_			:	List[Any]      =   super()._prepare_for_class(_snake_case       ,_snake_case       ,return_labels=_snake_case			)

				if return_labels:
					if model_class in get_values(_snake_case			):
						UpperCAmelCase_			:	List[str]      =   tf.zeros(self.model_tester.batch_size       ,dtype=tf.intaa			)

				return inputs_dict






			def 						UpperCamelCase__				(   self			):
				UpperCAmelCase_			:	List[str]      =   TFAlbertModelTester(self			)
				UpperCAmelCase_			:	Dict      =   ConfigTester(self       ,config_class=_snake_case       ,hidden_size=37			)






			def 						UpperCamelCase__				(   self			):
				self.config_tester.run_common_tests()






			def 						UpperCamelCase__				(   self			):
				UpperCAmelCase_			:	Optional[Any]      =   self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_albert_model(*_snake_case			)






			def 						UpperCamelCase__				(   self			):
				UpperCAmelCase_			:	Any      =   self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_albert_for_pretraining(*_snake_case			)






			def 						UpperCamelCase__				(   self			):
				UpperCAmelCase_			:	Any      =   self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_albert_for_masked_lm(*_snake_case			)






			def 						UpperCamelCase__				(   self			):
				UpperCAmelCase_			:	int      =   self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_albert_for_multiple_choice(*_snake_case			)






			def 						UpperCamelCase__				(   self			):
				UpperCAmelCase_			:	Union[str, Any]      =   self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_albert_for_sequence_classification(*_snake_case			)






			def 						UpperCamelCase__				(   self			):
				UpperCAmelCase_			:	Optional[int]      =   self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_albert_for_question_answering(*_snake_case			)






			@slow
			def 						UpperCamelCase__				(   self			):
				for model_name in TF_ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					UpperCAmelCase_			:	Tuple      =   TFAlbertModel.from_pretrained(_snake_case			)
					self.assertIsNotNone(_snake_case			)




@require_tf
class  _snake_case						(unittest.TestCase):






			@slow
			def 						UpperCamelCase__				(   self			):
				UpperCAmelCase_			:	Optional[int]      =   TFAlbertForPreTraining.from_pretrained("albert-base-v2"			)
				UpperCAmelCase_			:	Tuple      =   tf.constant([[0, 1, 2, 3, 4, 5]]			)
				UpperCAmelCase_			:	int      =   model(_snake_case			)[0]

				UpperCAmelCase_			:	Union[str, Any]      =   [1, 6, 3_00_00]
				self.assertEqual(output.shape       ,_snake_case			)

				UpperCAmelCase_			:	List[Any]      =   tf.constant(
				    [
				        [
				            [4.595668, 0.74462754, -1.818147],
				            [4.5954347, 0.7454184, -1.8188258],
				            [4.5954905, 0.7448235, -1.8182316],
				        ]
				    ]			)
				tf.debugging.assert_near(output[:, :3, :3]       ,_snake_case       ,atol=1E-4			)












"""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       ,						snake_case__       ,						snake_case__=13       ,						snake_case__=32       ,						snake_case__=2       ,						snake_case__=3       ,						snake_case__=16       ,						snake_case__=[1, 2, 1]       ,						snake_case__=[2, 2, 4]       ,						snake_case__=2       ,						snake_case__=2.0       ,						snake_case__=True       ,						snake_case__=0.0       ,						snake_case__=0.0       ,						snake_case__=0.1       ,						snake_case__="gelu"       ,						snake_case__=False       ,						snake_case__=True       ,						snake_case__=0.02       ,						snake_case__=1e-5       ,						snake_case__=True       ,						snake_case__=None       ,						snake_case__=True       ,						snake_case__=10       ,						snake_case__=8       ,						)	->	Optional[int]:



         """simple docstring"""





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



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



         """simple docstring"""





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

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

         UpperCAmelCase					=	self.get_config()

         return config, pixel_values, labels



  def 						UpperCamelCase_ (					self )	->	List[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 						UpperCamelCase_ (					self       ,						snake_case__       ,						snake_case__       ,						snake_case__ )	->	Optional[int]:



         """simple docstring"""





         UpperCAmelCase					=	DonutSwinModel(config=snake_case__ )
         model.to(snake_case__ )
         model.eval()
         UpperCAmelCase					=	model(snake_case__ )

         UpperCAmelCase					=	((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths ) - 1))
         UpperCAmelCase					=	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 						UpperCamelCase_ (					self )	->	Optional[Any]:



         """simple docstring"""





         UpperCAmelCase					=	self.prepare_config_and_inputs()
         (
             (
             UpperCAmelCase
         )			,				(
             UpperCAmelCase
         )			,				(
             UpperCAmelCase
         )			,				
         )					=	config_and_inputs
         UpperCAmelCase					=	{"""pixel_values""": pixel_values}
         return config, inputs_dict





@require_torch
class      UpperCamelCase_       (				a_      ,    a_      ,    unittest.TestCase     ):
  _A				:    Tuple =		(DonutSwinModel,) if is_torch_available() else ()
  _A				:    Any =		{'feature-extraction': DonutSwinModel} if is_torch_available() else {}
  _A				:    Optional[Any] =		True

  _A				:    Dict =		False
  _A				:    Any =		False
  _A				:    Tuple =		False



  def 						UpperCamelCase_ (					self )	->	Any:



         """simple docstring"""





         UpperCAmelCase					=	DonutSwinModelTester(self )
         UpperCAmelCase					=	ConfigTester(self       ,						config_class=snake_case__       ,						embed_dim=37 )



  def 						UpperCamelCase_ (					self )	->	Dict:



         """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 						UpperCamelCase_ (					self )	->	List[str]:



         """simple docstring"""





         return



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



         """simple docstring"""





         UpperCAmelCase					=	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*snake_case__ )



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



         """simple docstring"""





         pass



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



         """simple docstring"""





         UpperCAmelCase			,				UpperCAmelCase					=	self.model_tester.prepare_config_and_inputs_for_common()

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



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



         """simple docstring"""





         UpperCAmelCase			,				UpperCAmelCase					=	self.model_tester.prepare_config_and_inputs_for_common()

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

                UpperCAmelCase					=	["""pixel_values"""]
                self.assertListEqual(arg_names[:1]       ,						snake_case__ )



  def 						UpperCamelCase_ (					self )	->	Tuple:



         """simple docstring"""





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

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

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

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

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

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

                UpperCAmelCase					=	outputs.attentions

                self.assertEqual(len(snake_case__ )       ,						snake_case__ )

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



  def 						UpperCamelCase_ (					self       ,						snake_case__       ,						snake_case__       ,						snake_case__       ,						snake_case__ )	->	Optional[int]:



         """simple docstring"""





         UpperCAmelCase					=	model_class(snake_case__ )
         model.to(snake_case__ )
         model.eval()

         with torch.no_grad():
                UpperCAmelCase					=	model(**self._prepare_for_class(snake_case__       ,						snake_case__ ) )

         UpperCAmelCase					=	outputs.hidden_states

         UpperCAmelCase					=	getattr(
             self.model_tester       ,						"""expected_num_hidden_layers"""       ,						len(self.model_tester.depths ) + 1 )
         self.assertEqual(len(snake_case__ )       ,						snake_case__ )

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

         UpperCAmelCase					=	(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]       ,						)

         UpperCAmelCase					=	outputs.reshaped_hidden_states
         self.assertEqual(len(snake_case__ )       ,						snake_case__ )

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



  def 						UpperCamelCase_ (					self )	->	str:



         """simple docstring"""





         UpperCAmelCase			,				UpperCAmelCase					=	self.model_tester.prepare_config_and_inputs_for_common()

         UpperCAmelCase					=	(
             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:
                UpperCAmelCase					=	True
                self.check_hidden_states_output(snake_case__       ,						snake_case__       ,						snake_case__       ,						snake_case__ )

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

                self.check_hidden_states_output(snake_case__       ,						snake_case__       ,						snake_case__       ,						snake_case__ )



  def 						UpperCamelCase_ (					self )	->	Dict:



         """simple docstring"""





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

         UpperCAmelCase					=	(
             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)
         )
         UpperCAmelCase					=	(
             config.patch_size
             if isinstance(config.patch_size       ,						collections.abc.Iterable )
             else (config.patch_size, config.patch_size)
         )

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

         for model_class in self.all_model_classes:
                UpperCAmelCase					=	True
                self.check_hidden_states_output(snake_case__       ,						snake_case__       ,						snake_case__       ,						(padded_height, padded_width) )

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



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



         """simple docstring"""





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



  def 						UpperCamelCase_ (					self )	->	Any:



         """simple docstring"""





         UpperCAmelCase			,				UpperCAmelCase					=	self.model_tester.prepare_config_and_inputs_for_common()

         UpperCAmelCase					=	_config_zero_init(snake_case__ )
         for model_class in self.all_model_classes:
                UpperCAmelCase					=	model_class(config=snake_case__ )
                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'''       ,						)
