'''simple docstring'''


import unittest
from unittest.util import safe_repr

from transformers import AutoTokenizer, RwkvConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
 import torch

 from transformers import (
     RWKV_PRETRAINED_MODEL_ARCHIVE_LIST,
     RwkvForCausalLM,
     RwkvModel,
 )
 from transformers.pytorch_utils import is_torch_greater_or_equal_than_2_0
else:
 snake_case__	:     str      =    False






class 	__SCREAMING_SNAKE_CASE		:







  '''simple docstring'''






  def __init__(					self ,						snake_case_ ,						snake_case_=1_4 ,						snake_case_=7 ,						snake_case_=True ,						snake_case_=False ,						snake_case_=True ,						snake_case_=True ,						snake_case_=True ,						snake_case_=9_9 ,						snake_case_=3_2 ,						snake_case_=5 ,						snake_case_=3_7 ,						snake_case_="gelu" ,						snake_case_=0.1 ,						snake_case_=0.1 ,						snake_case_=5_1_2 ,						snake_case_=1_6 ,						snake_case_=2 ,						snake_case_=3 ,						snake_case_=4 ,						snake_case_=None ,						):




       '''simple docstring'''

       UpperCAmelCase_				:  Union[str, Any]  = parent
       UpperCAmelCase_				:  List[str]  = batch_size
       UpperCAmelCase_				:  int  = seq_length
       UpperCAmelCase_				:  Dict  = is_training
       UpperCAmelCase_				:  Optional[int]  = use_token_type_ids
       UpperCAmelCase_				:  Optional[Any]  = use_input_mask
       UpperCAmelCase_				:  int  = use_labels
       UpperCAmelCase_				:  Optional[Any]  = use_mc_token_ids
       UpperCAmelCase_				:  Optional[Any]  = vocab_size
       UpperCAmelCase_				:  Any  = hidden_size
       UpperCAmelCase_				:  Optional[int]  = num_hidden_layers
       UpperCAmelCase_				:  str  = intermediate_size
       UpperCAmelCase_				:  int  = hidden_act
       UpperCAmelCase_				:  Union[str, Any]  = hidden_dropout_prob
       UpperCAmelCase_				:  Optional[Any]  = attention_probs_dropout_prob
       UpperCAmelCase_				:  Any  = max_position_embeddings
       UpperCAmelCase_				:  str  = type_vocab_size
       UpperCAmelCase_				:  Dict  = type_sequence_label_size
       UpperCAmelCase_				:  Union[str, Any]  = num_labels
       UpperCAmelCase_				:  str  = num_choices
       UpperCAmelCase_				:  Any  = scope
       UpperCAmelCase_				:  int  = vocab_size - 1
       UpperCAmelCase_				:  str  = vocab_size - 1
       UpperCAmelCase_				:  Union[str, Any]  = vocab_size - 1


  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       return RwkvConfig.from_pretrained('sgugger/rwkv-4-pile-7b'		)


  def _UpperCamelCase	(					self ,						snake_case_=False ,						snake_case_=False ,						snake_case_=False		):




       '''simple docstring'''

       UpperCAmelCase_				:  Any  = ids_tensor([self.batch_size, self.seq_length] ,						self.vocab_size		)

       UpperCAmelCase_				:  Union[str, Any]  = None
       if self.use_input_mask:
            UpperCAmelCase_				:  Optional[int]  = random_attention_mask([self.batch_size, self.seq_length]		)

       UpperCAmelCase_				:  Optional[int]  = None
       if self.use_token_type_ids:
            UpperCAmelCase_				:  Optional[Any]  = ids_tensor([self.batch_size, self.seq_length] ,						self.type_vocab_size		)

       UpperCAmelCase_				:  List[Any]  = None
       if self.use_mc_token_ids:
            UpperCAmelCase_				:  int  = ids_tensor([self.batch_size, self.num_choices] ,						self.seq_length		)

       UpperCAmelCase_				:  List[Any]  = None
       UpperCAmelCase_				:  int  = None
       UpperCAmelCase_				:  int  = None
       if self.use_labels:
            UpperCAmelCase_				:  str  = ids_tensor([self.batch_size] ,						self.type_sequence_label_size		)
            UpperCAmelCase_				:  Optional[Any]  = ids_tensor([self.batch_size, self.seq_length] ,						self.num_labels		)
            UpperCAmelCase_				:  List[str]  = ids_tensor([self.batch_size] ,						self.num_choices		)

       UpperCAmelCase_				:  List[str]  = self.get_config(
           gradient_checkpointing=snake_case_ ,						scale_attn_by_inverse_layer_idx=snake_case_ ,						reorder_and_upcast_attn=snake_case_ ,						)

       return (
           config,
           input_ids,
           input_mask,
           None,
           token_type_ids,
           mc_token_ids,
           sequence_labels,
           token_labels,
           choice_labels,
       )


  def _UpperCamelCase	(					self ,						snake_case_=False ,						snake_case_=False ,						snake_case_=False		):




       '''simple docstring'''

       return RwkvConfig(
           vocab_size=self.vocab_size ,						hidden_size=self.hidden_size ,						num_hidden_layers=self.num_hidden_layers ,						intermediate_size=self.intermediate_size ,						activation_function=self.hidden_act ,						resid_pdrop=self.hidden_dropout_prob ,						attn_pdrop=self.attention_probs_dropout_prob ,						n_positions=self.max_position_embeddings ,						type_vocab_size=self.type_vocab_size ,						use_cache=snake_case_ ,						bos_token_id=self.bos_token_id ,						eos_token_id=self.eos_token_id ,						pad_token_id=self.pad_token_id ,						gradient_checkpointing=snake_case_ ,						scale_attn_by_inverse_layer_idx=snake_case_ ,						reorder_and_upcast_attn=snake_case_ ,						)


  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       UpperCAmelCase_				:  int  = self.get_config()
       UpperCAmelCase_				:  int  = 3_0_0
       return config


  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       (
           (
           UpperCAmelCase_
       )  ,     (
           UpperCAmelCase_
       )  ,     (
           UpperCAmelCase_
       )  ,     (
           UpperCAmelCase_
       )  ,     (
           UpperCAmelCase_
       )  ,     (
           UpperCAmelCase_
       )  ,     (
           UpperCAmelCase_
       )  ,     (
           UpperCAmelCase_
       )  ,     (
           UpperCAmelCase_
       )  ,     
       )				:  Tuple  = self.prepare_config_and_inputs()

       UpperCAmelCase_				:  Tuple  = floats_tensor([self.batch_size, self.seq_length, self.hidden_size]		)
       UpperCAmelCase_				:  Tuple  = ids_tensor([self.batch_size, self.seq_length] ,						vocab_size=2		)

       return (
           config,
           input_ids,
           input_mask,
           head_mask,
           token_type_ids,
           sequence_labels,
           token_labels,
           choice_labels,
           encoder_hidden_states,
           encoder_attention_mask,
       )


  def _UpperCamelCase	(					self ,						snake_case_ ,						snake_case_ ,						snake_case_ ,						snake_case_ ,						snake_case_ ,						*snake_case_		):




       '''simple docstring'''

       UpperCAmelCase_				:  List[Any]  = True
       UpperCAmelCase_				:  Dict  = RwkvModel(config=snake_case_		)
       model.to(snake_case_		)
       model.eval()

       UpperCAmelCase_				:  List[Any]  = model(snake_case_		)

       self.parent.assertEqual(result.last_hidden_state.shape ,						(self.batch_size, self.seq_length, self.hidden_size)		)
       self.parent.assertEqual(len(result.hidden_states		) ,						config.num_hidden_layers + 1		)


  def _UpperCamelCase	(					self ,						snake_case_ ,						snake_case_ ,						snake_case_ ,						snake_case_ ,						snake_case_ ,						*snake_case_		):




       '''simple docstring'''

       UpperCAmelCase_				:  List[Any]  = RwkvForCausalLM(snake_case_		)
       model.to(snake_case_		)
       model.eval()

       UpperCAmelCase_				:  Tuple  = model(snake_case_ ,						labels=snake_case_		)
       self.parent.assertEqual(result.loss.shape ,						()		)
       self.parent.assertEqual(result.logits.shape ,						(self.batch_size, self.seq_length, self.vocab_size)		)


  def _UpperCamelCase	(					self ,						snake_case_ ,						snake_case_ ,						snake_case_ ,						snake_case_ ,						snake_case_ ,						*snake_case_		):




       '''simple docstring'''

       UpperCAmelCase_				:  List[Any]  = RwkvModel(config=snake_case_		)
       model.to(snake_case_		)
       model.eval()

       UpperCAmelCase_				:  Any  = model(snake_case_		)
       UpperCAmelCase_				:  int  = outputs.last_hidden_state

       UpperCAmelCase_				:  Union[str, Any]  = model(input_ids[:, :2]		)
       UpperCAmelCase_				:  List[Any]  = outputs.last_hidden_state

       # Using the state computed on the first inputs, we will get the same output
       UpperCAmelCase_				:  Dict  = model(input_ids[:, 2:] ,						state=outputs.state		)
       UpperCAmelCase_				:  Union[str, Any]  = outputs.last_hidden_state

       self.parent.assertTrue(torch.allclose(torch.cat([output_one, output_two] ,						dim=1		) ,						snake_case_ ,						atol=1E-5		)		)


  def _UpperCamelCase	(					self ,						snake_case_ ,						snake_case_ ,						snake_case_ ,						snake_case_ ,						snake_case_ ,						*snake_case_ ,						snake_case_=False		):




       '''simple docstring'''

       UpperCAmelCase_				:  Optional[Any]  = RwkvForCausalLM(snake_case_		)
       model.to(snake_case_		)
       if gradient_checkpointing:
            model.gradient_checkpointing_enable()

       UpperCAmelCase_				:  Any  = model(snake_case_ ,						labels=snake_case_		)
       self.parent.assertEqual(result.loss.shape ,						()		)
       self.parent.assertEqual(result.logits.shape ,						(self.batch_size, self.seq_length, self.vocab_size)		)
       result.loss.backward()






  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       UpperCAmelCase_				:  int  = self.prepare_config_and_inputs()

       (
           (
           UpperCAmelCase_
       )  ,     (
           UpperCAmelCase_
       )  ,     (
           UpperCAmelCase_
       )  ,     (
           UpperCAmelCase_
       )  ,     (
           UpperCAmelCase_
       )  ,     (
           UpperCAmelCase_
       )  ,     (
           UpperCAmelCase_
       )  ,     (
           UpperCAmelCase_
       )  ,     (
           UpperCAmelCase_
       )  ,     
       )				:  List[Any]  = config_and_inputs

       UpperCAmelCase_				:  List[Any]  = {'input_ids': input_ids}

       return config, inputs_dict







