
'''simple docstring'''





import gc
import os
import tempfile
import unittest

import torch
import torch.nn as nn
import torch.nn.functional as F
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, StableDiffusionPipeline, UNetaDConditionModel
from diffusers.loaders import AttnProcsLayers, LoraLoaderMixin
from diffusers.models.attention_processor import (
    Attention,
    AttnProcessor,
    AttnProcessor2_0,
    LoRAAttnProcessor,
    LoRAAttnProcessor2_0,
    LoRAXFormersAttnProcessor,
    XFormersAttnProcessor,
)
from diffusers.utils import TEXT_ENCODER_ATTN_MODULE, floats_tensor, torch_device





def     snake_case							(						UpperCAmelCase		)->     Tuple:







      """simple docstring"""
      __A    		=     {}
      for name in unet.attn_processors.keys():
            __A    		=     None if name.endswith('attn1.processor'		) else unet.config.cross_attention_dim
            if name.startswith('mid_block'		):
                  __A    		=     unet.config.block_out_channels[-1]
            elif name.startswith('up_blocks'		):
                  __A    		=     int(name[len('up_blocks.'		)]		)
                  __A    		=     list(reversed(unet.config.block_out_channels		)		)[block_id]
            elif name.startswith('down_blocks'		):
                  __A    		=     int(name[len('down_blocks.'		)]		)
                  __A    		=     unet.config.block_out_channels[block_id]
            __A    		=     (
                LoRAAttnProcessor2_0 if hasattr(_lowerCAmelCase ,					'scaled_dot_product_attention'		) else LoRAAttnProcessor
            )
            __A    		=     lora_attn_processor_class(
                hidden_size=_lowerCAmelCase ,					cross_attention_dim=_lowerCAmelCase		)
      __A    		=     AttnProcsLayers(_lowerCAmelCase		)
      return lora_attn_procs, unet_lora_layers





def     snake_case							(						UpperCAmelCase		)->     int:







      """simple docstring"""
      __A    		=     {}
      __A    		=     (
          LoRAAttnProcessor2_0 if hasattr(_lowerCAmelCase ,					'scaled_dot_product_attention'		) else LoRAAttnProcessor
      )
      for name, module in text_encoder.named_modules():
            if name.endswith(_lowerCAmelCase		):
                  __A    		=     lora_attn_processor_class(
                      hidden_size=module.out_proj.out_features ,					cross_attention_dim=_lowerCAmelCase		)
      return text_lora_attn_procs





def     snake_case							(						UpperCAmelCase		)->     Optional[Any]:







      """simple docstring"""
      __A    		=     create_text_encoder_lora_attn_procs(_lowerCAmelCase		)
      __A    		=     AttnProcsLayers(_lowerCAmelCase		)
      return text_encoder_lora_layers





def     snake_case							(						UpperCAmelCase ,					UpperCAmelCase=False		)->     int:







      """simple docstring"""
      for _, attn_proc in text_lora_attn_procs.items():
            # set up.weights
            for layer_name, layer_module in attn_proc.named_modules():
                  if layer_name.endswith('_lora'		):
                        __A    		=     (
                            torch.randn_like(layer_module.up.weight		)
                            if randn_weight
                            else torch.zeros_like(layer_module.up.weight		)
                        )
                        __A    		=     torch.nn.Parameter(_lowerCAmelCase		)


