
import tempfile
import unittest

import transformers
from transformers import XGLMConfig, XGLMTokenizer, is_flax_available, is_torch_available
from transformers.testing_utils import is_pt_flax_cross_test, require_flax, require_sentencepiece, slow

from ...generation.test_flax_utils import FlaxGenerationTesterMixin
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask


if is_flax_available():
							import jax
							import jax.numpy as jnp
							import numpy as np

							from transformers.modeling_flax_pytorch_utils import (
							    convert_pytorch_state_dict_to_flax,
							    load_flax_weights_in_pytorch_model,
							)
							from transformers.models.xglm.modeling_flax_xglm import FlaxXGLMForCausalLM, FlaxXGLMModel


if is_torch_available():
							import torch





@require_flax
class 						lowercase       :
					def __init__(		self ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__=14 ,	SCREAMING_SNAKE_CASE__=7 ,	SCREAMING_SNAKE_CASE__=True ,	SCREAMING_SNAKE_CASE__=True ,	SCREAMING_SNAKE_CASE__=True ,	SCREAMING_SNAKE_CASE__=99 ,	SCREAMING_SNAKE_CASE__=32 ,	SCREAMING_SNAKE_CASE__=5 ,	SCREAMING_SNAKE_CASE__=4 ,	SCREAMING_SNAKE_CASE__=37 ,	SCREAMING_SNAKE_CASE__="gelu" ,	SCREAMING_SNAKE_CASE__=0.1 ,	SCREAMING_SNAKE_CASE__=0.1 ,	SCREAMING_SNAKE_CASE__=512 ,	SCREAMING_SNAKE_CASE__=0.02 ,	SCREAMING_SNAKE_CASE__=None ,	):
								"""simple docstring"""







								lowerCAmelCase__ :    Optional[Any]				      =			parent
								lowerCAmelCase__ :    Tuple				      =			batch_size
								lowerCAmelCase__ :    List[Any]				      =			seq_length
								lowerCAmelCase__ :    Optional[int]				      =			is_training
								lowerCAmelCase__ :    Optional[int]				      =			use_input_mask
								lowerCAmelCase__ :    int				      =			use_labels
								lowerCAmelCase__ :    str				      =			vocab_size
								lowerCAmelCase__ :    str				      =			d_model
								lowerCAmelCase__ :    List[Any]				      =			num_hidden_layers
								lowerCAmelCase__ :    str				      =			num_attention_heads
								lowerCAmelCase__ :    Tuple				      =			ffn_dim
								lowerCAmelCase__ :    Dict				      =			activation_function
								lowerCAmelCase__ :    Optional[Any]				      =			activation_dropout
								lowerCAmelCase__ :    Optional[int]				      =			attention_dropout
								lowerCAmelCase__ :    str				      =			max_position_embeddings
								lowerCAmelCase__ :    Optional[Any]				      =			initializer_range
								lowerCAmelCase__ :    Dict				      =			None
								lowerCAmelCase__ :    List[Any]				      =			0
								lowerCAmelCase__ :    List[str]				      =			2
								lowerCAmelCase__ :    List[Any]				      =			1
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__ :    Dict				      =			np.clip(ids_tensor([self.batch_size, self.seq_length] ,	self.vocab_size    ) ,	3 ,	self.vocab_size    )

								lowerCAmelCase__ :    Union[str, Any]				      =			None
								if self.use_input_mask:
											lowerCAmelCase__ :    int				      =			random_attention_mask([self.batch_size, self.seq_length]    )

								lowerCAmelCase__ :    Dict				      =			XGLMConfig(
								    vocab_size=self.vocab_size ,	d_model=self.hidden_size ,	num_layers=self.num_hidden_layers ,	attention_heads=self.num_attention_heads ,	ffn_dim=self.ffn_dim ,	activation_function=self.activation_function ,	activation_dropout=self.activation_dropout ,	attention_dropout=self.attention_dropout ,	max_position_embeddings=self.max_position_embeddings ,	initializer_range=self.initializer_range ,	use_cache=__UpperCamelCase ,	bos_token_id=self.bos_token_id ,	eos_token_id=self.eos_token_id ,	pad_token_id=self.pad_token_id ,	)

								return (config, input_ids, input_mask)
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__ :    int				      =			self.prepare_config_and_inputs()
								lowerCAmelCase__      ,				lowerCAmelCase__      ,				lowerCAmelCase__ :    Any				      =			config_and_inputs
								lowerCAmelCase__ :    Union[str, Any]				      =			{'''input_ids''': input_ids, '''attention_mask''': attention_mask}
								return config, inputs_dict
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__      ,				lowerCAmelCase__      ,				lowerCAmelCase__ :    List[str]				      =			self.prepare_config_and_inputs()

								lowerCAmelCase__ :    str				      =			floats_tensor([self.batch_size, self.seq_length, self.hidden_size]    )
								lowerCAmelCase__ :    List[str]				      =			ids_tensor([self.batch_size, self.seq_length] ,	vocab_size=2    )

								return (
								    config,
								    input_ids,
								    attention_mask,
								    encoder_hidden_states,
								    encoder_attention_mask,
								)
					def lowercase_			(		self ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__    ):
								"""simple docstring"""







								lowerCAmelCase__ :    int				      =			20
								lowerCAmelCase__ :    Optional[int]				      =			model_class_name(__UpperCamelCase    )

								lowerCAmelCase__ :    Dict				      =			model.init_cache(input_ids.shape[0] ,	__UpperCamelCase    )
								lowerCAmelCase__ :    Tuple				      =			jnp.ones((input_ids.shape[0], max_decoder_length) ,	dtype='''i4'''    )

								lowerCAmelCase__ :    List[str]				      =			jnp.broadcast_to(
								    jnp.arange(input_ids.shape[-1] - 1    )[None, :] ,	(input_ids.shape[0], input_ids.shape[-1] - 1)    )
								lowerCAmelCase__ :    Dict				      =			model(
								    input_ids[:, :-1] ,	attention_mask=__UpperCamelCase ,	past_key_values=__UpperCamelCase ,	position_ids=__UpperCamelCase ,	)

								lowerCAmelCase__ :    List[str]				      =			jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]] ,	dtype='''i4'''    )
								lowerCAmelCase__ :    Tuple				      =			model(
								    input_ids[:, -1:] ,	attention_mask=__UpperCamelCase ,	past_key_values=outputs_cache.past_key_values ,	position_ids=__UpperCamelCase ,	)

								lowerCAmelCase__ :    Optional[int]				      =			model(__UpperCamelCase    )

								lowerCAmelCase__ :    Union[str, Any]				      =			np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])    )    )
								self.parent.assertTrue(diff < 1E-3 ,	msg=f'''Max diff is {diff}'''    )
					def lowercase_			(		self ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__    ):
								"""simple docstring"""







								lowerCAmelCase__ :    int				      =			20
								lowerCAmelCase__ :    Union[str, Any]				      =			model_class_name(__UpperCamelCase    )

								lowerCAmelCase__ :    Optional[int]				      =			jnp.concatenate(
								    [attention_mask, jnp.zeros((attention_mask.shape[0], max_decoder_length - attention_mask.shape[1])    )] ,	axis=-1 ,	)

								lowerCAmelCase__ :    Tuple				      =			model.init_cache(input_ids.shape[0] ,	__UpperCamelCase    )
								lowerCAmelCase__ :    str				      =			jnp.broadcast_to(
								    jnp.arange(input_ids.shape[-1] - 1    )[None, :] ,	(input_ids.shape[0], input_ids.shape[-1] - 1)    )

								lowerCAmelCase__ :    str				      =			model(
								    input_ids[:, :-1] ,	attention_mask=__UpperCamelCase ,	past_key_values=__UpperCamelCase ,	position_ids=__UpperCamelCase ,	)
								lowerCAmelCase__ :    Union[str, Any]				      =			jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]] ,	dtype='''i4'''    )
								lowerCAmelCase__ :    Tuple				      =			model(
								    input_ids[:, -1:] ,	past_key_values=outputs_cache.past_key_values ,	attention_mask=__UpperCamelCase ,	position_ids=__UpperCamelCase ,	)

								lowerCAmelCase__ :    Union[str, Any]				      =			model(__UpperCamelCase ,	attention_mask=__UpperCamelCase    )
								lowerCAmelCase__ :    str				      =			np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])    )    )
								self.parent.assertTrue(diff < 1E-3 ,	msg=f'''Max diff is {diff}'''    )





