code: 
  
  import unittest
  
  import numpy as np
  
  from transformers.testing_utils import require_torch, require_vision
  from transformers.utils import is_torch_available, is_vision_available
  
  from ...test_image_processing_common import ImageProcessingSavingTestMixin
  
  
  if is_torch_available():
         import torch
  
  if is_vision_available():
         from PIL import Image
  
         from transformers import CLIPImageProcessor
  class 					A_   (      unittest.TestCase						):
  
  
      '''simple docstring'''
  
  
  
  
  
  
      def __init__(self     ,      lowercase__     ,      lowercase__=7     ,      lowercase__=3     ,      lowercase__=18     ,      lowercase__=30     ,      lowercase__=400     ,      lowercase__=True     ,      lowercase__=None     ,      lowercase__=True     ,      lowercase__=None     ,      lowercase__=True     ,      lowercase__=[0.48145466, 0.4578275, 0.40821073]     ,      lowercase__=[0.26862954, 0.26130258, 0.27577711]     ,      lowercase__=True     ,      )     ->      Optional[int]:
          __UpperCAmelCase									=			size if size is not None else {'''shortest_edge''': 20}
          __UpperCAmelCase									=			crop_size if crop_size is not None else {'''height''': 18, '''width''': 18}
          __UpperCAmelCase									=			parent
          __UpperCAmelCase									=			batch_size
          __UpperCAmelCase									=			num_channels
          __UpperCAmelCase									=			image_size
          __UpperCAmelCase									=			min_resolution
          __UpperCAmelCase									=			max_resolution
          __UpperCAmelCase									=			do_resize
          __UpperCAmelCase									=			size
          __UpperCAmelCase									=			do_center_crop
          __UpperCAmelCase									=			crop_size
          __UpperCAmelCase									=			do_normalize
          __UpperCAmelCase									=			image_mean
          __UpperCAmelCase									=			image_std
          __UpperCAmelCase									=			do_convert_rgb
  
  
      def      lowerCAmelCase_						(self  )     ->      Optional[int]:
          return {
              "do_resize": self.do_resize,
              "size": self.size,
              "do_center_crop": self.do_center_crop,
              "crop_size": self.crop_size,
              "do_normalize": self.do_normalize,
              "image_mean": self.image_mean,
              "image_std": self.image_std,
              "do_convert_rgb": self.do_convert_rgb,
          }
  
  
  
  
  
  
      def      lowerCAmelCase_						(self     ,      lowercase__=False     ,      lowercase__=False     ,      lowercase__=False  )     ->      List[Any]:
          assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"
  
          if equal_resolution:
              __UpperCAmelCase									=			[]
              for i in range(self.batch_size  ):
                  image_inputs.append(
                      np.random.randint(
                          255     ,      size=(self.num_channels, self.max_resolution, self.max_resolution)     ,      dtype=np.uinta  )  )
          else:
              __UpperCAmelCase									=			[]
              for i in range(self.batch_size  ):
                  __UpperCAmelCase					,     __UpperCAmelCase									=			np.random.choice(np.arange(self.min_resolution     ,      self.max_resolution  )     ,      2  )
                  image_inputs.append(np.random.randint(255     ,      size=(self.num_channels, width, height)     ,      dtype=np.uinta  )  )
  
          if not numpify and not torchify:
              # PIL expects the channel dimension as last dimension
              __UpperCAmelCase									=			[Image.fromarray(np.moveaxis(lowercase__     ,      0     ,      -1  )  ) for x in image_inputs]
  
          if torchify:
              __UpperCAmelCase									=			[torch.from_numpy(lowercase__  ) for x in image_inputs]
  
          return image_inputs
  
  
  
  
  
  
  @require_torch
  @require_vision
  class 					A_   (      _a ,     unittest.TestCase						):
  
  
      '''simple docstring'''
  
  
  
  
  
  
      a__     							=       CLIPImageProcessor if is_vision_available() else None
  
  
      def      lowerCAmelCase_						(self  )     ->      str:
          __UpperCAmelCase									=			CLIPImageProcessingTester(self  )
  
  
      @property
      def      lowerCAmelCase_						(self  )     ->      Tuple:
          return self.image_processor_tester.prepare_image_processor_dict()
  
  
      def      lowerCAmelCase_						(self  )     ->      Union[str, Any]:
          __UpperCAmelCase									=			self.image_processing_class(**self.image_processor_dict  )
          self.assertTrue(hasattr(lowercase__     ,      '''do_resize'''  )  )
          self.assertTrue(hasattr(lowercase__     ,      '''size'''  )  )
          self.assertTrue(hasattr(lowercase__     ,      '''do_center_crop'''  )  )
          self.assertTrue(hasattr(lowercase__     ,      '''center_crop'''  )  )
          self.assertTrue(hasattr(lowercase__     ,      '''do_normalize'''  )  )
          self.assertTrue(hasattr(lowercase__     ,      '''image_mean'''  )  )
          self.assertTrue(hasattr(lowercase__     ,      '''image_std'''  )  )
          self.assertTrue(hasattr(lowercase__     ,      '''do_convert_rgb'''  )  )
  
  
      def      lowerCAmelCase_						(self  )     ->      str:
          __UpperCAmelCase									=			self.image_processing_class.from_dict(self.image_processor_dict  )
          self.assertEqual(image_processor.size     ,      {'''shortest_edge''': 20}  )
          self.assertEqual(image_processor.crop_size     ,      {'''height''': 18, '''width''': 18}  )
  
          __UpperCAmelCase									=			self.image_processing_class.from_dict(self.image_processor_dict     ,      size=42     ,      crop_size=84  )
          self.assertEqual(image_processor.size     ,      {'''shortest_edge''': 42}  )
          self.assertEqual(image_processor.crop_size     ,      {'''height''': 84, '''width''': 84}  )
  
  
      def      lowerCAmelCase_						(self  )     ->      Optional[Any]:
          pass
  
  
      def      lowerCAmelCase_						(self  )     ->      str:
          # Initialize image_processing
          __UpperCAmelCase									=			self.image_processing_class(**self.image_processor_dict  )
          # create random PIL images
          __UpperCAmelCase									=			self.image_processor_tester.prepare_inputs(equal_resolution=lowercase__  )
          for image in image_inputs:
              self.assertIsInstance(lowercase__     ,      Image.Image  )
  
          # Test not batched input
          __UpperCAmelCase									=			image_processing(image_inputs[0]     ,      return_tensors='''pt'''  ).pixel_values
          self.assertEqual(
              encoded_images.shape     ,      (
                  1,
                  self.image_processor_tester.num_channels,
                  self.image_processor_tester.crop_size['''height'''],
                  self.image_processor_tester.crop_size['''width'''],
              )     ,      )
  
          # Test batched
          __UpperCAmelCase									=			image_processing(lowercase__     ,      return_tensors='''pt'''  ).pixel_values
          self.assertEqual(
              encoded_images.shape     ,      (
                  self.image_processor_tester.batch_size,
                  self.image_processor_tester.num_channels,
                  self.image_processor_tester.crop_size['''height'''],
                  self.image_processor_tester.crop_size['''width'''],
              )     ,      )
  
  
      def      lowerCAmelCase_						(self  )     ->      str:
          # Initialize image_processing
          __UpperCAmelCase									=			self.image_processing_class(**self.image_processor_dict  )
          # create random numpy tensors
          __UpperCAmelCase									=			self.image_processor_tester.prepare_inputs(equal_resolution=lowercase__     ,      numpify=lowercase__  )
          for image in image_inputs:
              self.assertIsInstance(lowercase__     ,      np.ndarray  )
  
          # Test not batched input
          __UpperCAmelCase									=			image_processing(image_inputs[0]     ,      return_tensors='''pt'''  ).pixel_values
          self.assertEqual(
              encoded_images.shape     ,      (
                  1,
                  self.image_processor_tester.num_channels,
                  self.image_processor_tester.crop_size['''height'''],
                  self.image_processor_tester.crop_size['''width'''],
              )     ,      )
  
          # Test batched
          __UpperCAmelCase									=			image_processing(lowercase__     ,      return_tensors='''pt'''  ).pixel_values
          self.assertEqual(
              encoded_images.shape     ,      (
                  self.image_processor_tester.batch_size,
                  self.image_processor_tester.num_channels,
                  self.image_processor_tester.crop_size['''height'''],
                  self.image_processor_tester.crop_size['''width'''],
              )     ,      )
  
  
  
  
  
  
      def      lowerCAmelCase_						(self  )     ->      Any:
          # Initialize image_processing
          __UpperCAmelCase									=			self.image_processing_class(**self.image_processor_dict  )
          # create random PyTorch tensors
          __UpperCAmelCase									=			self.image_processor_tester.prepare_inputs(equal_resolution=lowercase__     ,      torchify=lowercase__  )
          for image in image_inputs:
              self.assertIsInstance(lowercase__     ,      torch.Tensor  )
  
          # Test not batched input
          __UpperCAmelCase									=			image_processing(image_inputs[0]     ,      return_tensors='''pt'''  ).pixel_values
          self.assertEqual(
              encoded_images.shape     ,      (
                  1,
                  self.image_processor_tester.num_channels,
                  self.image_processor_tester.crop_size['''height'''],
                  self.image_processor_tester.crop_size['''width'''],
              )     ,      )
  
          # Test batched
          __UpperCAmelCase									=			image_processing(lowercase__     ,      return_tensors='''pt'''  ).pixel_values
          self.assertEqual(
              encoded_images.shape     ,      (
                  self.image_processor_tester.batch_size,
                  self.image_processor_tester.num_channels,
                  self.image_processor_tester.crop_size['''height'''],
                  self.image_processor_tester.crop_size['''width'''],
              )     ,      )
  
  
  
  
  
  
  @require_torch
  @require_vision
  class 					A_   (      _a ,     unittest.TestCase						):
  
  
      '''simple docstring'''
  
  
  
  
  
  
      a__     							=       CLIPImageProcessor if is_vision_available() else None
  
  
      def      lowerCAmelCase_						(self  )     ->      int:
          __UpperCAmelCase									=			CLIPImageProcessingTester(self     ,      num_channels=4  )
          __UpperCAmelCase									=			3
  
  
      @property
      def      lowerCAmelCase_						(self  )     ->      List[Any]:
          return self.image_processor_tester.prepare_image_processor_dict()
  
  
      def      lowerCAmelCase_						(self  )     ->      Union[str, Any]:
          __UpperCAmelCase									=			self.image_processing_class(**self.image_processor_dict  )
          self.assertTrue(hasattr(lowercase__     ,      '''do_resize'''  )  )
          self.assertTrue(hasattr(lowercase__     ,      '''size'''  )  )
          self.assertTrue(hasattr(lowercase__     ,      '''do_center_crop'''  )  )
          self.assertTrue(hasattr(lowercase__     ,      '''center_crop'''  )  )
          self.assertTrue(hasattr(lowercase__     ,      '''do_normalize'''  )  )
          self.assertTrue(hasattr(lowercase__     ,      '''image_mean'''  )  )
          self.assertTrue(hasattr(lowercase__     ,      '''image_std'''  )  )
          self.assertTrue(hasattr(lowercase__     ,      '''do_convert_rgb'''  )  )
  
  
      def      lowerCAmelCase_						(self  )     ->      List[Any]:
          pass
  
  
  
  
  
  
      def      lowerCAmelCase_						(self  )     ->      Dict:
          # Initialize image_processing
          __UpperCAmelCase									=			self.image_processing_class(**self.image_processor_dict  )
          # create random PIL images
          __UpperCAmelCase									=			self.image_processor_tester.prepare_inputs(equal_resolution=lowercase__  )
          for image in image_inputs:
              self.assertIsInstance(lowercase__     ,      Image.Image  )
  
          # Test not batched input
          __UpperCAmelCase									=			image_processing(image_inputs[0]     ,      return_tensors='''pt'''  ).pixel_values
          self.assertEqual(
              encoded_images.shape     ,      (
                  1,
                  self.expected_encoded_image_num_channels,
                  self.image_processor_tester.crop_size['''height'''],
                  self.image_processor_tester.crop_size['''width'''],
              )     ,      )
  
          # Test batched
          __UpperCAmelCase									=			image_processing(lowercase__     ,      return_tensors='''pt'''  ).pixel_values
          self.assertEqual(
              encoded_images.shape     ,      (
                  self.image_processor_tester.batch_size,
                  self.expected_encoded_image_num_channels,
                  self.image_processor_tester.crop_size['''height'''],
                  self.image_processor_tester.crop_size['''width'''],
              )     ,      )
  
  
  
  
  
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'''     ,      )
  
  
  
  
  