class 	UpperCamelCase__					(      unittest.TestCase):






 def 		lowercase_  (     self					:str     )			->     Dict:







       '''simple docstring'''



       torch.manual_seed(0     )
       __A    		=     UNetaDConditionModel(
           block_out_channels=(32, 64)		,			layers_per_block=2		,			sample_size=32		,			in_channels=4		,			out_channels=4		,			down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')		,			up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')		,			cross_attention_dim=32		,			)
       __A    		=     DDIMScheduler(
           beta_start=0.00_085		,			beta_end=0.012		,			beta_schedule='scaled_linear'		,			clip_sample=__snake_case		,			set_alpha_to_one=__snake_case		,			steps_offset=1		,			)
       torch.manual_seed(0     )
       __A    		=     AutoencoderKL(
           block_out_channels=[32, 64]		,			in_channels=3		,			out_channels=3		,			down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']		,			up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']		,			latent_channels=4		,			)
       __A    		=     CLIPTextConfig(
           bos_token_id=0		,			eos_token_id=2		,			hidden_size=32		,			intermediate_size=37		,			layer_norm_eps=1E-05		,			num_attention_heads=4		,			num_hidden_layers=5		,			pad_token_id=1		,			vocab_size=1_000		,			)
       __A    		=     CLIPTextModel(__snake_case     )
       __A    		=     CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'     )

       __A    		=     create_unet_lora_layers(__snake_case     )
       __A    		=     create_text_encoder_lora_layers(__snake_case     )

       __A    		=     {
           '''unet''': unet,
           '''scheduler''': scheduler,
           '''vae''': vae,
           '''text_encoder''': text_encoder,
           '''tokenizer''': tokenizer,
           '''safety_checker''': None,
           '''feature_extractor''': None,
       }
       __A    		=     {
           '''unet_lora_layers''': unet_lora_layers,
           '''text_encoder_lora_layers''': text_encoder_lora_layers,
           '''unet_lora_attn_procs''': unet_lora_attn_procs,
       }
       return pipeline_components, lora_components






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







       '''simple docstring'''



       __A    		=     1
       __A    		=     10
       __A    		=     4
       __A    		=     (32, 32)

       __A    		=     torch.manual_seed(0     )
       __A    		=     floats_tensor((batch_size, num_channels) + sizes     )
       __A    		=     torch.randint(1		,			__snake_case		,			size=(batch_size, sequence_length)		,			generator=__snake_case     )

       __A    		=     {
           '''prompt''': '''A painting of a squirrel eating a burger''',
           '''generator''': generator,
           '''num_inference_steps''': 2,
           '''guidance_scale''': 6.0,
           '''output_type''': '''numpy''',
       }

       return noise, input_ids, pipeline_inputs

       # copied from: https://colab.research.google.com/gist/sayakpaul/df2ef6e1ae6d8c10a49d859883b10860/scratchpad.ipynb






 def 		lowercase_  (     self					:str     )			->     Tuple:







       '''simple docstring'''



       __A    		=     77

       __A    		=     torch.randint(2		,			56		,			size=(1, max_seq_length)		,			generator=torch.manual_seed(0     )     )

       __A    		=     {}
       __A    		=     inputs
       return prepared_inputs






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







       '''simple docstring'''



       __A    		=     self.get_dummy_components()
       LoraLoaderMixin.save_lora_weights(
           save_directory=__snake_case		,			unet_lora_layers=lora_components['unet_lora_layers']		,			text_encoder_lora_layers=lora_components['text_encoder_lora_layers']		,			)
       self.assertTrue(os.path.isfile(os.path.join(__snake_case		,			'pytorch_lora_weights.bin'     )     )     )






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







       '''simple docstring'''



       __A    		=     self.get_dummy_components()
       __A    		=     StableDiffusionPipeline(**__snake_case     )
       __A    		=     sd_pipe.to(__snake_case     )
       sd_pipe.set_progress_bar_config(disable=__snake_case     )

       __A    		=     self.get_dummy_inputs()

       __A    		=     sd_pipe(**__snake_case     ).images
       __A    		=     original_images[0, -3:, -3:, -1]

       with tempfile.TemporaryDirectory() as tmpdirname:
             LoraLoaderMixin.save_lora_weights(
                 save_directory=__snake_case		,			unet_lora_layers=lora_components['unet_lora_layers']		,			text_encoder_lora_layers=lora_components['text_encoder_lora_layers']		,			)
             self.assertTrue(os.path.isfile(os.path.join(__snake_case		,			'pytorch_lora_weights.bin'     )     )     )
             sd_pipe.load_lora_weights(__snake_case     )

       __A    		=     sd_pipe(**__snake_case     ).images
       __A    		=     lora_images[0, -3:, -3:, -1]

       # Outputs shouldn't match.
       self.assertFalse(torch.allclose(torch.from_numpy(__snake_case     )		,			torch.from_numpy(__snake_case     )     )     )






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







       '''simple docstring'''



       __A    		=     self.get_dummy_components()
       __A    		=     StableDiffusionPipeline(**__snake_case     )
       __A    		=     sd_pipe.to(__snake_case     )
       sd_pipe.set_progress_bar_config(disable=__snake_case     )

       __A    		=     self.get_dummy_inputs()

       __A    		=     sd_pipe(**__snake_case     ).images
       __A    		=     original_images[0, -3:, -3:, -1]

       with tempfile.TemporaryDirectory() as tmpdirname:
             LoraLoaderMixin.save_lora_weights(
                 save_directory=__snake_case		,			unet_lora_layers=lora_components['unet_lora_layers']		,			text_encoder_lora_layers=lora_components['text_encoder_lora_layers']		,			safe_serialization=__snake_case		,			)
             self.assertTrue(os.path.isfile(os.path.join(__snake_case		,			'pytorch_lora_weights.safetensors'     )     )     )
             sd_pipe.load_lora_weights(__snake_case     )

       __A    		=     sd_pipe(**__snake_case     ).images
       __A    		=     lora_images[0, -3:, -3:, -1]

       # Outputs shouldn't match.
       self.assertFalse(torch.allclose(torch.from_numpy(__snake_case     )		,			torch.from_numpy(__snake_case     )     )     )






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







       '''simple docstring'''



       __A    		=     self.get_dummy_components()
       __A    		=     lora_components['''unet_lora_attn_procs''']
       __A    		=     StableDiffusionPipeline(**__snake_case     )
       __A    		=     sd_pipe.to(__snake_case     )
       sd_pipe.set_progress_bar_config(disable=__snake_case     )

       __A    		=     self.get_dummy_inputs()

       __A    		=     sd_pipe(**__snake_case     ).images
       __A    		=     original_images[0, -3:, -3:, -1]

       with tempfile.TemporaryDirectory() as tmpdirname:
             __A    		=     sd_pipe.unet
             unet.set_attn_processor(__snake_case     )
             unet.save_attn_procs(__snake_case     )
             self.assertTrue(os.path.isfile(os.path.join(__snake_case		,			'pytorch_lora_weights.bin'     )     )     )
             sd_pipe.load_lora_weights(__snake_case     )

       __A    		=     sd_pipe(**__snake_case     ).images
       __A    		=     lora_images[0, -3:, -3:, -1]

       # Outputs shouldn't match.
       self.assertFalse(torch.allclose(torch.from_numpy(__snake_case     )		,			torch.from_numpy(__snake_case     )     )     )






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







       '''simple docstring'''



       __A    		=     self.get_dummy_components()
       __A    		=     StableDiffusionPipeline(**__snake_case     )

       __A    		=     self.get_dummy_tokens()

       # inference without lora
       __A    		=     pipe.text_encoder(**__snake_case     )[0]
       assert outputs_without_lora.shape == (1, 77, 32)

       # create lora_attn_procs with zeroed out up.weights
       __A    		=     create_text_encoder_lora_attn_procs(pipe.text_encoder     )
       set_lora_up_weights(__snake_case		,			randn_weight=__snake_case     )

       # monkey patch
       pipe._modify_text_encoder(__snake_case     )

       # verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
       del text_attn_procs
       gc.collect()

       # inference with lora
       __A    		=     pipe.text_encoder(**__snake_case     )[0]
       assert outputs_with_lora.shape == (1, 77, 32)

       assert torch.allclose(
           __snake_case		,			__snake_case     ), "lora_up_weight are all zero, so the lora outputs should be the same to without lora outputs"

       # create lora_attn_procs with randn up.weights
       __A    		=     create_text_encoder_lora_attn_procs(pipe.text_encoder     )
       set_lora_up_weights(__snake_case		,			randn_weight=__snake_case     )

       # monkey patch
       pipe._modify_text_encoder(__snake_case     )

       # verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
       del text_attn_procs
       gc.collect()

       # inference with lora
       __A    		=     pipe.text_encoder(**__snake_case     )[0]
       assert outputs_with_lora.shape == (1, 77, 32)

       assert not torch.allclose(
           __snake_case		,			__snake_case     ), "lora_up_weight are not zero, so the lora outputs should be different to without lora outputs"






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







       '''simple docstring'''



       __A    		=     self.get_dummy_components()
       __A    		=     StableDiffusionPipeline(**__snake_case     )

       __A    		=     self.get_dummy_tokens()

       # inference without lora
       __A    		=     pipe.text_encoder(**__snake_case     )[0]
       assert outputs_without_lora.shape == (1, 77, 32)

       # create lora_attn_procs with randn up.weights
       __A    		=     create_text_encoder_lora_attn_procs(pipe.text_encoder     )
       set_lora_up_weights(__snake_case		,			randn_weight=__snake_case     )

       # monkey patch
       pipe._modify_text_encoder(__snake_case     )

       # verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
       del text_attn_procs
       gc.collect()

       # inference with lora
       __A    		=     pipe.text_encoder(**__snake_case     )[0]
       assert outputs_with_lora.shape == (1, 77, 32)

       assert not torch.allclose(
           __snake_case		,			__snake_case     ), "lora outputs should be different to without lora outputs"

       # remove monkey patch
       pipe._remove_text_encoder_monkey_patch()

       # inference with removed lora
       __A    		=     pipe.text_encoder(**__snake_case     )[0]
       assert outputs_without_lora_removed.shape == (1, 77, 32)

       assert torch.allclose(
           __snake_case		,			__snake_case     ), "remove lora monkey patch should restore the original outputs"






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







       '''simple docstring'''



       __A    		=     self.get_dummy_components()
       __A    		=     StableDiffusionPipeline(**__snake_case     )
       __A    		=     sd_pipe.to(__snake_case     )
       sd_pipe.set_progress_bar_config(disable=__snake_case     )

       __A    		=     self.get_dummy_inputs()

       with tempfile.TemporaryDirectory() as tmpdirname:
             LoraLoaderMixin.save_lora_weights(
                 save_directory=__snake_case		,			unet_lora_layers=lora_components['unet_lora_layers']		,			text_encoder_lora_layers=lora_components['text_encoder_lora_layers']		,			)
             self.assertTrue(os.path.isfile(os.path.join(__snake_case		,			'pytorch_lora_weights.bin'     )     )     )
             sd_pipe.load_lora_weights(__snake_case     )

       __A    		=     sd_pipe(**__snake_case     ).images
       __A    		=     lora_images[0, -3:, -3:, -1]

       __A    		=     sd_pipe(**__snake_case		,			cross_attention_kwargs={'scale': 0.5}     ).images
       __A    		=     lora_images_with_scale[0, -3:, -3:, -1]

       # Outputs shouldn't match.
       self.assertFalse(
           torch.allclose(torch.from_numpy(__snake_case     )		,			torch.from_numpy(__snake_case     )     )     )






 def 		lowercase_  (     self					:Tuple     )			->     Dict:







       '''simple docstring'''



       with tempfile.TemporaryDirectory() as tmpdirname:
             self.create_lora_weight_file(__snake_case     )

             __A    		=     self.get_dummy_components()
             __A    		=     StableDiffusionPipeline(**__snake_case     )
             __A    		=     sd_pipe.to(__snake_case     )
             sd_pipe.set_progress_bar_config(disable=__snake_case     )

             # check if vanilla attention processors are used
             for _, module in sd_pipe.unet.named_modules():
                   if isinstance(__snake_case		,			__snake_case     ):
                         self.assertIsInstance(module.processor		,			(AttnProcessor, AttnProcessor2_0)     )

            # load LoRA weight file
             sd_pipe.load_lora_weights(__snake_case     )

             # check if lora attention processors are used
             for _, module in sd_pipe.unet.named_modules():
                   if isinstance(__snake_case		,			__snake_case     ):
                         __A    		=     (
                             LoRAAttnProcessor2_0 if hasattr(__snake_case		,			'scaled_dot_product_attention'     ) else LoRAAttnProcessor
                         )
                         self.assertIsInstance(module.processor		,			__snake_case     )






 @unittest.skipIf(torch_device != 'cuda'		,			'This test is supposed to run on GPU'     )
 def 		lowercase_  (     self					:List[str]     )			->     Optional[Any]:







       '''simple docstring'''



       with tempfile.TemporaryDirectory() as tmpdirname:
             self.create_lora_weight_file(__snake_case     )

             __A    		=     self.get_dummy_components()
             __A    		=     StableDiffusionPipeline(**__snake_case     )
             __A    		=     sd_pipe.to(__snake_case     )
             sd_pipe.set_progress_bar_config(disable=__snake_case     )

             # enable XFormers
             sd_pipe.enable_xformers_memory_efficient_attention()

             # check if xFormers attention processors are used
             for _, module in sd_pipe.unet.named_modules():
                   if isinstance(__snake_case		,			__snake_case     ):
                         self.assertIsInstance(module.processor		,			__snake_case     )

            # load LoRA weight file
             sd_pipe.load_lora_weights(__snake_case     )

             # check if lora attention processors are used
             for _, module in sd_pipe.unet.named_modules():
                   if isinstance(__snake_case		,			__snake_case     ):
                         self.assertIsInstance(module.processor		,			__snake_case     )






 @unittest.skipIf(torch_device != 'cuda'		,			'This test is supposed to run on GPU'     )
 def 		lowercase_  (     self					:List[Any]     )			->     Any:







       '''simple docstring'''



       __A    		=     self.get_dummy_components()
       __A    		=     StableDiffusionPipeline(**__snake_case     )
       __A    		=     sd_pipe.to(__snake_case     )
       sd_pipe.set_progress_bar_config(disable=__snake_case     )

       __A    		=     self.get_dummy_inputs()

       # enable XFormers
       sd_pipe.enable_xformers_memory_efficient_attention()

       __A    		=     sd_pipe(**__snake_case     ).images
       __A    		=     original_images[0, -3:, -3:, -1]

       with tempfile.TemporaryDirectory() as tmpdirname:
             LoraLoaderMixin.save_lora_weights(
                 save_directory=__snake_case		,			unet_lora_layers=lora_components['unet_lora_layers']		,			text_encoder_lora_layers=lora_components['text_encoder_lora_layers']		,			)
             self.assertTrue(os.path.isfile(os.path.join(__snake_case		,			'pytorch_lora_weights.bin'     )     )     )
             sd_pipe.load_lora_weights(__snake_case     )

       __A    		=     sd_pipe(**__snake_case     ).images
       __A    		=     lora_images[0, -3:, -3:, -1]

       # Outputs shouldn't match.
       self.assertFalse(torch.allclose(torch.from_numpy(__snake_case     )		,			torch.from_numpy(__snake_case     )     )     )






'''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'		,			)






