
'''simple docstring'''
from __future__ import annotations

import copy
import os
import tempfile
from importlib import import_module
from math import isnan

from transformers import is_tf_available
from transformers.models.auto import get_values
from transformers.testing_utils import _tf_gpu_memory_limit, require_tf, slow

from ..test_modeling_tf_common import ids_tensor


if is_tf_available():
  import numpy as np
  import tensorflow as tf

  from transformers import (
      TF_MODEL_FOR_CAUSAL_LM_MAPPING,
      TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
      TF_MODEL_FOR_MASKED_LM_MAPPING,
      TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
      TF_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
      TF_MODEL_FOR_PRETRAINING_MAPPING,
      TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
      TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
      TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
      TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
      TFSharedEmbeddings,
  )

  if _tf_gpu_memory_limit is not None:
    a_           =    tf.config.list_physical_devices("GPU")
    for gpu in gpus:
      # Restrict TensorFlow to only allocate x GB of memory on the GPUs
      try:
        tf.config.set_logical_device_configuration(
            gpu, [tf.config.LogicalDeviceConfiguration(memory_limit=_tf_gpu_memory_limit)]
        )
        a_           =    tf.config.list_logical_devices("GPU")
        print("Logical GPUs", logical_gpus)
      except RuntimeError as e:
        # Virtual devices must be set before GPUs have been initialized
        print(e)






