




'''simple docstring'''





import timeit
from typing import Callable, Optional

from ..configuration_utils import PretrainedConfig
from ..models.auto.modeling_auto import MODEL_MAPPING, MODEL_WITH_LM_HEAD_MAPPING
from ..utils import is_pyanvml_available, is_torch_available, logging
from .benchmark_utils import (
    Benchmark,
    Memory,
    MemorySummary,
    measure_peak_memory_cpu,
    start_memory_tracing,
    stop_memory_tracing,
)


if is_torch_available():
  import torch

  from .benchmark_args import PyTorchBenchmarkArguments


if is_pyanvml_available():
  import pyanvml.pyanvml as nvml


a		:	int       =      logging.get_logger(__name__)




class      UpperCamelCase       (	snake_case__       ):
  a     :PyTorchBenchmarkArguments
  a     :PretrainedConfig
  a     :str          =					"PyTorch"



  @property
  def     a_							(			self ):







      '''simple docstring'''


      return torch.__version__



  def     a_							(			self		,     __lowerCAmelCase		,     __lowerCAmelCase		,     __lowerCAmelCase ):







      '''simple docstring'''


      _a				:							Optional[int]							       =      self._prepare_inference_func(__lowerCAmelCase		,     __lowerCAmelCase		,     __lowerCAmelCase )
      return self._measure_speed(_inference )



  def     a_							(			self		,     __lowerCAmelCase		,     __lowerCAmelCase		,     __lowerCAmelCase ):







      '''simple docstring'''


      _a				:							List[str]							       =      self._prepare_inference_func(__lowerCAmelCase		,     __lowerCAmelCase		,     __lowerCAmelCase )
      return self._measure_memory(_inference )



  def     a_							(			self		,     __lowerCAmelCase		,     __lowerCAmelCase		,     __lowerCAmelCase ):







      '''simple docstring'''


      _a				:							List[Any]							       =      self._prepare_train_func(__lowerCAmelCase		,     __lowerCAmelCase		,     __lowerCAmelCase )
      return self._measure_speed(_train )



  def     a_							(			self		,     __lowerCAmelCase		,     __lowerCAmelCase		,     __lowerCAmelCase ):







      '''simple docstring'''


      _a				:							Any							       =      self._prepare_train_func(__lowerCAmelCase		,     __lowerCAmelCase		,     __lowerCAmelCase )
      return self._measure_memory(_train )



  def     a_							(			self		,     __lowerCAmelCase		,     __lowerCAmelCase		,     __lowerCAmelCase ):







      '''simple docstring'''


      _a				:							Tuple							       =      self.config_dict[model_name]

      if self.args.torchscript:
          _a				:							Any							       =      True

      _a				:							Any							       =      (
          hasattr(__lowerCAmelCase		,     """architectures""" )
          and isinstance(config.architectures		,     __lowerCAmelCase )
          and len(config.architectures ) > 0
      )
      if not self.args.only_pretrain_model and has_model_class_in_config:
          try:
              _a				:							Optional[int]							       =      config.architectures[0]
              _a				:							str							       =      __import__("""transformers"""		,     fromlist=[model_class] )
              _a				:							str							       =      getattr(__lowerCAmelCase		,     __lowerCAmelCase )
              _a				:							List[Any]							       =      model_cls(__lowerCAmelCase )
          except ImportError:
              raise ImportError(
                  f'''{model_class} does not exist. If you just want to test the pretrained model, you might want to'''
                  """ set `--only_pretrain_model` or `args.only_pretrain_model=True`.""" )
      else:
          _a				:							List[str]							       =      MODEL_MAPPING[config.__class__](__lowerCAmelCase )

      model.eval()
      model.to(self.args.device )

      # encoder-decoder has vocab size saved differently
      _a				:							str							       =      config.vocab_size if hasattr(__lowerCAmelCase		,     """vocab_size""" ) else config.encoder.vocab_size
      _a				:							int							       =      torch.randint(__lowerCAmelCase		,     (batch_size, sequence_length)		,     dtype=torch.long		,     device=self.args.device )

      if self.args.fpaa:
          logger.info("""Running training in Mixed Precision...""" )
          if not self.args.is_gpu:
              raise ValueError("""Mixed precision is possible only for GPU.""" )
          # amp seems to have memory leaks so that memory usage
          # is measured using .half() for now https://github.com/NVIDIA/apex/issues/439
          model.half()

      if self.args.torchscript:
          with torch.no_grad():
              _a				:							str							       =      torch.jit.trace(__lowerCAmelCase		,     __lowerCAmelCase )
      else:
          _a				:							Tuple							       =      model

      def encoder_decoder_forward():
          with torch.no_grad():
              _a				:							Tuple							       =      inference_model(__lowerCAmelCase		,     decoder_input_ids=__lowerCAmelCase )
          return outputs

      def encoder_forward():
          with torch.no_grad():
              _a				:							Union[str, Any]							       =      inference_model(__lowerCAmelCase )
          return outputs

      _a				:							Union[str, Any]							       =      encoder_decoder_forward if config.is_encoder_decoder else encoder_forward
      return _forward



  def     a_							(			self		,     __lowerCAmelCase		,     __lowerCAmelCase		,     __lowerCAmelCase ):







      '''simple docstring'''


      _a				:							int							       =      self.config_dict[model_name]

      _a				:							List[str]							       =      (
          hasattr(__lowerCAmelCase		,     """architectures""" )
          and isinstance(config.architectures		,     __lowerCAmelCase )
          and len(config.architectures ) > 0
      )
      if not self.args.only_pretrain_model and has_model_class_in_config:
          try:
              _a				:							Dict							       =      config.architectures[0]
              _a				:							Optional[Any]							       =      __import__("""transformers"""		,     fromlist=[model_class] )
              _a				:							int							       =      getattr(__lowerCAmelCase		,     __lowerCAmelCase )
              _a				:							List[str]							       =      model_cls(__lowerCAmelCase )
          except ImportError:
              raise ImportError(
                  f'''{model_class} does not exist. If you just want to test the pretrained model, you might want to'''
                  """ set `--only_pretrain_model` or `args.only_pretrain_model=True`.""" )
      else:
          _a				:							Any							       =      MODEL_WITH_LM_HEAD_MAPPING[config.__class__](__lowerCAmelCase )

      if self.args.torchscript:
          raise NotImplementedError("""Training for torchscript is currently not implemented""" )
      else:
          _a				:							Tuple							       =      model

      model.train()
      model.to(self.args.device )

      # encoder-decoder has vocab size saved differently
      _a				:							Dict							       =      config.vocab_size if hasattr(__lowerCAmelCase		,     """vocab_size""" ) else config.encoder.vocab_size
      _a				:							Tuple							       =      torch.randint(__lowerCAmelCase		,     (batch_size, sequence_length)		,     dtype=torch.long		,     device=self.args.device )

      if self.args.fpaa:
          logger.info("""Running training in Mixed Precision...""" )
          if not self.args.is_gpu:
              raise ValueError("""Mixed precision is possible only for GPU.""" )

          # amp seems to have memory leaks so that memory usage
          # is measured using .half() for now https://github.com/NVIDIA/apex/issues/439
          model.half()

      def compute_loss_and_backprob_encoder():
          _a				:							int							       =      train_model(__lowerCAmelCase		,     labels=__lowerCAmelCase )[0]
          loss.backward()
          return loss

      def compute_loss_and_backprob_encoder_decoder():
          _a				:							str							       =      train_model(__lowerCAmelCase		,     decoder_input_ids=__lowerCAmelCase		,     labels=__lowerCAmelCase )[0]
          loss.backward()
          return loss

      _a				:							Any							       =      (
          compute_loss_and_backprob_encoder_decoder
          if config.is_encoder_decoder
          else compute_loss_and_backprob_encoder
      )
      return _train



  def     a_							(			self		,     __lowerCAmelCase ):







      '''simple docstring'''


      try:
          if self.args.is_tpu or self.args.torchscript:
              # run additional 10 times to stabilize compilation for tpu and torchscript
              logger.info("""Do inference on TPU or torchscript. Running model 5 times to stabilize compilation""" )
              timeit.repeat(
                  __lowerCAmelCase		,     repeat=1		,     number=5		,     )

          # as written in https://docs.python.org/2/library/timeit.html#timeit.Timer.repeat, min should be taken rather than the average
          _a				:							List[str]							       =      timeit.repeat(
              __lowerCAmelCase		,     repeat=self.args.repeat		,     number=10		,     )

          if self.args.is_tpu and self.args.torch_xla_tpu_print_metrics:
              import torch_xla.debug.metrics as met

              self.print_fn(met.metrics_report() )

          return min(__lowerCAmelCase ) / 10.0
      except RuntimeError as e:
          self.print_fn(f'''Doesn\'t fit on GPU. {e}''' )
          return "N/A"



  def     a_							(			self		,     __lowerCAmelCase ):







      '''simple docstring'''


      try:
          if self.args.trace_memory_line_by_line:
              _a				:							Any							       =      start_memory_tracing("""transformers""" )

          if self.args.is_tpu:
              # tpu
              raise NotImplementedError(
                  """Memory Benchmarking is currently not implemented for TPU. Please disable memory benchmarking with"""
                  """ `--no-memory` or `args.memory=False`""" )
          elif self.args.is_gpu:
              if not is_pyanvml_available():
                  logger.warning(
                      """py3nvml not installed, we won't log GPU memory usage. """
                      """Install py3nvml (pip install py3nvml) to log information about GPU.""" )
                  _a				:							Tuple							       =      """N/A"""
              else:
                  logger.info(
                      """Measuring total GPU usage on GPU device. Make sure to not have additional processes running"""
                      """ on the same GPU.""" )
                  # init nvml
                  nvml.nvmlInit()
                  func()
                  _a				:							Optional[Any]							       =      nvml.nvmlDeviceGetHandleByIndex(self.args.device_idx )
                  _a				:							str							       =      nvml.nvmlDeviceGetMemoryInfo(__lowerCAmelCase )
                  _a				:							Any							       =      meminfo.used
                  _a				:							str							       =      Memory(__lowerCAmelCase )
                  # shutdown nvml
                  nvml.nvmlShutdown()
          else:
              # cpu
              _a				:							Tuple							       =      measure_peak_memory_cpu(__lowerCAmelCase )
              _a				:							str							       =      Memory(__lowerCAmelCase ) if isinstance(__lowerCAmelCase		,     __lowerCAmelCase ) else memory_bytes

          if self.args.trace_memory_line_by_line:
              _a				:							str							       =      stop_memory_tracing(__lowerCAmelCase )
          else:
              _a				:							List[str]							       =      None

          return memory, summary
      except RuntimeError as e:
          self.print_fn(f'''Doesn\'t fit on GPU. {e}''' )
          return "N/A", None









