



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 			__snake_case   :







							'''simple docstring'''






							def __init__(				self	,	a_	,	a_=13	,	a_=32	,	a_=2	,	a_=3	,	a_=16	,	a_=[1, 2, 1]	,	a_=[2, 2, 4]	,	a_=2	,	a_=2.0	,	a_=True	,	a_=0.0	,	a_=0.0	,	a_=0.1	,	a_="gelu"	,	a_=False	,	a_=True	,	a_=0.02	,	a_=1E-5	,	a_=True	,	a_=None	,	a_=True	,	a_=10	,	a_=8	,	):
											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 _a   (				self		):
											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 _a   (				self		):
											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 _a   (				self	,	a_	,	a_	,	a_		):
											a__					   =		DonutSwinModel(config=__UpperCamelCase		)
											model.to(__UpperCamelCase		)
											model.eval()
											a__					   =		model(__UpperCamelCase		)

											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 _a   (				self		):
											a__					   =		self.prepare_config_and_inputs()
											(
											    a__    
											)					   =		config_and_inputs
											a__					   =		{'pixel_values': pixel_values}
											return config, inputs_dict




@require_torch
class 			__snake_case   ( _lowerCamelCase      ,_lowerCamelCase      ,unittest.TestCase):







							'''simple docstring'''






							UpperCamelCase__					:   Tuple       =       (DonutSwinModel,) if is_torch_available() else ()
							UpperCamelCase__					:   str       =       {"""feature-extraction""": DonutSwinModel} if is_torch_available() else {}
							UpperCamelCase__					:   List[Any]       =       True

							UpperCamelCase__					:   Union[str, Any]       =       False
							UpperCamelCase__					:   Any       =       False
							UpperCamelCase__					:   Any       =       False


							def _a   (				self		):
											a__					   =		DonutSwinModelTester(self		)
											a__					   =		ConfigTester(self	,	config_class=__UpperCamelCase	,	embed_dim=37		)


							def _a   (				self		):
											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 _a   (				self		):
											return


							def _a   (				self		):
											a__					   =		self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*__UpperCamelCase		)


							def _a   (				self		):
											pass


							def _a   (				self		):
											a__					   =		self.model_tester.prepare_config_and_inputs_for_common()

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


							def _a   (				self		):
											a__					   =		self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
															a__					   =		model_class(__UpperCamelCase		)
															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]	,	__UpperCamelCase		)


							def _a   (				self		):
											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(__UpperCamelCase		)
															model.to(__UpperCamelCase		)
															model.eval()
															with torch.no_grad():
																			a__					   =		model(**self._prepare_for_class(__UpperCamelCase	,	__UpperCamelCase		)		)
															a__					   =		outputs.attentions
															a__					   =		len(self.model_tester.depths		)
															self.assertEqual(len(__UpperCamelCase		)	,	__UpperCamelCase		)

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

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

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

															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(__UpperCamelCase		)		)

															a__					   =		outputs.attentions

															self.assertEqual(len(__UpperCamelCase		)	,	__UpperCamelCase		)

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


							def _a   (				self	,	a_	,	a_	,	a_	,	a_		):
											a__					   =		model_class(__UpperCamelCase		)
											model.to(__UpperCamelCase		)
											model.eval()

											with torch.no_grad():
															a__					   =		model(**self._prepare_for_class(__UpperCamelCase	,	__UpperCamelCase		)		)

											a__					   =		outputs.hidden_states

											a__					   =		getattr(
											    self.model_tester	,	"""expected_num_hidden_layers"""	,	len(self.model_tester.depths		) + 1		)
											self.assertEqual(len(__UpperCamelCase		)	,	__UpperCamelCase		)

											# 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(__UpperCamelCase		)	,	__UpperCamelCase		)

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


							def _a   (				self		):
											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(__UpperCamelCase	,	__UpperCamelCase	,	__UpperCamelCase	,	__UpperCamelCase		)

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

															self.check_hidden_states_output(__UpperCamelCase	,	__UpperCamelCase	,	__UpperCamelCase	,	__UpperCamelCase		)


							def _a   (				self		):
											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(__UpperCamelCase	,	__UpperCamelCase	,	__UpperCamelCase	,	(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(__UpperCamelCase	,	__UpperCamelCase	,	__UpperCamelCase	,	(padded_height, padded_width)		)


							@slow
							def _a   (				self		):







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







							def _a   (				self		):
											a__					   =		self.model_tester.prepare_config_and_inputs_for_common()

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


from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


lowerCAmelCase__	:  int						=  {
    '''configuration_switch_transformers''': [
        '''SWITCH_TRANSFORMERS_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''SwitchTransformersConfig''',
        '''SwitchTransformersOnnxConfig''',
    ]
}

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				lowerCAmelCase__	:  List[Any]						=  [
				    '''SWITCH_TRANSFORMERS_PRETRAINED_MODEL_ARCHIVE_LIST''',
				    '''SwitchTransformersEncoderModel''',
				    '''SwitchTransformersForConditionalGeneration''',
				    '''SwitchTransformersModel''',
				    '''SwitchTransformersPreTrainedModel''',
				    '''SwitchTransformersTop1Router''',
				    '''SwitchTransformersSparseMLP''',
				]


if TYPE_CHECKING:
				from .configuration_switch_transformers import (
				    SWITCH_TRANSFORMERS_PRETRAINED_CONFIG_ARCHIVE_MAP,
				    SwitchTransformersConfig,
				    SwitchTransformersOnnxConfig,
				)

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_switch_transformers import (
								    SWITCH_TRANSFORMERS_PRETRAINED_MODEL_ARCHIVE_LIST,
								    SwitchTransformersEncoderModel,
								    SwitchTransformersForConditionalGeneration,
								    SwitchTransformersModel,
								    SwitchTransformersPreTrainedModel,
								    SwitchTransformersSparseMLP,
								    SwitchTransformersTopaRouter,
								)


else:
				import sys

				lowerCAmelCase__	:  Union[str, Any]						=  _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)