@require_tf
class  UpperCAmelCase_					:
 UpperCAmelCase_		     =    None
 UpperCAmelCase_		     =    ()
 UpperCAmelCase_		     =    ()
 UpperCAmelCase_		     =    True
 UpperCAmelCase_		     =    True
 UpperCAmelCase_		     =    True
 UpperCAmelCase_		     =    False





 def 							snake_case__		(     self			,							lowercase_			,							lowercase_			,							lowercase_=False):
     snake_case_			:     Optional[Any]        =    copy.deepcopy(lowercase_)

     if model_class in get_values(lowercase_):
         snake_case_			:     int        =    {
             k: tf.tile(tf.expand_dims(lowercase_			,							1)			,							(1, self.model_tester.num_choices) + (1,) * (v.ndim - 1))
             if isinstance(lowercase_			,							tf.Tensor) and v.ndim > 0
             else v
             for k, v in inputs_dict.items()
         }

     if return_labels:
         if model_class in get_values(lowercase_):
             snake_case_			:     Optional[int]        =    tf.ones(self.model_tester.batch_size			,							dtype=tf.intaa)
         elif model_class in get_values(lowercase_):
             snake_case_			:     Tuple        =    tf.zeros(self.model_tester.batch_size			,							dtype=tf.intaa)
             snake_case_			:     str        =    tf.zeros(self.model_tester.batch_size			,							dtype=tf.intaa)
         elif model_class in [
             *get_values(lowercase_),
             *get_values(lowercase_),
         ]:
             snake_case_			:     Optional[int]        =    tf.zeros(self.model_tester.batch_size			,							dtype=tf.intaa)
         elif model_class in get_values(lowercase_):
             snake_case_			:     Optional[Any]        =    tf.zeros(self.model_tester.batch_size			,							dtype=tf.intaa)
         elif model_class in [
             *get_values(lowercase_),
             *get_values(lowercase_),
             *get_values(lowercase_),
             *get_values(lowercase_),
             *get_values(lowercase_),
         ]:
             snake_case_			:     List[str]        =    tf.zeros(
                 (self.model_tester.batch_size, self.model_tester.seq_length)			,							dtype=tf.intaa)
     return inputs_dict





 @slow
 def 							snake_case__		(     self):
     snake_case_      ,			snake_case_			:     Any        =    self.model_tester.prepare_config_and_inputs_for_common()
     for model_class in self.all_model_classes[:2]:
         snake_case_			:     int        =    self._prepare_for_class(lowercase_			,							lowercase_)
         snake_case_			:     List[Any]        =    model_class(lowercase_)

         @tf.function
         def run_in_graph_mode():
             return model(lowercase_)

         snake_case_			:     Dict        =    run_in_graph_mode()
         self.assertIsNotNone(lowercase_)





 @slow
 def 							snake_case__		(     self):
     snake_case_      ,			snake_case_			:     Optional[int]        =    self.model_tester.prepare_config_and_inputs_for_common()
     for model_class in self.all_model_classes[:2]:
         snake_case_			:     Optional[Any]        =    self._prepare_for_class(lowercase_			,							lowercase_)
         snake_case_			:     str        =    model_class(lowercase_)

         @tf.function(experimental_compile=lowercase_)
         def run_in_graph_mode():
             return model(lowercase_)

         snake_case_			:     str        =    run_in_graph_mode()
         self.assertIsNotNone(lowercase_)





 @slow
 def 							snake_case__		(     self):
     # This is a copy of the test_keras_fit method, but we use XLA compilation instead of eager
     snake_case_      ,			snake_case_			:     str        =    self.model_tester.prepare_config_and_inputs_for_common()
     for model_class in self.all_model_classes[:2]:
         snake_case_			:     List[str]        =    model_class(lowercase_)
         if getattr(lowercase_			,							"hf_compute_loss"			,							lowercase_):
             # Test that model correctly compute the loss with kwargs
             snake_case_			:     int        =    self._prepare_for_class(inputs_dict.copy()			,							lowercase_			,							return_labels=lowercase_)
             # Is there a better way to remove these decoder inputs?
             snake_case_			:     List[Any]        =    {
                 key: val
                 for key, val in prepared_for_class.items()
                 if key not in ("head_mask", "decoder_head_mask", "cross_attn_head_mask", "decoder_input_ids")
             }

             snake_case_			:     int        =    {
                 "labels",
                 "label",
                 "label_ids",
                 "start_positions",
                 "start_position",
                 "end_positions",
                 "end_position",
                 "next_sentence_label",
             }
             snake_case_			:     Tuple        =    possible_label_cols.intersection(set(lowercase_))
             self.assertGreater(len(lowercase_)			,							0			,							msg="No matching label names found!")
             snake_case_			:     Dict        =    {key: val for key, val in prepared_for_class.items() if key in label_names}
             snake_case_			:     List[str]        =    {key: val for key, val in prepared_for_class.items() if key not in label_names}
             self.assertGreater(len(lowercase_)			,							0)

             # Make sure it works with XLA!
             model.compile(optimizer=tf.keras.optimizers.SGD(0.0)			,							jit_compile=lowercase_)
             # Make sure the model fits without crashing regardless of where we pass the labels
             snake_case_			:     int        =    model.fit(
                 lowercase_			,							validation_data=lowercase_			,							steps_per_epoch=1			,							validation_steps=1			,							shuffle=lowercase_			,							verbose=0			,							)
             snake_case_			:     Union[str, Any]        =    history.history["loss"][0]
             self.assertTrue(not isnan(lowercase_))
             snake_case_			:     List[Any]        =    history.history["val_loss"][0]
             self.assertTrue(not isnan(lowercase_))

             # Now test it with separate labels, to make sure that path works in XLA too.
             snake_case_			:     Dict        =    model_class(lowercase_)
             model.compile(optimizer=tf.keras.optimizers.SGD(0.0)			,							jit_compile=lowercase_)
             snake_case_			:     Dict        =    model.fit(
                 lowercase_			,							lowercase_			,							validation_data=(inputs_minus_labels, labels)			,							steps_per_epoch=1			,							validation_steps=1			,							shuffle=lowercase_			,							verbose=0			,							)

             snake_case_			:     Optional[int]        =    history.history["loss"][0]
             self.assertTrue(not isnan(lowercase_))
             snake_case_			:     Optional[Any]        =    history.history["val_loss"][0]
             self.assertTrue(not isnan(lowercase_))





 @slow
 def 							snake_case__		(     self):
     snake_case_      ,			snake_case_			:     Dict        =    self.model_tester.prepare_config_and_inputs_for_common()
     snake_case_			:     List[str]        =    True
     snake_case_			:     str        =    True

     if hasattr(lowercase_			,							"use_cache"):
         snake_case_			:     List[Any]        =    True

     snake_case_			:     List[str]        =    getattr(self.model_tester			,							"encoder_seq_length"			,							self.model_tester.seq_length)
     snake_case_			:     Optional[int]        =    getattr(self.model_tester			,							"key_length"			,							lowercase_)

     for model_class in self.all_model_classes[:2]:
         snake_case_			:     Any        =    self._prepare_for_class(lowercase_			,							lowercase_)
         snake_case_			:     List[str]        =    model_class(lowercase_)
         model.build()
         snake_case_			:     List[Any]        =    len(model(lowercase_))

         for key in list(class_inputs_dict.keys()):
             # Remove keys not in the serving signature, as the SavedModel will not be compiled to deal with them
             if key not in model.input_signature:
                 del class_inputs_dict[key]
             # Check it's a tensor, in case the inputs dict has some bools in it too
             elif isinstance(class_inputs_dict[key]			,							tf.Tensor) and class_inputs_dict[key].dtype.is_integer:
                 snake_case_			:     Optional[int]        =    tf.cast(class_inputs_dict[key]			,							tf.intaa)

         if set(class_inputs_dict.keys()) != set(model.input_signature.keys()):
             continue  # Some models have inputs that the preparation functions don't create, we skip those

         with tempfile.TemporaryDirectory() as tmpdirname:
             model.save_pretrained(lowercase_			,							saved_model=lowercase_)
             snake_case_			:     List[str]        =    os.path.join(lowercase_			,							"saved_model"			,							"1")
             snake_case_			:     Optional[Any]        =    tf.keras.models.load_model(lowercase_)
             snake_case_			:     int        =    model(lowercase_)

             if self.is_encoder_decoder:
                 snake_case_			:     List[str]        =    outputs["encoder_hidden_states"]
                 snake_case_			:     List[Any]        =    outputs["encoder_attentions"]
             else:
                 snake_case_			:     List[str]        =    outputs["hidden_states"]
                 snake_case_			:     List[str]        =    outputs["attentions"]

             self.assertEqual(len(lowercase_)			,							lowercase_)

             snake_case_			:     Union[str, Any]        =    getattr(
                 self.model_tester			,							"expected_num_hidden_layers"			,							self.model_tester.num_hidden_layers + 1)

             self.assertEqual(len(lowercase_)			,							lowercase_)
             self.assertListEqual(
                 list(output_hidden_states[0].shape[-2:])			,							[self.model_tester.seq_length, self.model_tester.hidden_size]			,							)

             self.assertEqual(len(lowercase_)			,							self.model_tester.num_hidden_layers)
             self.assertListEqual(
                 list(output_attentions[0].shape[-3:])			,							[self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length]			,							)





 @slow
 def 							snake_case__		(     self):
     tf.keras.mixed_precision.set_global_policy("mixed_float16")

     # try/finally block to ensure subsequent tests run in float32
     try:
         snake_case_      ,			snake_case_			:     Optional[int]        =    self.model_tester.prepare_config_and_inputs_for_common()
         for model_class in self.all_model_classes[:2]:
             snake_case_			:     Optional[Any]        =    self._prepare_for_class(lowercase_			,							lowercase_)
             snake_case_			:     Tuple        =    model_class(lowercase_)
             snake_case_			:     int        =    model(lowercase_)

             self.assertIsNotNone(lowercase_)
     finally:
         tf.keras.mixed_precision.set_global_policy("float32")





 @slow
 def 							snake_case__		(     self):
     snake_case_      ,			snake_case_			:     str        =    self.model_tester.prepare_config_and_inputs_for_common()
     # head_mask and decoder_head_mask has different shapes than other input args
     if "head_mask" in inputs_dict:
         del inputs_dict["head_mask"]
     if "decoder_head_mask" in inputs_dict:
         del inputs_dict["decoder_head_mask"]
     if "cross_attn_head_mask" in inputs_dict:
         del inputs_dict["cross_attn_head_mask"]
     snake_case_			:     Dict        =    {
         module_member
         for model_class in self.all_model_classes
         for module in (import_module(model_class.__module__),)
         for module_member_name in dir(lowercase_)
         if module_member_name.endswith("MainLayer")
         for module_member in (getattr(lowercase_			,							lowercase_),)
         if isinstance(lowercase_			,							lowercase_)
         and tf.keras.layers.Layer in module_member.__bases__
         and getattr(lowercase_			,							"_keras_serializable"			,							lowercase_)
     }

     for main_layer_class in tf_main_layer_classes:
         # T5MainLayer needs an embed_tokens parameter when called without the inputs_embeds parameter
         if "T5" in main_layer_class.__name__:
             # Take the same values than in TFT5ModelTester for this shared layer
             snake_case_			:     str        =    TFSharedEmbeddings(self.model_tester.vocab_size			,							self.model_tester.hidden_size			,							name="shared")
             snake_case_			:     str        =    False
             snake_case_			:     Optional[int]        =    main_layer_class(lowercase_			,							embed_tokens=lowercase_)
         else:
             snake_case_			:     Dict        =    main_layer_class(lowercase_)

         snake_case_			:     Tuple        =    {
             name: tf.keras.Input(tensor.shape[1:]			,							dtype=tensor.dtype) for name, tensor in inputs_dict.items()
         }

         if hasattr(self.model_tester			,							"num_labels"):
             snake_case_			:     Optional[Any]        =    self.model_tester.num_labels
         else:
             snake_case_			:     List[str]        =    2

         snake_case_			:     Union[str, Any]        =    tf.data.Dataset.from_tensor_slices(
             (inputs_dict, np.ones((self.model_tester.batch_size, self.model_tester.seq_length, num_labels, 1)))).batch(1)

         snake_case_			:     Union[str, Any]        =    main_layer(lowercase_)[0]
         snake_case_			:     str        =    tf.keras.layers.Dense(lowercase_			,							activation="softmax"			,							name="outputs")(lowercase_)
         snake_case_			:     Any        =    tf.keras.models.Model(inputs=lowercase_			,							outputs=[outputs])

         model.compile(loss="binary_crossentropy"			,							optimizer="adam"			,							metrics=["binary_accuracy"])
         model.fit(lowercase_			,							epochs=1)

         with tempfile.TemporaryDirectory() as tmpdirname:
             snake_case_			:     Union[str, Any]        =    os.path.join(lowercase_			,							"keras_model.h5")
             model.save(lowercase_)
             if "T5" in main_layer_class.__name__:
                 snake_case_			:     Dict        =    tf.keras.models.load_model(
                     lowercase_			,							custom_objects={
                         main_layer_class.__name__: main_layer_class,
                         "TFSharedEmbeddings": TFSharedEmbeddings,
                     }			,							)
             else:
                 snake_case_			:     Optional[int]        =    tf.keras.models.load_model(
                     lowercase_			,							custom_objects={main_layer_class.__name__: main_layer_class})
             assert isinstance(lowercase_			,							tf.keras.Model)
             model(lowercase_)





 @slow
 def 							snake_case__		(     self):
     snake_case_      ,			snake_case_			:     Union[str, Any]        =    self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes[:2]:
         snake_case_			:     str        =    model_class(lowercase_)

         snake_case_			:     Dict        =    copy.deepcopy(lowercase_)

         if not self.is_encoder_decoder:
             snake_case_			:     str        =    inputs["input_ids"]
             del inputs["input_ids"]
         else:
             snake_case_			:     Union[str, Any]        =    inputs["input_ids"]
             snake_case_			:     Union[str, Any]        =    inputs.get("decoder_input_ids"			,							lowercase_)
             del inputs["input_ids"]
             inputs.pop("decoder_input_ids"			,							lowercase_)

         if not self.is_encoder_decoder:
             snake_case_			:     str        =    model.get_input_embeddings()(lowercase_)
         else:
             snake_case_			:     List[Any]        =    model.get_input_embeddings()(lowercase_)
             snake_case_			:     Tuple        =    model.get_input_embeddings()(lowercase_)

         snake_case_			:     Optional[int]        =    self._prepare_for_class(lowercase_			,							lowercase_)

         @tf.function
         def run_in_graph_mode():
             return model(lowercase_)

         snake_case_			:     Any        =    run_in_graph_mode()
         self.assertIsNotNone(lowercase_)





 def 							snake_case__		(     self			,							lowercase_			,							lowercase_):
     # special tokens cannot be bad tokens
     snake_case_			:     Union[str, Any]        =    []
     if model.config.bos_token_id is not None:
         special_tokens.append(model.config.bos_token_id)
     if model.config.pad_token_id is not None:
         special_tokens.append(model.config.pad_token_id)
     if model.config.eos_token_id is not None:
         special_tokens.append(model.config.eos_token_id)

     # create random bad tokens that are not special tokens
     snake_case_			:     Optional[int]        =    []
     while len(lowercase_) < num_bad_tokens:
         snake_case_			:     Optional[int]        =    tf.squeeze(ids_tensor((1, 1)			,							self.model_tester.vocab_size)			,							0).numpy()[0]
         if token not in special_tokens:
             bad_tokens.append(lowercase_)
     return bad_tokens





 def 							snake_case__		(     self			,							lowercase_):
     for token_id in output_ids[0].numpy().tolist():
         self.assertGreaterEqual(lowercase_			,							0)
         self.assertLess(lowercase_			,							self.model_tester.vocab_size)





 def 							snake_case__		(     self			,							lowercase_			,							lowercase_):
     # for all bad word tokens
     for bad_word_ids in bad_words_ids:
         # for all slices in batch
         for generated_ids_slice in generated_ids:
             # for all word idx
             for i in range(len(lowercase_)			,							len(lowercase_)):
                 # if tokens match
                 if generated_ids_slice[i - len(lowercase_) : i] == bad_word_ids:
                     return True
     return False






