

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_  )







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




