code: 
  
  from dataclasses import dataclass
  from typing import Any, Dict, Optional
  
  import torch
  import torch.nn.functional as F
  from torch import nn
  
  from ..configuration_utils import ConfigMixin, register_to_config
  from ..models.embeddings import ImagePositionalEmbeddings
  from ..utils import BaseOutput, deprecate
  from .attention import BasicTransformerBlock
  from .embeddings import PatchEmbed
  from .modeling_utils import ModelMixin
  @dataclass
  class 					A_   (      UpperCamelCase__						):
  
  
      '''simple docstring'''
  
  
  
  
  
  
      a__     							=       42
  
  
  
  
  
  
  class 					A_   (      UpperCamelCase__ ,     UpperCamelCase__						):
  
  
      '''simple docstring'''
  
  
  
  
  
  
      @register_to_config
      def __init__(self     ,      lowercase__ = 16     ,      lowercase__ = 88     ,      lowercase__ = None     ,      lowercase__ = None     ,      lowercase__ = 1     ,      lowercase__ = 0.0     ,      lowercase__ = 32     ,      lowercase__ = None     ,      lowercase__ = False     ,      lowercase__ = None     ,      lowercase__ = None     ,      lowercase__ = None     ,      lowercase__ = "geglu"     ,      lowercase__ = None     ,      lowercase__ = False     ,      lowercase__ = False     ,      lowercase__ = False     ,      lowercase__ = "layer_norm"     ,      lowercase__ = True     ,      )     ->      Tuple:
          super().__init__()
          __UpperCAmelCase									=			use_linear_projection
          __UpperCAmelCase									=			num_attention_heads
          __UpperCAmelCase									=			attention_head_dim
          __UpperCAmelCase									=			num_attention_heads * attention_head_dim
  
          # 1. Transformer2DModel can process both standard continuous images of shape `(batch_size, num_channels, width, height)` as well as quantized image embeddings of shape `(batch_size, num_image_vectors)`
          # Define whether input is continuous or discrete depending on configuration
          __UpperCAmelCase									=			(in_channels is not None) and (patch_size is None)
          __UpperCAmelCase									=			num_vector_embeds is not None
          __UpperCAmelCase									=			in_channels is not None and patch_size is not None
  
          if norm_type == "layer_norm" and num_embeds_ada_norm is not None:
              __UpperCAmelCase									=			(
                  F'''The configuration file of this model: {self.__class__} is outdated. `norm_type` is either not set or'''
                  ''' incorrectly set to `\'layer_norm\'`.Make sure to set `norm_type` to `\'ada_norm\'` in the config.'''
                  ''' Please make sure to update the config accordingly as leaving `norm_type` might led to incorrect'''
                  ''' results in future versions. If you have downloaded this checkpoint from the Hugging Face Hub, it'''
                  ''' would be very nice if you could open a Pull request for the `transformer/config.json` file'''
              )
              deprecate('''norm_type!=num_embeds_ada_norm'''     ,      '''1.0.0'''     ,      snake_case_     ,      standard_warn=snake_case_  )
              __UpperCAmelCase									=			'''ada_norm'''
  
          if self.is_input_continuous and self.is_input_vectorized:
              raise ValueError(
                  F'''Cannot define both `in_channels`: {in_channels} and `num_vector_embeds`: {num_vector_embeds}. Make'''
                  ''' sure that either `in_channels` or `num_vector_embeds` is None.'''  )
          elif self.is_input_vectorized and self.is_input_patches:
              raise ValueError(
                  F'''Cannot define both `num_vector_embeds`: {num_vector_embeds} and `patch_size`: {patch_size}. Make'''
                  ''' sure that either `num_vector_embeds` or `num_patches` is None.'''  )
          elif not self.is_input_continuous and not self.is_input_vectorized and not self.is_input_patches:
              raise ValueError(
                  F'''Has to define `in_channels`: {in_channels}, `num_vector_embeds`: {num_vector_embeds}, or patch_size:'''
                  F''' {patch_size}. Make sure that `in_channels`, `num_vector_embeds` or `num_patches` is not None.'''  )
  
          # 2. Define input layers
          if self.is_input_continuous:
              __UpperCAmelCase									=			in_channels
  
              __UpperCAmelCase									=			torch.nn.GroupNorm(num_groups=snake_case_     ,      num_channels=snake_case_     ,      eps=1E-6     ,      affine=snake_case_  )
              if use_linear_projection:
                  __UpperCAmelCase									=			nn.Linear(snake_case_     ,      snake_case_  )
              else:
                  __UpperCAmelCase									=			nn.Convad(snake_case_     ,      snake_case_     ,      kernel_size=1     ,      stride=1     ,      padding=0  )
          elif self.is_input_vectorized:
              assert sample_size is not None, "Transformer2DModel over discrete input must provide sample_size"
              assert num_vector_embeds is not None, "Transformer2DModel over discrete input must provide num_embed"
  
              __UpperCAmelCase									=			sample_size
              __UpperCAmelCase									=			sample_size
              __UpperCAmelCase									=			num_vector_embeds
              __UpperCAmelCase									=			self.height * self.width
  
              __UpperCAmelCase									=			ImagePositionalEmbeddings(
                  num_embed=snake_case_     ,      embed_dim=snake_case_     ,      height=self.height     ,      width=self.width  )
          elif self.is_input_patches:
              assert sample_size is not None, "Transformer2DModel over patched input must provide sample_size"
  
              __UpperCAmelCase									=			sample_size
              __UpperCAmelCase									=			sample_size
  
              __UpperCAmelCase									=			patch_size
              __UpperCAmelCase									=			PatchEmbed(
                  height=snake_case_     ,      width=snake_case_     ,      patch_size=snake_case_     ,      in_channels=snake_case_     ,      embed_dim=snake_case_     ,      )
  
          # 3. Define transformers blocks
          __UpperCAmelCase									=			nn.ModuleList(
              [
                  BasicTransformerBlock(
                      snake_case_     ,      snake_case_     ,      snake_case_     ,      dropout=snake_case_     ,      cross_attention_dim=snake_case_     ,      activation_fn=snake_case_     ,      num_embeds_ada_norm=snake_case_     ,      attention_bias=snake_case_     ,      only_cross_attention=snake_case_     ,      upcast_attention=snake_case_     ,      norm_type=snake_case_     ,      norm_elementwise_affine=snake_case_     ,      )
                  for d in range(snake_case_  )
              ]  )
  
          # 4. Define output layers
          __UpperCAmelCase									=			in_channels if out_channels is None else out_channels
          if self.is_input_continuous:
              # TODO: should use out_channels for continuous projections
              if use_linear_projection:
                  __UpperCAmelCase									=			nn.Linear(snake_case_     ,      snake_case_  )
              else:
                  __UpperCAmelCase									=			nn.Convad(snake_case_     ,      snake_case_     ,      kernel_size=1     ,      stride=1     ,      padding=0  )
          elif self.is_input_vectorized:
              __UpperCAmelCase									=			nn.LayerNorm(snake_case_  )
              __UpperCAmelCase									=			nn.Linear(snake_case_     ,      self.num_vector_embeds - 1  )
          elif self.is_input_patches:
              __UpperCAmelCase									=			nn.LayerNorm(snake_case_     ,      elementwise_affine=snake_case_     ,      eps=1E-6  )
              __UpperCAmelCase									=			nn.Linear(snake_case_     ,      2 * inner_dim  )
              __UpperCAmelCase									=			nn.Linear(snake_case_     ,      patch_size * patch_size * self.out_channels  )
  
  
  
  
  
  
      def      lowerCAmelCase_						(self     ,      lowercase__     ,      lowercase__ = None     ,      lowercase__ = None     ,      lowercase__ = None     ,      lowercase__ = None     ,      lowercase__ = None     ,      lowercase__ = None     ,      lowercase__ = True     ,      )     ->      Tuple:
          # ensure attention_mask is a bias, and give it a singleton query_tokens dimension.
          #   we may have done this conversion already, e.g. if we came here via UNet2DConditionModel#forward.
          #   we can tell by counting dims; if ndim == 2: it's a mask rather than a bias.
          # expects mask of shape:
          #   [batch, key_tokens]
          # adds singleton query_tokens dimension:
          #   [batch,                    1, key_tokens]
          # this helps to broadcast it as a bias over attention scores, which will be in one of the following shapes:
          #   [batch,  heads, query_tokens, key_tokens] (e.g. torch sdp attn)
          #   [batch * heads, query_tokens, key_tokens] (e.g. xformers or classic attn)
          if attention_mask is not None and attention_mask.ndim == 2:
              # assume that mask is expressed as:
              #   (1 = keep,      0 = discard)
              # convert mask into a bias that can be added to attention scores:
              #       (keep = +0,     discard = -10000.0)
              __UpperCAmelCase									=			(1 - attention_mask.to(hidden_states.dtype  )) * -10_000.0
              __UpperCAmelCase									=			attention_mask.unsqueeze(1  )
  
          # convert encoder_attention_mask to a bias the same way we do for attention_mask
          if encoder_attention_mask is not None and encoder_attention_mask.ndim == 2:
              __UpperCAmelCase									=			(1 - encoder_attention_mask.to(hidden_states.dtype  )) * -10_000.0
              __UpperCAmelCase									=			encoder_attention_mask.unsqueeze(1  )
  
          # 1. Input
          if self.is_input_continuous:
              __UpperCAmelCase									=			hidden_states.shape
              __UpperCAmelCase									=			hidden_states
  
              __UpperCAmelCase									=			self.norm(snake_case_  )
              if not self.use_linear_projection:
                  __UpperCAmelCase									=			self.proj_in(snake_case_  )
                  __UpperCAmelCase									=			hidden_states.shape[1]
                  __UpperCAmelCase									=			hidden_states.permute(0     ,      2     ,      3     ,      1  ).reshape(snake_case_     ,      height * width     ,      snake_case_  )
              else:
                  __UpperCAmelCase									=			hidden_states.shape[1]
                  __UpperCAmelCase									=			hidden_states.permute(0     ,      2     ,      3     ,      1  ).reshape(snake_case_     ,      height * width     ,      snake_case_  )
                  __UpperCAmelCase									=			self.proj_in(snake_case_  )
          elif self.is_input_vectorized:
              __UpperCAmelCase									=			self.latent_image_embedding(snake_case_  )
          elif self.is_input_patches:
              __UpperCAmelCase									=			self.pos_embed(snake_case_  )
  
          # 2. Blocks
          for block in self.transformer_blocks:
              __UpperCAmelCase									=			block(
                  snake_case_     ,      attention_mask=snake_case_     ,      encoder_hidden_states=snake_case_     ,      encoder_attention_mask=snake_case_     ,      timestep=snake_case_     ,      cross_attention_kwargs=snake_case_     ,      class_labels=snake_case_     ,      )
  
          # 3. Output
          if self.is_input_continuous:
              if not self.use_linear_projection:
                  __UpperCAmelCase									=			hidden_states.reshape(snake_case_     ,      snake_case_     ,      snake_case_     ,      snake_case_  ).permute(0     ,      3     ,      1     ,      2  ).contiguous()
                  __UpperCAmelCase									=			self.proj_out(snake_case_  )
              else:
                  __UpperCAmelCase									=			self.proj_out(snake_case_  )
                  __UpperCAmelCase									=			hidden_states.reshape(snake_case_     ,      snake_case_     ,      snake_case_     ,      snake_case_  ).permute(0     ,      3     ,      1     ,      2  ).contiguous()
  
              __UpperCAmelCase									=			hidden_states + residual
          elif self.is_input_vectorized:
              __UpperCAmelCase									=			self.norm_out(snake_case_  )
              __UpperCAmelCase									=			self.out(snake_case_  )
              # (batch, self.num_vector_embeds - 1, self.num_latent_pixels)
              __UpperCAmelCase									=			logits.permute(0     ,      2     ,      1  )
  
              # log(p(x_0))
              __UpperCAmelCase									=			F.log_softmax(logits.double()     ,      dim=1  ).float()
          elif self.is_input_patches:
              # TODO: cleanup!
              __UpperCAmelCase									=			self.transformer_blocks[0].norma.emb(
                  snake_case_     ,      snake_case_     ,      hidden_dtype=hidden_states.dtype  )
              __UpperCAmelCase									=			self.proj_out_a(F.silu(snake_case_  )  ).chunk(2     ,      dim=1  )
              __UpperCAmelCase									=			self.norm_out(snake_case_  ) * (1 + scale[:, None]) + shift[:, None]
              __UpperCAmelCase									=			self.proj_out_a(snake_case_  )
  
              # unpatchify
              __UpperCAmelCase									=			int(hidden_states.shape[1] ** 0.5  )
              __UpperCAmelCase									=			hidden_states.reshape(
                  shape=(-1, height, width, self.patch_size, self.patch_size, self.out_channels)  )
              __UpperCAmelCase									=			torch.einsum('''nhwpqc->nchpwq'''     ,      snake_case_  )
              __UpperCAmelCase									=			hidden_states.reshape(
                  shape=(-1, self.out_channels, height * self.patch_size, width * self.patch_size)  )
  
          if not return_dict:
              return (output,)
  
          return TransformeraDModelOutput(sample=snake_case_  )
  
  
  
  
  
