

import copy
import os
from typing import Dict, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...utils import add_start_docstrings, logging
from ..auto import AutoConfig


A_		:			Optional[int]										=   logging.get_logger(__name__)


A_		:			Optional[int]										=   {
    'suno/bark-small': 'https://huggingface.co/suno/bark-small/resolve/main/config.json',
    'suno/bark': 'https://huggingface.co/suno/bark/resolve/main/config.json',
}

A_		:			List[str]										=   '\n    This is the configuration class to store the configuration of a [`{model}`]. It is used to instantiate the model\n    according to the specified arguments, defining the model architecture. Instantiating a configuration with the\n    defaults will yield a similar configuration to that of the Bark [suno/bark](https://huggingface.co/suno/bark)\n    architecture.\n\n    Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the\n    documentation from [`PretrainedConfig`] for more information.\n\n    Args:\n        block_size (`int`, *optional*, defaults to 1024):\n            The maximum sequence length that this model might ever be used with. Typically set this to something large\n            just in case (e.g., 512 or 1024 or 2048).\n        input_vocab_size (`int`, *optional*, defaults to 10_048):\n            Vocabulary size of a Bark sub-model. Defines the number of different tokens that can be represented by the\n            `inputs_ids` passed when calling [`{model}`]. Defaults to 10_048 but should be carefully thought with\n            regards to the chosen sub-model.\n        output_vocab_size (`int`, *optional*, defaults to 10_048):\n            Output vocabulary size of a Bark sub-model. Defines the number of different tokens that can be represented\n            by the: `output_ids` when passing forward a [`{model}`]. Defaults to 10_048 but should be carefully thought\n            with regards to the chosen sub-model.\n        num_layers (`int`, *optional*, defaults to 12):\n            Number of hidden layers in the given sub-model.\n        num_heads (`int`, *optional*, defaults to 12):\n            Number of attention heads for each attention layer in the Transformer architecture.\n        hidden_size (`int`, *optional*, defaults to 768):\n            Dimensionality of the "intermediate" (often named feed-forward) layer in the architecture.\n        dropout (`float`, *optional*, defaults to 0.0):\n            The dropout probability for all fully connected layers in the embeddings, encoder, and pooler.\n        bias (`bool`, *optional*, defaults to `True`):\n            Whether or not to use bias in the linear layers and layer norm layers.\n        initializer_range (`float`, *optional*, defaults to 0.02):\n            The standard deviation of the truncated_normal_initializer for initializing all weight matrices.\n        use_cache (`bool`, *optional*, defaults to `True`):\n            Whether or not the model should return the last key/values attentions (not used by all models).\n'
class 					A_   (      _a						):


    '''simple docstring'''






    a__     							=       "bark_module"
    a__     							=       ["past_key_values"]

    a__     							=       {
        "num_attention_heads": "num_heads",
        "num_hidden_layers": "num_layers",
        "vocab_size": "input_vocab_size",
        "window_size": "block_size",
    }


    def __init__(self     ,      lowercase__=1_024     ,      lowercase__=10_048     ,      lowercase__=10_048     ,      lowercase__=12     ,      lowercase__=12     ,      lowercase__=768     ,      lowercase__=0.0     ,      lowercase__=True     ,      lowercase__=0.02     ,      lowercase__=True     ,      **lowercase__     ,      )     ->      Union[str, Any]:
        __UpperCAmelCase									=			block_size
        __UpperCAmelCase									=			input_vocab_size
        __UpperCAmelCase									=			output_vocab_size
        __UpperCAmelCase									=			num_layers
        __UpperCAmelCase									=			num_heads
        __UpperCAmelCase									=			hidden_size
        __UpperCAmelCase									=			dropout
        __UpperCAmelCase									=			bias
        __UpperCAmelCase									=			use_cache
        __UpperCAmelCase									=			initializer_range

        super().__init__(**__lowerCamelCase  )






    @classmethod
    def      lowerCAmelCase_						(cls     ,      lowercase__     ,      lowercase__ = None     ,      lowercase__ = False     ,      lowercase__ = False     ,      lowercase__ = None     ,      lowercase__ = "main"     ,      **lowercase__     ,      )     ->      "PretrainedConfig":
        __UpperCAmelCase									=			cache_dir
        __UpperCAmelCase									=			force_download
        __UpperCAmelCase									=			local_files_only
        __UpperCAmelCase									=			revision

        cls._set_token_in_kwargs(__lowerCamelCase     ,      __lowerCamelCase  )

        __UpperCAmelCase									=			cls.get_config_dict(__lowerCamelCase     ,      **__lowerCamelCase  )

        # get the config dict if we are loading from Bark
        if config_dict.get('''model_type'''  ) == "bark":
            __UpperCAmelCase									=			config_dict[F'''{cls.model_type}_config''']

        if "model_type" in config_dict and hasattr(cls     ,      '''model_type'''  ) and config_dict["model_type"] != cls.model_type:
            logger.warning(
                F'''You are using a model of type {config_dict['model_type']} to instantiate a model of type '''
                F'''{cls.model_type}. This is not supported for all configurations of models and can yield errors.'''  )

        return cls.from_dict(__lowerCamelCase     ,      **__lowerCamelCase  )