'''simple docstring'''
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  UpperCAmelCase_					:





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





 def 							snake_case__		(     self):
     snake_case_			:     str        =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

     snake_case_			:     Tuple        =    None
     if self.use_labels:
         snake_case_			:     Union[str, Any]        =    ids_tensor([self.batch_size]			,							self.type_sequence_label_size)

     snake_case_			:     Any        =    self.get_config()

     return config, pixel_values, labels





 def 							snake_case__		(     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 							snake_case__		(     self			,							lowercase_			,							lowercase_			,							lowercase_):
     snake_case_			:     str        =    DonutSwinModel(config=lowercase_)
     model.to(lowercase_)
     model.eval()
     snake_case_			:     Union[str, Any]        =    model(lowercase_)

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






@require_torch
class  UpperCAmelCase_					(						snake_case__     ,    snake_case__     ,    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 							snake_case__		(     self):
     snake_case_			:     Union[str, Any]        =    DonutSwinModelTester(self)
     snake_case_			:     Optional[Any]        =    ConfigTester(self			,							config_class=lowercase_			,							embed_dim=37)





 def 							snake_case__		(     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 							snake_case__		(     self):
     return





 def 							snake_case__		(     self):
     snake_case_			:     int        =    self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*lowercase_)





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





 def 							snake_case__		(     self):
     snake_case_      ,			snake_case_			:     Tuple        =    self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
         snake_case_			:     Any        =    model_class(lowercase_)
         self.assertIsInstance(model.get_input_embeddings()			,							(nn.Module))
         snake_case_			:     List[str]        =    model.get_output_embeddings()
         self.assertTrue(x is None or isinstance(lowercase_			,							nn.Linear))





 def 							snake_case__		(     self):
     snake_case_      ,			snake_case_			:     Optional[Any]        =    self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
         snake_case_			:     Optional[Any]        =    model_class(lowercase_)
         snake_case_			:     Any        =    inspect.signature(model.forward)
         # signature.parameters is an OrderedDict => so arg_names order is deterministic
         snake_case_			:     Union[str, Any]        =    [*signature.parameters.keys()]

         snake_case_			:     Any        =    ["pixel_values"]
         self.assertListEqual(arg_names[:1]			,							lowercase_)





 def 							snake_case__		(     self):
     snake_case_      ,			snake_case_			:     Union[str, Any]        =    self.model_tester.prepare_config_and_inputs_for_common()
     snake_case_			:     Union[str, Any]        =    True

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

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

         # Check attention is always last and order is fine
         snake_case_			:     Union[str, Any]        =    True
         snake_case_			:     Union[str, Any]        =    True
         snake_case_			:     List[Any]        =    model_class(lowercase_)
         model.to(lowercase_)
         model.eval()
         with torch.no_grad():
             snake_case_			:     Tuple        =    model(**self._prepare_for_class(lowercase_			,							lowercase_))

         if hasattr(self.model_tester			,							"num_hidden_states_types"):
             snake_case_			:     Dict        =    self.model_tester.num_hidden_states_types
         else:
             # also another +1 for reshaped_hidden_states
             snake_case_			:     Dict        =    2
         self.assertEqual(out_len + added_hidden_states			,							len(lowercase_))

         snake_case_			:     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 							snake_case__		(     self			,							lowercase_			,							lowercase_			,							lowercase_			,							lowercase_):
     snake_case_			:     Union[str, Any]        =    model_class(lowercase_)
     model.to(lowercase_)
     model.eval()

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

     snake_case_			:     Dict        =    outputs.hidden_states

     snake_case_			:     Dict        =    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
     snake_case_			:     List[Any]        =    (
         config.patch_size
         if isinstance(config.patch_size			,							collections.abc.Iterable)
         else (config.patch_size, config.patch_size)
     )

     snake_case_			:     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]			,							)

     snake_case_			:     str        =    outputs.reshaped_hidden_states
     self.assertEqual(len(lowercase_)			,							lowercase_)

     snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_			:     Dict        =    reshaped_hidden_states[0].shape
     snake_case_			:     Union[str, Any]        =    (
         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 							snake_case__		(     self):
     snake_case_      ,			snake_case_			:     int        =    self.model_tester.prepare_config_and_inputs_for_common()

     snake_case_			:     Union[str, Any]        =    (
         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:
         snake_case_			:     List[str]        =    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"]
         snake_case_			:     List[Any]        =    True

         self.check_hidden_states_output(lowercase_			,							lowercase_			,							lowercase_			,							lowercase_)





 def 							snake_case__		(     self):
     snake_case_      ,			snake_case_			:     List[str]        =    self.model_tester.prepare_config_and_inputs_for_common()
     snake_case_			:     Any        =    3

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

     snake_case_			:     str        =    image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
     snake_case_			:     List[str]        =    image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

     for model_class in self.all_model_classes:
         snake_case_			:     str        =    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"]
         snake_case_			:     Dict        =    True
         self.check_hidden_states_output(lowercase_			,							lowercase_			,							lowercase_			,							(padded_height, padded_width))





 @slow
 def 							snake_case__		(     self):
     for model_name in DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         snake_case_			:     List[str]        =    DonutSwinModel.from_pretrained(lowercase_)
         self.assertIsNotNone(lowercase_)





 def 							snake_case__		(     self):
     snake_case_      ,			snake_case_			:     Union[str, Any]        =    self.model_tester.prepare_config_and_inputs_for_common()

     snake_case_			:     Dict        =    _config_zero_init(lowercase_)
     for model_class in self.all_model_classes:
         snake_case_			:     str        =    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'			,							)