@unittest.skipIf(
    not is_torch_greater_or_equal_than_2_0		,      reason='''See https://github.com/huggingface/transformers/pull/24204'''			)
@require_torch
class 	__SCREAMING_SNAKE_CASE		(			lowerCamelCase_		,      lowerCamelCase_		,      lowerCamelCase_		,      unittest.TestCase			):







  '''simple docstring'''






  lowerCamelCase_						:Dict		       =						(RwkvModel, RwkvForCausalLM) if is_torch_available() else ()
  lowerCamelCase_						:Optional[int]		       =						(
      {'''feature-extraction''': RwkvModel, '''text-generation''': RwkvForCausalLM} if is_torch_available() else {}
  )
  # all_generative_model_classes = (RwkvForCausalLM,) if is_torch_available() else ()
  lowerCamelCase_						:Union[str, Any]		       =						False
  lowerCamelCase_						:Tuple		       =						False
  lowerCamelCase_						:Optional[Any]		       =						False
  lowerCamelCase_						:List[str]		       =						False
  lowerCamelCase_						:Dict		       =						False  # Rwkv does not support head masking


  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       UpperCAmelCase_				:  int  = RwkvModelTester(self		)
       UpperCAmelCase_				:  Union[str, Any]  = ConfigTester(
           self ,						config_class=snake_case_ ,						n_embd=3_7 ,						common_properties=['hidden_size', 'num_hidden_layers']		)


  def _UpperCamelCase	(					self ,						snake_case_ ,						snake_case_ ,						snake_case_=None		):




       '''simple docstring'''

       if isinstance(snake_case_ ,						torch.Tensor		):
            UpperCAmelCase_  ,     UpperCAmelCase_				:  str  = member.max().item(), member.min().item()
       elif isinstance(snake_case_ ,						snake_case_		) or isinstance(snake_case_ ,						snake_case_		):
            UpperCAmelCase_  ,     UpperCAmelCase_				:  Union[str, Any]  = max(snake_case_		), min(snake_case_		)

       if not isinstance(snake_case_ ,						snake_case_		):
            raise TypeError('container should be a list or tuple'		)
       elif len(snake_case_		) != 2:
            raise ValueError('container should have 2 elements'		)

       UpperCAmelCase_  ,     UpperCAmelCase_				:  Dict  = container

       UpperCAmelCase_				:  Optional[Any]  = (min_value >= expected_min) and (max_value <= expected_max)

       if not is_inside_interval:
            UpperCAmelCase_				:  int  = '%s not found in %s' % (safe_repr(snake_case_		), safe_repr(snake_case_		))
            self.fail(self._formatMessage(snake_case_ ,						snake_case_		)		)


  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       self.config_tester.run_common_tests()


  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       UpperCAmelCase_				:  Optional[Any]  = self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_rwkv_model(*snake_case_		)


  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       UpperCAmelCase_				:  str  = self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_causl_lm(*snake_case_		)


  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       UpperCAmelCase_				:  int  = self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_state_equivalency(*snake_case_		)


  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       UpperCAmelCase_  ,     UpperCAmelCase_				:  List[str]  = self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
            UpperCAmelCase_				:  str  = model_class(config=snake_case_		)
            for name, param in model.named_parameters():
                 if "time_decay" in name:
                      if param.requires_grad:
                           self.assertTrue(param.data.max().item() == 3.0		)
                           self.assertTrue(param.data.min().item() == -5.0		)
                 elif "time_first" in name:
                      if param.requires_grad:
                           # check if it's a ones like
                           self.assertTrue(torch.allclose(param.data ,						torch.ones_like(param.data		) ,						atol=1E-5 ,						rtol=1E-5		)		)
                 elif any(x in name for x in ['time_mix_key', 'time_mix_receptance']		):
                      if param.requires_grad:
                           self.assertInterval(
                               param.data ,						[0.0, 1.0] ,						msg=F'''Parameter {name} of model {model_class} seems not properly initialized''' ,						)
                 elif "time_mix_value" in name:
                      if param.requires_grad:
                           self.assertInterval(
                               param.data ,						[0.0, 1.3] ,						msg=F'''Parameter {name} of model {model_class} seems not properly initialized''' ,						)


  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       UpperCAmelCase_  ,     UpperCAmelCase_				:  Union[str, Any]  = self.model_tester.prepare_config_and_inputs_for_common()
       UpperCAmelCase_				:  Union[str, Any]  = True

       UpperCAmelCase_				:  List[Any]  = getattr(self.model_tester ,						'seq_length' ,						snake_case_		)

       for model_class in self.all_model_classes:
            UpperCAmelCase_				:  int  = True
            UpperCAmelCase_				:  Any  = False
            UpperCAmelCase_				:  Union[str, Any]  = True
            UpperCAmelCase_				:  List[Any]  = model_class(snake_case_		)
            model.to(snake_case_		)
            model.eval()

            UpperCAmelCase_				:  Any  = self._prepare_for_class(snake_case_ ,						snake_case_		)
            UpperCAmelCase_				:  List[Any]  = inputs['input_ids'].shape[0]
            with torch.no_grad():
                 UpperCAmelCase_				:  Any  = model(**snake_case_		)
            UpperCAmelCase_				:  Union[str, Any]  = outputs.attentions
            self.assertEqual(len(snake_case_		) ,						self.model_tester.num_hidden_layers		)

            # check that output_attentions also work using config
            del inputs_dict["output_attentions"]
            UpperCAmelCase_				:  Any  = True
            UpperCAmelCase_				:  Any  = model_class(snake_case_		)
            model.to(snake_case_		)
            model.eval()

            UpperCAmelCase_				:  List[Any]  = self._prepare_for_class(snake_case_ ,						snake_case_		)
            UpperCAmelCase_				:  Tuple  = inputs['input_ids'].shape[0]
            with torch.no_grad():
                 UpperCAmelCase_				:  List[Any]  = model(**snake_case_		)
            UpperCAmelCase_				:  Optional[int]  = outputs.attentions
            self.assertEqual(len(snake_case_		) ,						self.model_tester.num_hidden_layers		)

            self.assertListEqual(
                list(attentions[0].shape[-3:]		) ,						[batch_size, seq_len, config.hidden_size] ,						)
            UpperCAmelCase_				:  Any  = len(snake_case_		)

            # Check attention is always last and order is fine
            UpperCAmelCase_				:  Dict  = True
            UpperCAmelCase_				:  Optional[Any]  = True
            UpperCAmelCase_				:  Any  = model_class(snake_case_		)
            model.to(snake_case_		)
            model.eval()

            UpperCAmelCase_				:  Tuple  = self._prepare_for_class(snake_case_ ,						snake_case_		)
            UpperCAmelCase_				:  Any  = inputs['input_ids'].shape[0]
            with torch.no_grad():
                 UpperCAmelCase_				:  Tuple  = model(**snake_case_		)

            UpperCAmelCase_				:  Optional[Any]  = 1
            self.assertEqual(out_len + added_hidden_states ,						len(snake_case_		)		)

            UpperCAmelCase_				:  str  = outputs.attentions

            self.assertEqual(len(snake_case_		) ,						self.model_tester.num_hidden_layers		)
            self.assertListEqual(
                list(self_attentions[0].shape[-3:]		) ,						[batch_size, seq_len, config.hidden_size] ,						)






  @slow
  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       for model_name in RWKV_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            UpperCAmelCase_				:  int  = RwkvModel.from_pretrained(snake_case_		)
            self.assertIsNotNone(snake_case_		)