@require_sentencepiece
@require_flax
class 						lowercase       (  UpperCAmelCase_	,		UpperCAmelCase_	,		unittest.TestCase					):
					__a					=    (FlaxXGLMModel, FlaxXGLMForCausalLM) if is_flax_available() else ()
					__a					=    (FlaxXGLMForCausalLM,) if is_flax_available() else ()
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__ :    Dict				      =			FlaxXGLMModelTester(self    )
					def lowercase_			(		self    ):
								"""simple docstring"""







								for model_class_name in self.all_model_classes:
											lowerCAmelCase__      ,				lowerCAmelCase__      ,				lowerCAmelCase__ :    Optional[int]				      =			self.model_tester.prepare_config_and_inputs()
											self.model_tester.check_use_cache_forward(__UpperCamelCase ,	__UpperCamelCase ,	__UpperCamelCase ,	__UpperCamelCase    )
					def lowercase_			(		self    ):
								"""simple docstring"""







								for model_class_name in self.all_model_classes:
											lowerCAmelCase__      ,				lowerCAmelCase__      ,				lowerCAmelCase__ :    Tuple				      =			self.model_tester.prepare_config_and_inputs()
											self.model_tester.check_use_cache_forward_with_attn_mask(
											    __UpperCamelCase ,	__UpperCamelCase ,	__UpperCamelCase ,	__UpperCamelCase    )
					@slow
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__ :    Optional[int]				      =			XGLMTokenizer.from_pretrained('''XGLM''' ,	padding_side='''left'''    )
								lowerCAmelCase__ :    List[str]				      =			tokenizer(['''Hello this is a long string''', '''Hey'''] ,	return_tensors='''np''' ,	padding=__UpperCamelCase ,	truncation=__UpperCamelCase    )

								lowerCAmelCase__ :    Tuple				      =			FlaxXGLMForCausalLM.from_pretrained('''facebook/xglm-564M'''    )
								lowerCAmelCase__ :    int				      =			1
								lowerCAmelCase__ :    List[str]				      =			False

								lowerCAmelCase__ :    str				      =			jax.jit(model.generate    )

								lowerCAmelCase__ :    str				      =			jit_generate(inputs['''input_ids'''] ,	attention_mask=inputs['''attention_mask''']    ).sequences

								lowerCAmelCase__ :    str				      =			tokenizer.batch_decode(__UpperCamelCase ,	skip_special_tokens=__UpperCamelCase    )

								lowerCAmelCase__ :    Any				      =			[
								    '''Hello this is a long string of questions, but I\'m not sure if I\'m''',
								    '''Hey, I\'m a newbie to the forum and I\'''',
								]

								self.assertListEqual(__UpperCamelCase ,	__UpperCamelCase    )
					@is_pt_flax_cross_test
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__      ,				lowerCAmelCase__ :    Optional[int]				      =			self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
											with self.subTest(model_class.__name__    ):
														# prepare inputs
														lowerCAmelCase__ :    Tuple				      =			self._prepare_for_class(__UpperCamelCase ,	__UpperCamelCase    )
														lowerCAmelCase__ :    str				      =			{k: torch.tensor(v.tolist()    ) for k, v in prepared_inputs_dict.items()}

														# load corresponding PyTorch class
														lowerCAmelCase__ :    int				      =			model_class.__name__[4:]  # Skip the "Flax" at the beginning
														lowerCAmelCase__ :    Dict				      =			getattr(__UpperCamelCase ,	__UpperCamelCase    )

														lowerCAmelCase__      ,				lowerCAmelCase__ :    Tuple				      =			pt_inputs['''input_ids'''].shape
														lowerCAmelCase__ :    Any				      =			np.random.randint(0 ,	seq_length - 1 ,	size=(batch_size,)    )
														for batch_idx, start_index in enumerate(__UpperCamelCase    ):
																	lowerCAmelCase__ :    int				      =			0
																	lowerCAmelCase__ :    Any				      =			1
																	lowerCAmelCase__ :    str				      =			0
																	lowerCAmelCase__ :    Tuple				      =			1
														lowerCAmelCase__ :    Optional[int]				      =			pt_model_class(__UpperCamelCase    ).eval()
														# Flax models don't use the `use_cache` option and cache is not returned as a default.
														# So we disable `use_cache` here for PyTorch model.
														lowerCAmelCase__ :    str				      =			False
														lowerCAmelCase__ :    Union[str, Any]				      =			model_class(__UpperCamelCase ,	dtype=jnp.floataa    )
														lowerCAmelCase__ :    List[str]				      =			convert_pytorch_state_dict_to_flax(pt_model.state_dict() ,	__UpperCamelCase    )
														lowerCAmelCase__ :    Optional[int]				      =			fx_state

														with torch.no_grad():
																	lowerCAmelCase__ :    Optional[int]				      =			pt_model(**__UpperCamelCase    ).to_tuple()

														lowerCAmelCase__ :    Optional[Any]				      =			fx_model(**__UpperCamelCase    ).to_tuple()
														self.assertEqual(len(__UpperCamelCase    ) ,	len(__UpperCamelCase    ) ,	'''Output lengths differ between Flax and PyTorch'''    )
														for fx_output, pt_output in zip(__UpperCamelCase ,	__UpperCamelCase    ):
																	self.assert_almost_equals(fx_output[:, -1] ,	pt_output[:, -1].numpy() ,	4E-2    )

														with tempfile.TemporaryDirectory() as tmpdirname:
																	pt_model.save_pretrained(__UpperCamelCase    )
																	lowerCAmelCase__ :    Any				      =			model_class.from_pretrained(__UpperCamelCase ,	from_pt=__UpperCamelCase    )

														lowerCAmelCase__ :    str				      =			fx_model_loaded(**__UpperCamelCase    ).to_tuple()
														self.assertEqual(
														    len(__UpperCamelCase    ) ,	len(__UpperCamelCase    ) ,	'''Output lengths differ between Flax and PyTorch'''    )
														for fx_output_loaded, pt_output in zip(__UpperCamelCase ,	__UpperCamelCase    ):
																	self.assert_almost_equals(fx_output_loaded[:, -1] ,	pt_output[:, -1].numpy() ,	4E-2    )
					@is_pt_flax_cross_test
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__      ,				lowerCAmelCase__ :    Any				      =			self.model_tester.prepare_config_and_inputs_for_common()
								for model_class in self.all_model_classes:
											with self.subTest(model_class.__name__    ):
														# prepare inputs
														lowerCAmelCase__ :    Tuple				      =			self._prepare_for_class(__UpperCamelCase ,	__UpperCamelCase    )
														lowerCAmelCase__ :    Union[str, Any]				      =			{k: torch.tensor(v.tolist()    ) for k, v in prepared_inputs_dict.items()}

														# load corresponding PyTorch class
														lowerCAmelCase__ :    int				      =			model_class.__name__[4:]  # Skip the "Flax" at the beginning
														lowerCAmelCase__ :    Union[str, Any]				      =			getattr(__UpperCamelCase ,	__UpperCamelCase    )

														lowerCAmelCase__ :    Union[str, Any]				      =			pt_model_class(__UpperCamelCase    ).eval()
														lowerCAmelCase__ :    Optional[Any]				      =			False
														lowerCAmelCase__ :    Optional[Any]				      =			model_class(__UpperCamelCase ,	dtype=jnp.floataa    )

														lowerCAmelCase__ :    Optional[int]				      =			load_flax_weights_in_pytorch_model(__UpperCamelCase ,	fx_model.params    )
														lowerCAmelCase__      ,				lowerCAmelCase__ :    List[str]				      =			pt_inputs['''input_ids'''].shape
														lowerCAmelCase__ :    int				      =			np.random.randint(0 ,	seq_length - 1 ,	size=(batch_size,)    )
														for batch_idx, start_index in enumerate(__UpperCamelCase    ):
																	lowerCAmelCase__ :    Optional[int]				      =			0
																	lowerCAmelCase__ :    Any				      =			1
																	lowerCAmelCase__ :    List[str]				      =			0
																	lowerCAmelCase__ :    List[Any]				      =			1

														# make sure weights are tied in PyTorch
														pt_model.tie_weights()

														with torch.no_grad():
																	lowerCAmelCase__ :    List[Any]				      =			pt_model(**__UpperCamelCase    ).to_tuple()

														lowerCAmelCase__ :    int				      =			fx_model(**__UpperCamelCase    ).to_tuple()
														self.assertEqual(len(__UpperCamelCase    ) ,	len(__UpperCamelCase    ) ,	'''Output lengths differ between Flax and PyTorch'''    )
														for fx_output, pt_output in zip(__UpperCamelCase ,	__UpperCamelCase    ):
																	self.assert_almost_equals(fx_output[:, -1] ,	pt_output[:, -1].numpy() ,	4E-2    )

														with tempfile.TemporaryDirectory() as tmpdirname:
																	fx_model.save_pretrained(__UpperCamelCase    )
																	lowerCAmelCase__ :    str				      =			pt_model_class.from_pretrained(__UpperCamelCase ,	from_flax=__UpperCamelCase    )

														with torch.no_grad():
																	lowerCAmelCase__ :    Tuple				      =			pt_model_loaded(**__UpperCamelCase    ).to_tuple()

														self.assertEqual(
														    len(__UpperCamelCase    ) ,	len(__UpperCamelCase    ) ,	'''Output lengths differ between Flax and PyTorch'''    )
														for fx_output, pt_output in zip(__UpperCamelCase ,	__UpperCamelCase    ):
																	self.assert_almost_equals(fx_output[:, -1] ,	pt_output[:, -1].numpy() ,	4E-2    )
					@slow
					def lowercase_			(		self    ):
								"""simple docstring"""







								for model_class_name in self.all_model_classes:
											lowerCAmelCase__ :    Dict				      =			model_class_name.from_pretrained('''facebook/xglm-564M'''    )
											lowerCAmelCase__ :    List[str]				      =			model(np.ones((1, 1)    )    )
											self.assertIsNotNone(__UpperCamelCase    )





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 						lowercase       :
					def __init__(		self ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__=13 ,	SCREAMING_SNAKE_CASE__=32 ,	SCREAMING_SNAKE_CASE__=2 ,	SCREAMING_SNAKE_CASE__=3 ,	SCREAMING_SNAKE_CASE__=16 ,	SCREAMING_SNAKE_CASE__=[1, 2, 1] ,	SCREAMING_SNAKE_CASE__=[2, 2, 4] ,	SCREAMING_SNAKE_CASE__=2 ,	SCREAMING_SNAKE_CASE__=2.0 ,	SCREAMING_SNAKE_CASE__=True ,	SCREAMING_SNAKE_CASE__=0.0 ,	SCREAMING_SNAKE_CASE__=0.0 ,	SCREAMING_SNAKE_CASE__=0.1 ,	SCREAMING_SNAKE_CASE__="gelu" ,	SCREAMING_SNAKE_CASE__=False ,	SCREAMING_SNAKE_CASE__=True ,	SCREAMING_SNAKE_CASE__=0.02 ,	SCREAMING_SNAKE_CASE__=1E-5 ,	SCREAMING_SNAKE_CASE__=True ,	SCREAMING_SNAKE_CASE__=None ,	SCREAMING_SNAKE_CASE__=True ,	SCREAMING_SNAKE_CASE__=10 ,	SCREAMING_SNAKE_CASE__=8 ,	):
								"""simple docstring"""







								lowerCAmelCase__ :    Any				      =			parent
								lowerCAmelCase__ :    str				      =			batch_size
								lowerCAmelCase__ :    Tuple				      =			image_size
								lowerCAmelCase__ :    Union[str, Any]				      =			patch_size
								lowerCAmelCase__ :    int				      =			num_channels
								lowerCAmelCase__ :    Tuple				      =			embed_dim
								lowerCAmelCase__ :    Optional[int]				      =			depths
								lowerCAmelCase__ :    Tuple				      =			num_heads
								lowerCAmelCase__ :    Tuple				      =			window_size
								lowerCAmelCase__ :    Dict				      =			mlp_ratio
								lowerCAmelCase__ :    int				      =			qkv_bias
								lowerCAmelCase__ :    Dict				      =			hidden_dropout_prob
								lowerCAmelCase__ :    Dict				      =			attention_probs_dropout_prob
								lowerCAmelCase__ :    Tuple				      =			drop_path_rate
								lowerCAmelCase__ :    int				      =			hidden_act
								lowerCAmelCase__ :    Union[str, Any]				      =			use_absolute_embeddings
								lowerCAmelCase__ :    Dict				      =			patch_norm
								lowerCAmelCase__ :    Any				      =			layer_norm_eps
								lowerCAmelCase__ :    Tuple				      =			initializer_range
								lowerCAmelCase__ :    Optional[Any]				      =			is_training
								lowerCAmelCase__ :    str				      =			scope
								lowerCAmelCase__ :    List[str]				      =			use_labels
								lowerCAmelCase__ :    Optional[Any]				      =			type_sequence_label_size
								lowerCAmelCase__ :    int				      =			encoder_stride
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__ :    List[str]				      =			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )

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

								lowerCAmelCase__ :    Tuple				      =			self.get_config()

								return config, pixel_values, labels
					def lowercase_			(		self    ):
								"""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 ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__    ):
								"""simple docstring"""







								lowerCAmelCase__ :    Optional[Any]				      =			DonutSwinModel(config=SCREAMING_SNAKE_CASE__    )
								model.to(SCREAMING_SNAKE_CASE__    )
								model.eval()
								lowerCAmelCase__ :    Optional[Any]				      =			model(SCREAMING_SNAKE_CASE__    )

								lowerCAmelCase__ :    str				      =			((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths    ) - 1))
								lowerCAmelCase__ :    int				      =			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    ):
								"""simple docstring"""







								lowerCAmelCase__ :    int				      =			self.prepare_config_and_inputs()
								(
								    (
								    lowerCAmelCase__
								)      ,				(
								    lowerCAmelCase__
								)      ,				(
								    lowerCAmelCase__
								)      ,				
								) :    Optional[Any]				      =			config_and_inputs
								lowerCAmelCase__ :    Union[str, Any]				      =			{'''pixel_values''': pixel_values}
								return config, inputs_dict





@require_torch
class 						lowercase       (  __UpperCamelCase	,		__UpperCamelCase	,		unittest.TestCase					):
					__a					=    (DonutSwinModel,) if is_torch_available() else ()
					__a					=    {"""feature-extraction""": DonutSwinModel} if is_torch_available() else {}
					__a					=    True

					__a					=    False
					__a					=    False
					__a					=    False
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__ :    List[str]				      =			DonutSwinModelTester(self    )
								lowerCAmelCase__ :    Union[str, Any]				      =			ConfigTester(self ,	config_class=SCREAMING_SNAKE_CASE__ ,	embed_dim=37    )
					def lowercase_			(		self    ):
								"""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    ):
								"""simple docstring"""







								return
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__ :    int				      =			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE__    )
					def lowercase_			(		self    ):
								"""simple docstring"""







								pass
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__      ,				lowerCAmelCase__ :    Optional[Any]				      =			self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
											lowerCAmelCase__ :    List[str]				      =			model_class(SCREAMING_SNAKE_CASE__    )
											self.assertIsInstance(model.get_input_embeddings() ,	(nn.Module)    )
											lowerCAmelCase__ :    Dict				      =			model.get_output_embeddings()
											self.assertTrue(x is None or isinstance(SCREAMING_SNAKE_CASE__ ,	nn.Linear    )    )
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__      ,				lowerCAmelCase__ :    Tuple				      =			self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
											lowerCAmelCase__ :    Union[str, Any]				      =			model_class(SCREAMING_SNAKE_CASE__    )
											lowerCAmelCase__ :    Optional[Any]				      =			inspect.signature(model.forward    )
											# signature.parameters is an OrderedDict => so arg_names order is deterministic
											lowerCAmelCase__ :    Tuple				      =			[*signature.parameters.keys()]

											lowerCAmelCase__ :    List[str]				      =			['''pixel_values''']
											self.assertListEqual(arg_names[:1] ,	SCREAMING_SNAKE_CASE__    )
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__      ,				lowerCAmelCase__ :    str				      =			self.model_tester.prepare_config_and_inputs_for_common()
								lowerCAmelCase__ :    List[Any]				      =			True

								for model_class in self.all_model_classes:
											lowerCAmelCase__ :    int				      =			True
											lowerCAmelCase__ :    Union[str, Any]				      =			False
											lowerCAmelCase__ :    Tuple				      =			True
											lowerCAmelCase__ :    str				      =			model_class(SCREAMING_SNAKE_CASE__    )
											model.to(SCREAMING_SNAKE_CASE__    )
											model.eval()
											with torch.no_grad():
														lowerCAmelCase__ :    Dict				      =			model(**self._prepare_for_class(SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__    )    )
											lowerCAmelCase__ :    List[Any]				      =			outputs.attentions
											lowerCAmelCase__ :    str				      =			len(self.model_tester.depths    )
											self.assertEqual(len(SCREAMING_SNAKE_CASE__    ) ,	SCREAMING_SNAKE_CASE__    )

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

											self.assertListEqual(
											    list(attentions[0].shape[-3:]    ) ,	[self.model_tester.num_heads[0], window_size_squared, window_size_squared] ,	)
											lowerCAmelCase__ :    Optional[int]				      =			len(SCREAMING_SNAKE_CASE__    )

											# Check attention is always last and order is fine
											lowerCAmelCase__ :    Any				      =			True
											lowerCAmelCase__ :    List[Any]				      =			True
											lowerCAmelCase__ :    Tuple				      =			model_class(SCREAMING_SNAKE_CASE__    )
											model.to(SCREAMING_SNAKE_CASE__    )
											model.eval()
											with torch.no_grad():
														lowerCAmelCase__ :    Any				      =			model(**self._prepare_for_class(SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__    )    )

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

											lowerCAmelCase__ :    List[str]				      =			outputs.attentions

											self.assertEqual(len(SCREAMING_SNAKE_CASE__    ) ,	SCREAMING_SNAKE_CASE__    )

											self.assertListEqual(
											    list(self_attentions[0].shape[-3:]    ) ,	[self.model_tester.num_heads[0], window_size_squared, window_size_squared] ,	)
					def lowercase_			(		self ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__    ):
								"""simple docstring"""







								lowerCAmelCase__ :    Tuple				      =			model_class(SCREAMING_SNAKE_CASE__    )
								model.to(SCREAMING_SNAKE_CASE__    )
								model.eval()

								with torch.no_grad():
											lowerCAmelCase__ :    List[str]				      =			model(**self._prepare_for_class(SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__    )    )

								lowerCAmelCase__ :    List[str]				      =			outputs.hidden_states

								lowerCAmelCase__ :    Optional[Any]				      =			getattr(
								    self.model_tester ,	'''expected_num_hidden_layers''' ,	len(self.model_tester.depths    ) + 1    )
								self.assertEqual(len(SCREAMING_SNAKE_CASE__    ) ,	SCREAMING_SNAKE_CASE__    )

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

								lowerCAmelCase__ :    Dict				      =			(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] ,	)

								lowerCAmelCase__ :    List[str]				      =			outputs.reshaped_hidden_states
								self.assertEqual(len(SCREAMING_SNAKE_CASE__    ) ,	SCREAMING_SNAKE_CASE__    )

								lowerCAmelCase__      ,				lowerCAmelCase__      ,				lowerCAmelCase__      ,				lowerCAmelCase__ :    List[str]				      =			reshaped_hidden_states[0].shape
								lowerCAmelCase__ :    Dict				      =			(
								    reshaped_hidden_states[0].view(SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	height * width    ).permute(0 ,	2 ,	1    )
								)
								self.assertListEqual(
								    list(reshaped_hidden_states.shape[-2:]    ) ,	[num_patches, self.model_tester.embed_dim] ,	)
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__      ,				lowerCAmelCase__ :    List[str]				      =			self.model_tester.prepare_config_and_inputs_for_common()

								lowerCAmelCase__ :    Optional[int]				      =			(
								    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:
											lowerCAmelCase__ :    Any				      =			True
											self.check_hidden_states_output(SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__    )

											# check that output_hidden_states also work using config
											del inputs_dict["output_hidden_states"]
											lowerCAmelCase__ :    Union[str, Any]				      =			True

											self.check_hidden_states_output(SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__    )
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__      ,				lowerCAmelCase__ :    Dict				      =			self.model_tester.prepare_config_and_inputs_for_common()
								lowerCAmelCase__ :    Union[str, Any]				      =			3

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

								lowerCAmelCase__ :    Optional[int]				      =			image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
								lowerCAmelCase__ :    Any				      =			image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

								for model_class in self.all_model_classes:
											lowerCAmelCase__ :    Tuple				      =			True
											self.check_hidden_states_output(SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	(padded_height, padded_width)    )

											# check that output_hidden_states also work using config
											del inputs_dict["output_hidden_states"]
											lowerCAmelCase__ :    Dict				      =			True
											self.check_hidden_states_output(SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	(padded_height, padded_width)    )
					@slow
					def lowercase_			(		self    ):
								"""simple docstring"""







								for model_name in DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											lowerCAmelCase__ :    Optional[Any]				      =			DonutSwinModel.from_pretrained(SCREAMING_SNAKE_CASE__    )
											self.assertIsNotNone(SCREAMING_SNAKE_CASE__    )
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__      ,				lowerCAmelCase__ :    Any				      =			self.model_tester.prepare_config_and_inputs_for_common()

								lowerCAmelCase__ :    Union[str, Any]				      =			_config_zero_init(SCREAMING_SNAKE_CASE__    )
								for model_class in self.all_model_classes:
											lowerCAmelCase__ :    Union[str, Any]				      =			model_class(config=SCREAMING_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''' ,	)