import collections
import inspect
import unittest

from transformers import DonutSwinConfig
from transformers.testing_utils import require_torch, slow, torch_device
from transformers.utils import is_torch_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
      import torch
      from torch import nn

      from transformers import DonutSwinModel
      from transformers.models.donut.modeling_donut_swin import DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST





class   lowercase__     :







  def __init__(						self     ,    _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     ,    ):
       lowerCAmelCase_       :							List[str]			 =		parent
       lowerCAmelCase_       :							int			 =		batch_size
       lowerCAmelCase_       :							str			 =		image_size
       lowerCAmelCase_       :							Any			 =		patch_size
       lowerCAmelCase_       :							Dict			 =		num_channels
       lowerCAmelCase_       :							str			 =		embed_dim
       lowerCAmelCase_       :							Tuple			 =		depths
       lowerCAmelCase_       :							int			 =		num_heads
       lowerCAmelCase_       :							str			 =		window_size
       lowerCAmelCase_       :							str			 =		mlp_ratio
       lowerCAmelCase_       :							List[Any]			 =		qkv_bias
       lowerCAmelCase_       :							Tuple			 =		hidden_dropout_prob
       lowerCAmelCase_       :							int			 =		attention_probs_dropout_prob
       lowerCAmelCase_       :							Union[str, Any]			 =		drop_path_rate
       lowerCAmelCase_       :							List[str]			 =		hidden_act
       lowerCAmelCase_       :							str			 =		use_absolute_embeddings
       lowerCAmelCase_       :							Union[str, Any]			 =		patch_norm
       lowerCAmelCase_       :							Tuple			 =		layer_norm_eps
       lowerCAmelCase_       :							Optional[Any]			 =		initializer_range
       lowerCAmelCase_       :							Optional[int]			 =		is_training
       lowerCAmelCase_       :							Optional[int]			 =		scope
       lowerCAmelCase_       :							Any			 =		use_labels
       lowerCAmelCase_       :							Dict			 =		type_sequence_label_size
       lowerCAmelCase_       :							str			 =		encoder_stride







  def 						UpperCAmelCase__		(						self    ):
       lowerCAmelCase_       :							Any			 =		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )

       lowerCAmelCase_       :							str			 =		None
       if self.use_labels:
            lowerCAmelCase_       :							Dict			 =		ids_tensor([self.batch_size]     ,    self.type_sequence_label_size    )

       lowerCAmelCase_       :							List[Any]			 =		self.get_config()

       return config, pixel_values, labels







  def 						UpperCAmelCase__		(						self    ):
       return DonutSwinConfig(
           image_size=self.image_size     ,    patch_size=self.patch_size     ,    num_channels=self.num_channels     ,    embed_dim=self.embed_dim     ,    depths=self.depths     ,    num_heads=self.num_heads     ,    window_size=self.window_size     ,    mlp_ratio=self.mlp_ratio     ,    qkv_bias=self.qkv_bias     ,    hidden_dropout_prob=self.hidden_dropout_prob     ,    attention_probs_dropout_prob=self.attention_probs_dropout_prob     ,    drop_path_rate=self.drop_path_rate     ,    hidden_act=self.hidden_act     ,    use_absolute_embeddings=self.use_absolute_embeddings     ,    path_norm=self.patch_norm     ,    layer_norm_eps=self.layer_norm_eps     ,    initializer_range=self.initializer_range     ,    encoder_stride=self.encoder_stride     ,    )







  def 						UpperCAmelCase__		(						self     ,    _lowercase     ,    _lowercase     ,    _lowercase    ):
       lowerCAmelCase_       :							Optional[Any]			 =		DonutSwinModel(config=_lowercase    )
       model.to(_lowercase    )
       model.eval()
       lowerCAmelCase_       :							Optional[Any]			 =		model(_lowercase    )

       lowerCAmelCase_       :							Optional[int]			 =		((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths    ) - 1))
       lowerCAmelCase_       :							Tuple			 =		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 						UpperCAmelCase__		(						self    ):
       lowerCAmelCase_       :							str			 =		self.prepare_config_and_inputs()
       (
           (
           lowerCAmelCase_
       ) ,	(
           lowerCAmelCase_
       ) ,	(
           lowerCAmelCase_
       ) ,	
       )       :							List[str]			 =		config_and_inputs
       lowerCAmelCase_       :							int			 =		{"""pixel_values""": pixel_values}
       return config, inputs_dict





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

  __UpperCamelCase						  =	False
  __UpperCamelCase						  =	False
  __UpperCamelCase						  =	False







  def 						UpperCAmelCase__		(						self    ):
       lowerCAmelCase_       :							Tuple			 =		DonutSwinModelTester(self    )
       lowerCAmelCase_       :							Optional[Any]			 =		ConfigTester(self     ,    config_class=_lowercase     ,    embed_dim=37    )







  def 						UpperCAmelCase__		(						self    ):
       self.create_and_test_config_common_properties()
       self.config_tester.create_and_test_config_to_json_string()
       self.config_tester.create_and_test_config_to_json_file()
       self.config_tester.create_and_test_config_from_and_save_pretrained()
       self.config_tester.create_and_test_config_with_num_labels()
       self.config_tester.check_config_can_be_init_without_params()
       self.config_tester.check_config_arguments_init()







  def 						UpperCAmelCase__		(						self    ):
       return







  def 						UpperCAmelCase__		(						self    ):
       lowerCAmelCase_       :							Tuple			 =		self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*_lowercase    )







  def 						UpperCAmelCase__		(						self    ):
       # DonutSwin does not use inputs_embeds
       pass







  def 						UpperCAmelCase__		(						self    ):
       lowerCAmelCase_ ,	lowerCAmelCase_       :							str			 =		self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
            lowerCAmelCase_       :							Optional[Any]			 =		model_class(_lowercase    )
            self.assertIsInstance(model.get_input_embeddings()     ,    (nn.Module)    )
            lowerCAmelCase_       :							int			 =		model.get_output_embeddings()
            self.assertTrue(x is None or isinstance(_lowercase     ,    nn.Linear    )    )







  def 						UpperCAmelCase__		(						self    ):
       lowerCAmelCase_ ,	lowerCAmelCase_       :							List[Any]			 =		self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
            lowerCAmelCase_       :							Dict			 =		model_class(_lowercase    )
            lowerCAmelCase_       :							Any			 =		inspect.signature(model.forward    )
            # signature.parameters is an OrderedDict => so arg_names order is deterministic
            lowerCAmelCase_       :							Dict			 =		[*signature.parameters.keys()]

            lowerCAmelCase_       :							Union[str, Any]			 =		["""pixel_values"""]
            self.assertListEqual(arg_names[:1]     ,    _lowercase    )







  def 						UpperCAmelCase__		(						self    ):
       lowerCAmelCase_ ,	lowerCAmelCase_       :							Optional[Any]			 =		self.model_tester.prepare_config_and_inputs_for_common()
       lowerCAmelCase_       :							Tuple			 =		True

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

            # check that output_attentions also work using config
            del inputs_dict["output_attentions"]
            lowerCAmelCase_       :							int			 =		True
            lowerCAmelCase_       :							Union[str, Any]			 =		config.window_size**2
            lowerCAmelCase_       :							Tuple			 =		model_class(_lowercase    )
            model.to(_lowercase    )
            model.eval()
            with torch.no_grad():
                 lowerCAmelCase_       :							Any			 =		model(**self._prepare_for_class(_lowercase     ,    _lowercase    )    )
            lowerCAmelCase_       :							int			 =		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]     ,    )
            lowerCAmelCase_       :							Any			 =		len(_lowercase    )

            # Check attention is always last and order is fine
            lowerCAmelCase_       :							int			 =		True
            lowerCAmelCase_       :							str			 =		True
            lowerCAmelCase_       :							Tuple			 =		model_class(_lowercase    )
            model.to(_lowercase    )
            model.eval()
            with torch.no_grad():
                 lowerCAmelCase_       :							Any			 =		model(**self._prepare_for_class(_lowercase     ,    _lowercase    )    )

            if hasattr(self.model_tester     ,    """num_hidden_states_types"""    ):
                 lowerCAmelCase_       :							Optional[Any]			 =		self.model_tester.num_hidden_states_types
            else:
                 # also another +1 for reshaped_hidden_states
                 lowerCAmelCase_       :							Union[str, Any]			 =		2
            self.assertEqual(out_len + added_hidden_states     ,    len(_lowercase    )    )

            lowerCAmelCase_       :							Any			 =		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 						UpperCAmelCase__		(						self     ,    _lowercase     ,    _lowercase     ,    _lowercase     ,    _lowercase    ):
       lowerCAmelCase_       :							Optional[Any]			 =		model_class(_lowercase    )
       model.to(_lowercase    )
       model.eval()

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

       lowerCAmelCase_       :							List[Any]			 =		outputs.hidden_states

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

       lowerCAmelCase_       :							List[str]			 =		(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

       self.assertListEqual(
           list(hidden_states[0].shape[-2:]    )     ,    [num_patches, self.model_tester.embed_dim]     ,    )

       lowerCAmelCase_       :							List[Any]			 =		outputs.reshaped_hidden_states
       self.assertEqual(len(_lowercase    )     ,    _lowercase    )

       lowerCAmelCase_ ,	lowerCAmelCase_ ,	lowerCAmelCase_ ,	lowerCAmelCase_       :							Optional[Any]			 =		reshaped_hidden_states[0].shape
       lowerCAmelCase_       :							str			 =		(
           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 						UpperCAmelCase__		(						self    ):
       lowerCAmelCase_ ,	lowerCAmelCase_       :							Dict			 =		self.model_tester.prepare_config_and_inputs_for_common()

       lowerCAmelCase_       :							int			 =		(
           self.model_tester.image_size
           if isinstance(self.model_tester.image_size     ,    collections.abc.Iterable    )
           else (self.model_tester.image_size, self.model_tester.image_size)
       )

       for model_class in self.all_model_classes:
            lowerCAmelCase_       :							Any			 =		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"]
            lowerCAmelCase_       :							Any			 =		True

            self.check_hidden_states_output(_lowercase     ,    _lowercase     ,    _lowercase     ,    _lowercase    )







  def 						UpperCAmelCase__		(						self    ):
       lowerCAmelCase_ ,	lowerCAmelCase_       :							int			 =		self.model_tester.prepare_config_and_inputs_for_common()
       lowerCAmelCase_       :							int			 =		3

       lowerCAmelCase_       :							str			 =		(
           self.model_tester.image_size
           if isinstance(self.model_tester.image_size     ,    collections.abc.Iterable    )
           else (self.model_tester.image_size, self.model_tester.image_size)
       )
       lowerCAmelCase_       :							Optional[int]			 =		(
           config.patch_size
           if isinstance(config.patch_size     ,    collections.abc.Iterable    )
           else (config.patch_size, config.patch_size)
       )

       lowerCAmelCase_       :							int			 =		image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
       lowerCAmelCase_       :							int			 =		image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

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

            # check that output_hidden_states also work using config
            del inputs_dict["output_hidden_states"]
            lowerCAmelCase_       :							Union[str, Any]			 =		True
            self.check_hidden_states_output(_lowercase     ,    _lowercase     ,    _lowercase     ,    (padded_height, padded_width)    )







  @slow
  def 						UpperCAmelCase__		(						self    ):
       for model_name in DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            lowerCAmelCase_       :							str			 =		DonutSwinModel.from_pretrained(_lowercase    )
            self.assertIsNotNone(_lowercase    )







  def 						UpperCAmelCase__		(						self    ):
       lowerCAmelCase_ ,	lowerCAmelCase_       :							List[str]			 =		self.model_tester.prepare_config_and_inputs_for_common()

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