@add_start_docstrings(
    BARK_SUBMODELCONFIG_START_DOCSTRING.format(config="BarkSemanticConfig" ,     model="BarkSemanticModel"						) ,     "\n    Example:\n\n    ```python\n    >>> from transformers import BarkSemanticConfig, BarkSemanticModel\n\n    >>> # Initializing a Bark sub-module style configuration\n    >>> configuration = BarkSemanticConfig()\n\n    >>> # Initializing a model (with random weights) from the suno/bark style configuration\n    >>> model = BarkSemanticModel(configuration)\n\n    >>> # Accessing the model configuration\n    >>> configuration = model.config\n    ```" ,     )
class 					A_   (      _a						):


    '''simple docstring'''






    a__     							=       "semantic"






@add_start_docstrings(
    BARK_SUBMODELCONFIG_START_DOCSTRING.format(config="BarkCoarseConfig" ,     model="BarkCoarseModel"						) ,     "\n    Example:\n\n    ```python\n    >>> from transformers import BarkCoarseConfig, BarkCoarseModel\n\n    >>> # Initializing a Bark sub-module style configuration\n    >>> configuration = BarkCoarseConfig()\n\n    >>> # Initializing a model (with random weights) from the suno/bark style configuration\n    >>> model = BarkCoarseModel(configuration)\n\n    >>> # Accessing the model configuration\n    >>> configuration = model.config\n    ```" ,     )
class 					A_   (      _a						):


    '''simple docstring'''






    a__     							=       "coarse_acoustics"






@add_start_docstrings(
    BARK_SUBMODELCONFIG_START_DOCSTRING.format(config="BarkFineConfig" ,     model="BarkFineModel"						) ,     "\n        n_codes_total (`int`, *optional*, defaults to 8):\n            The total number of audio codebooks predicted. Used in the fine acoustics sub-model.\n        n_codes_given (`int`, *optional*, defaults to 1):\n            The number of audio codebooks predicted in the coarse acoustics sub-model. Used in the acoustics\n            sub-models.\n    Example:\n\n    ```python\n    >>> from transformers import BarkFineConfig, BarkFineModel\n\n    >>> # Initializing a Bark sub-module style configuration\n    >>> configuration = BarkFineConfig()\n\n    >>> # Initializing a model (with random weights) from the suno/bark style configuration\n    >>> model = BarkFineModel(configuration)\n\n    >>> # Accessing the model configuration\n    >>> configuration = model.config\n    ```" ,     )
class 					A_   (      _a						):


    '''simple docstring'''






    a__     							=       "fine_acoustics"


    def __init__(self     ,      lowercase__=True     ,      lowercase__=8     ,      lowercase__=1     ,      **lowercase__  )     ->      Optional[Any]:
        __UpperCAmelCase									=			n_codes_total
        __UpperCAmelCase									=			n_codes_given

        super().__init__(tie_word_embeddings=__lowerCamelCase     ,      **__lowerCamelCase  )






class 					A_   (      _a						):


    '''simple docstring'''






    a__     							=       "bark"
    a__     							=       True


    def __init__(self     ,      lowercase__ = None     ,      lowercase__ = None     ,      lowercase__ = None     ,      lowercase__ = None     ,      lowercase__=0.02     ,      **lowercase__     ,      )     ->      Any:
        if semantic_config is None:
            __UpperCAmelCase									=			{}
            logger.info('''semantic_config is None. initializing the semantic model with default values.'''  )

        if coarse_acoustics_config is None:
            __UpperCAmelCase									=			{}
            logger.info('''coarse_acoustics_config is None. initializing the coarse model with default values.'''  )

        if fine_acoustics_config is None:
            __UpperCAmelCase									=			{}
            logger.info('''fine_acoustics_config is None. initializing the fine model with default values.'''  )

        if codec_config is None:
            __UpperCAmelCase									=			{}
            logger.info('''codec_config is None. initializing the codec model with default values.'''  )

        __UpperCAmelCase									=			BarkSemanticConfig(**__lowerCamelCase  )
        __UpperCAmelCase									=			BarkCoarseConfig(**__lowerCamelCase  )
        __UpperCAmelCase									=			BarkFineConfig(**__lowerCamelCase  )
        __UpperCAmelCase									=			AutoConfig.for_model(**__lowerCamelCase  )

        __UpperCAmelCase									=			initializer_range

        super().__init__(**__lowerCamelCase  )


    @classmethod
    def      lowerCAmelCase_						(cls     ,      lowercase__     ,      lowercase__     ,      lowercase__     ,      lowercase__     ,      **lowercase__     ,      )     ->      Tuple:
        return cls(
            semantic_config=semantic_config.to_dict()     ,      coarse_acoustics_config=coarse_acoustics_config.to_dict()     ,      fine_acoustics_config=fine_acoustics_config.to_dict()     ,      codec_config=codec_config.to_dict()     ,      **__lowerCamelCase     ,      )






    def      lowerCAmelCase_						(self  )     ->      Any:
        __UpperCAmelCase									=			copy.deepcopy(self.__dict__  )

        __UpperCAmelCase									=			self.semantic_config.to_dict()
        __UpperCAmelCase									=			self.coarse_acoustics_config.to_dict()
        __UpperCAmelCase									=			self.fine_acoustics_config.to_dict()
        __UpperCAmelCase									=			self.codec_config.to_dict()

        __UpperCAmelCase									=			self.__class__.model_type
        return output







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