@unittest.skipIf(
    not is_torch_greater_or_equal_than_2_0		,      reason='''See https://github.com/huggingface/transformers/pull/24204'''			)
@slow
class 	__SCREAMING_SNAKE_CASE		(			unittest.TestCase			):







  '''simple docstring'''






  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       UpperCAmelCase_				:  Optional[int]  = 'RWKV/rwkv-4-169m-pile'
       UpperCAmelCase_				:  int  = AutoTokenizer.from_pretrained(self.model_id		)


  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       UpperCAmelCase_				:  List[Any]  = 'Hello my name is Jasmine and I am a newbie to the'
       UpperCAmelCase_				:  List[Any]  = RwkvForCausalLM.from_pretrained(self.model_id		).to(snake_case_		)

       UpperCAmelCase_				:  str  = self.tokenizer('Hello my name is' ,						return_tensors='pt'		).input_ids.to(snake_case_		)
       UpperCAmelCase_				:  Optional[int]  = model.generate(snake_case_ ,						max_new_tokens=1_0		)
       UpperCAmelCase_				:  Optional[int]  = self.tokenizer.decode(output[0].tolist()		)

       self.assertEqual(snake_case_ ,						snake_case_		)






  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       UpperCAmelCase_				:  Dict  = 'Hello my name is Jasmine and I am a newbie to the'

       UpperCAmelCase_				:  Any  = self.tokenizer('Hello my name is' ,						return_tensors='pt'		).input_ids.to(snake_case_		)
       UpperCAmelCase_				:  Dict  = RwkvForCausalLM.from_pretrained(self.model_id ,						torch_dtype=torch.bfloataa		).to(snake_case_		)

       UpperCAmelCase_				:  Any  = model.generate(snake_case_ ,						max_new_tokens=1_0		)
       UpperCAmelCase_				:  Tuple  = self.tokenizer.decode(output[0].tolist()		)

       self.assertEqual(snake_case_ ,						snake_case_		)








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