style_context: 
  
  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 					A_   :
  
  
      '''simple docstring'''
  
  
  
  
  
  
      def __init__(self     ,      lowercase__     ,      lowercase__=13     ,      lowercase__=32     ,      lowercase__=2     ,      lowercase__=3     ,      lowercase__=16     ,      lowercase__=[1, 2, 1]     ,      lowercase__=[2, 2, 4]     ,      lowercase__=2     ,      lowercase__=2.0     ,      lowercase__=True     ,      lowercase__=0.0     ,      lowercase__=0.0     ,      lowercase__=0.1     ,      lowercase__="gelu"     ,      lowercase__=False     ,      lowercase__=True     ,      lowercase__=0.02     ,      lowercase__=1E-5     ,      lowercase__=True     ,      lowercase__=None     ,      lowercase__=True     ,      lowercase__=10     ,      lowercase__=8     ,      )     ->      str:
          __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      lowerCAmelCase_						(self  )     ->      Any:
          __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      lowerCAmelCase_						(self  )     ->      Tuple:
          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      lowerCAmelCase_						(self     ,      lowercase__     ,      lowercase__     ,      lowercase__  )     ->      List[str]:
          __UpperCAmelCase									=			DonutSwinModel(config=lowercase__  )
          model.to(lowercase__  )
          model.eval()
          __UpperCAmelCase									=			model(lowercase__  )
  
          __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      lowerCAmelCase_						(self  )     ->      str:
          __UpperCAmelCase									=			self.prepare_config_and_inputs()
          (
              (
              __UpperCAmelCase
          )					,     (
              __UpperCAmelCase
          )					,     (
              __UpperCAmelCase
          )					,     
          )									=			config_and_inputs
          __UpperCAmelCase									=			{'''pixel_values''': pixel_values}
          return config, inputs_dict
  
  
  
  
  
  
  @require_torch
  class 					A_   (      _a ,     _a ,     unittest.TestCase						):
  
  
      '''simple docstring'''
  
  
  
  
  
  
      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      lowerCAmelCase_						(self  )     ->      Optional[Any]:
          __UpperCAmelCase									=			DonutSwinModelTester(self  )
          __UpperCAmelCase									=			ConfigTester(self     ,      config_class=lowercase__     ,      embed_dim=37  )
  
  
      def      lowerCAmelCase_						(self  )     ->      Union[str, Any]:
          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      lowerCAmelCase_						(self  )     ->      Optional[int]:
          return
  
  
      def      lowerCAmelCase_						(self  )     ->      Union[str, Any]:
          __UpperCAmelCase									=			self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*lowercase__  )
  
  
      def      lowerCAmelCase_						(self  )     ->      List[Any]:
          # DonutSwin does not use inputs_embeds
          pass
  
  
      def      lowerCAmelCase_						(self  )     ->      Union[str, Any]:
          __UpperCAmelCase					,     __UpperCAmelCase									=			self.model_tester.prepare_config_and_inputs_for_common()
  
          for model_class in self.all_model_classes:
              __UpperCAmelCase									=			model_class(lowercase__  )
              self.assertIsInstance(model.get_input_embeddings()     ,      (nn.Module)  )
              __UpperCAmelCase									=			model.get_output_embeddings()
              self.assertTrue(x is None or isinstance(lowercase__     ,      nn.Linear  )  )
  
  
      def      lowerCAmelCase_						(self  )     ->      Tuple:
          __UpperCAmelCase					,     __UpperCAmelCase									=			self.model_tester.prepare_config_and_inputs_for_common()
  
          for model_class in self.all_model_classes:
              __UpperCAmelCase									=			model_class(lowercase__  )
              __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]     ,      lowercase__  )
  
  
      def      lowerCAmelCase_						(self  )     ->      Optional[Any]:
          __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(lowercase__  )
              model.to(lowercase__  )
              model.eval()
              with torch.no_grad():
                  __UpperCAmelCase									=			model(**self._prepare_for_class(lowercase__     ,      lowercase__  )  )
              __UpperCAmelCase									=			outputs.attentions
              __UpperCAmelCase									=			len(self.model_tester.depths  )
              self.assertEqual(len(lowercase__  )     ,      lowercase__  )
  
              # check that output_attentions also work using config
              del inputs_dict["output_attentions"]
              __UpperCAmelCase									=			True
              __UpperCAmelCase									=			config.window_size**2
              __UpperCAmelCase									=			model_class(lowercase__  )
              model.to(lowercase__  )
              model.eval()
              with torch.no_grad():
                  __UpperCAmelCase									=			model(**self._prepare_for_class(lowercase__     ,      lowercase__  )  )
              __UpperCAmelCase									=			outputs.attentions
              self.assertEqual(len(lowercase__  )     ,      lowercase__  )
  
              self.assertListEqual(
                  list(attentions[0].shape[-3:]  )     ,      [self.model_tester.num_heads[0], window_size_squared, window_size_squared]     ,      )
              __UpperCAmelCase									=			len(lowercase__  )
  
              # Check attention is always last and order is fine
              __UpperCAmelCase									=			True
              __UpperCAmelCase									=			True
              __UpperCAmelCase									=			model_class(lowercase__  )
              model.to(lowercase__  )
              model.eval()
              with torch.no_grad():
                  __UpperCAmelCase									=			model(**self._prepare_for_class(lowercase__     ,      lowercase__  )  )
  
              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(lowercase__  )  )
  
              __UpperCAmelCase									=			outputs.attentions
  
              self.assertEqual(len(lowercase__  )     ,      lowercase__  )
  
              self.assertListEqual(
                  list(self_attentions[0].shape[-3:]  )     ,      [self.model_tester.num_heads[0], window_size_squared, window_size_squared]     ,      )
  
  
      def      lowerCAmelCase_						(self     ,      lowercase__     ,      lowercase__     ,      lowercase__     ,      lowercase__  )     ->      List[str]:
          __UpperCAmelCase									=			model_class(lowercase__  )
          model.to(lowercase__  )
          model.eval()
  
          with torch.no_grad():
              __UpperCAmelCase									=			model(**self._prepare_for_class(lowercase__     ,      lowercase__  )  )
  
          __UpperCAmelCase									=			outputs.hidden_states
  
          __UpperCAmelCase									=			getattr(
              self.model_tester     ,      '''expected_num_hidden_layers'''     ,      len(self.model_tester.depths  ) + 1  )
          self.assertEqual(len(lowercase__  )     ,      lowercase__  )
  
          # 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(lowercase__  )     ,      lowercase__  )
  
          __UpperCAmelCase					,     __UpperCAmelCase					,     __UpperCAmelCase					,     __UpperCAmelCase									=			reshaped_hidden_states[0].shape
          __UpperCAmelCase									=			(
              reshaped_hidden_states[0].view(lowercase__     ,      lowercase__     ,      height * width  ).permute(0     ,      2     ,      1  )
          )
          self.assertListEqual(
              list(reshaped_hidden_states.shape[-2:]  )     ,      [num_patches, self.model_tester.embed_dim]     ,      )
  
  
      def      lowerCAmelCase_						(self  )     ->      Any:
          __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(lowercase__     ,      lowercase__     ,      lowercase__     ,      lowercase__  )
  
              # check that output_hidden_states also work using config
              del inputs_dict["output_hidden_states"]
              __UpperCAmelCase									=			True
  
              self.check_hidden_states_output(lowercase__     ,      lowercase__     ,      lowercase__     ,      lowercase__  )
  
  
      def      lowerCAmelCase_						(self  )     ->      int:
          __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(lowercase__     ,      lowercase__     ,      lowercase__     ,      (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(lowercase__     ,      lowercase__     ,      lowercase__     ,      (padded_height, padded_width)  )
  
  
      @slow
      def      lowerCAmelCase_						(self  )     ->      Tuple:
          for model_name in DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              __UpperCAmelCase									=			DonutSwinModel.from_pretrained(lowercase__  )
              self.assertIsNotNone(lowercase__  )
  
  
  
  
  
  
      def      lowerCAmelCase_						(self  )     ->      Tuple:
          __UpperCAmelCase					,     __UpperCAmelCase									=			self.model_tester.prepare_config_and_inputs_for_common()
  
          __UpperCAmelCase									=			_config_zero_init(lowercase__  )
          for model_class in self.all_model_classes:
              __UpperCAmelCase									=			model_class(config=lowercase__  )
              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'''     ,      )
  
  
  
  
  