






import tempfile
import unittest

from transformers import TaConfig, is_torch_available
from transformers.testing_utils import (
    require_sentencepiece,
    require_tokenizers,
    require_torch,
    slow,
    torch_device,
)

from ...generation.test_utils import GenerationTesterMixin
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
   import torch

   from transformers import AutoTokenizer, UMTaForConditionalGeneration, UMTaForQuestionAnswering, UMTaModel



class 				_A			:
    """simple docstring"""

    def __init__(				self      :     List[Any] ,     __SCREAMING_SNAKE_CASE      :     Tuple ,     __SCREAMING_SNAKE_CASE      :     List[str]=99 ,     __SCREAMING_SNAKE_CASE      :     int=13 ,     __SCREAMING_SNAKE_CASE      :     Any=7 ,     __SCREAMING_SNAKE_CASE      :     Union[str, Any]=9 ,     __SCREAMING_SNAKE_CASE      :     Any=True ,     __SCREAMING_SNAKE_CASE      :     Optional[Any]=True ,     __SCREAMING_SNAKE_CASE      :     Optional[Any]=False ,     __SCREAMING_SNAKE_CASE      :     Any=32 ,     __SCREAMING_SNAKE_CASE      :     int=5 ,     __SCREAMING_SNAKE_CASE      :     Optional[int]=4 ,     __SCREAMING_SNAKE_CASE      :     str=37 ,     __SCREAMING_SNAKE_CASE      :     Dict=8 ,     __SCREAMING_SNAKE_CASE      :     Optional[int]=0.1 ,     __SCREAMING_SNAKE_CASE      :     List[str]=0.002 ,     __SCREAMING_SNAKE_CASE      :     Union[str, Any]=1 ,     __SCREAMING_SNAKE_CASE      :     Union[str, Any]=0 ,     __SCREAMING_SNAKE_CASE      :     Union[str, Any]=0 ,     __SCREAMING_SNAKE_CASE      :     Dict=None ,     __SCREAMING_SNAKE_CASE      :     Union[str, Any]=None ,     )      ->							List[Any]:
           __UpperCAmelCase     				=parent
           __UpperCAmelCase     				=batch_size
           __UpperCAmelCase     				=encoder_seq_length
           __UpperCAmelCase     				=decoder_seq_length
           # For common tests
           __UpperCAmelCase     				=self.decoder_seq_length
           __UpperCAmelCase     				=is_training
           __UpperCAmelCase     				=use_attention_mask
           __UpperCAmelCase     				=use_labels
           __UpperCAmelCase     				=vocab_size
           __UpperCAmelCase     				=hidden_size
           __UpperCAmelCase     				=num_hidden_layers
           __UpperCAmelCase     				=num_attention_heads
           __UpperCAmelCase     				=d_ff
           __UpperCAmelCase     				=relative_attention_num_buckets
           __UpperCAmelCase     				=dropout_rate
           __UpperCAmelCase     				=initializer_factor
           __UpperCAmelCase     				=eos_token_id
           __UpperCAmelCase     				=pad_token_id
           __UpperCAmelCase     				=decoder_start_token_id
           __UpperCAmelCase     				=None
           __UpperCAmelCase     				=decoder_layers



    def _a							(				self      :     Dict      )      ->							List[str]:
           return TaConfig.from_pretrained("""google/umt5-base"""      )



    def _a							(				self      :     Union[str, Any] ,     __SCREAMING_SNAKE_CASE      :     str ,     __SCREAMING_SNAKE_CASE      :     Optional[Any] ,     __SCREAMING_SNAKE_CASE      :     Union[str, Any] ,     __SCREAMING_SNAKE_CASE      :     Union[str, Any]=None ,     __SCREAMING_SNAKE_CASE      :     str=None ,     __SCREAMING_SNAKE_CASE      :     List[str]=None ,     __SCREAMING_SNAKE_CASE      :     List[str]=None ,     __SCREAMING_SNAKE_CASE      :     Optional[Any]=None ,     )      ->							Any:
           if attention_mask is None:
                  __UpperCAmelCase     				=input_ids.ne(config.pad_token_id      )
           if decoder_attention_mask is None:
                  __UpperCAmelCase     				=decoder_input_ids.ne(config.pad_token_id      )
           if head_mask is None:
                  __UpperCAmelCase     				=torch.ones(config.num_hidden_layers ,     config.num_attention_heads ,     device=__SCREAMING_SNAKE_CASE      )
           if decoder_head_mask is None:
                  __UpperCAmelCase     				=torch.ones(config.num_decoder_layers ,     config.num_attention_heads ,     device=__SCREAMING_SNAKE_CASE      )
           if cross_attn_head_mask is None:
                  __UpperCAmelCase     				=torch.ones(
                      config.num_decoder_layers ,     config.num_attention_heads ,     device=__SCREAMING_SNAKE_CASE      )
           return {
               "input_ids": input_ids,
               "decoder_input_ids": decoder_input_ids,
               "attention_mask": attention_mask,
               "decoder_attention_mask": decoder_attention_mask,
               "head_mask": head_mask,
               "decoder_head_mask": decoder_head_mask,
               "cross_attn_head_mask": cross_attn_head_mask,
           }



    def _a							(				self      :     Optional[int]      )      ->							Union[str, Any]:
           __UpperCAmelCase     				=ids_tensor([self.batch_size, self.encoder_seq_length] ,     self.vocab_size      )
           __UpperCAmelCase     				=ids_tensor([self.batch_size, self.decoder_seq_length] ,     self.vocab_size      )

           # we need to clamp the input ids here to avoid having pad token in between
           # this is because for NllbMoe the position_ids are prepared such that
           # all pad tokens have pos id = 2 and rest are between 2..seq_length
           # and the seq_length here is seq_length - num_pad_tokens
           # but when using past, there is no way of knowing if the past input ids had
           # pad tokens in them, which results in incorrect seq_lenth and which in turn results in
           # position_ids being off by num_pad_tokens in past input
           __UpperCAmelCase     				=input_ids.clamp(self.pad_token_id + 1      )
           __UpperCAmelCase     				=decoder_input_ids.clamp(self.pad_token_id + 1      )

           __UpperCAmelCase     				=self.get_config()
           __UpperCAmelCase     				=config.num_attention_heads
           __UpperCAmelCase     				=self.prepare_inputs_dict(__SCREAMING_SNAKE_CASE ,     __SCREAMING_SNAKE_CASE ,     __SCREAMING_SNAKE_CASE      )
           return config, input_dict



    def _a							(				self      :     Optional[Any]      )      ->							Any:
           __UpperCAmelCase				, __UpperCAmelCase     				=self.prepare_config_and_inputs()
           return config, inputs_dict



    def _a							(				self      :     str      )      ->							Optional[int]:
           return TaConfig(
               vocab_size=166 ,     d_model=self.hidden_size ,     d_ff=self.d_ff ,     d_kv=self.hidden_size // self.num_attention_heads ,     num_layers=self.num_hidden_layers ,     num_decoder_layers=self.decoder_layers ,     num_heads=self.num_attention_heads ,     relative_attention_num_buckets=self.relative_attention_num_buckets ,     dropout_rate=self.dropout_rate ,     initializer_factor=self.initializer_factor ,     eos_token_id=self.eos_token_id ,     bos_token_id=self.pad_token_id ,     pad_token_id=self.pad_token_id ,     decoder_start_token_id=self.decoder_start_token_id ,     )



    def _a							(				self      :     Dict      )      ->							List[Any]:
           return TaConfig(
               vocab_size=self.vocab_size ,     d_model=self.hidden_size ,     d_ff=self.d_ff ,     d_kv=self.hidden_size // self.num_attention_heads ,     num_layers=self.num_hidden_layers ,     num_decoder_layers=self.decoder_layers ,     num_heads=self.num_attention_heads ,     relative_attention_num_buckets=self.relative_attention_num_buckets ,     dropout_rate=self.dropout_rate ,     initializer_factor=self.initializer_factor ,     eos_token_id=self.eos_token_id ,     bos_token_id=self.pad_token_id ,     pad_token_id=self.pad_token_id ,     decoder_start_token_id=self.decoder_start_token_id ,     )



    def _a							(				self      :     List[Any] ,     __SCREAMING_SNAKE_CASE      :     Union[str, Any] ,     __SCREAMING_SNAKE_CASE      :     List[str] ,     __SCREAMING_SNAKE_CASE      :     List[Any] ,     __SCREAMING_SNAKE_CASE      :     Union[str, Any] ,     __SCREAMING_SNAKE_CASE      :     Optional[Any] ,     __SCREAMING_SNAKE_CASE      :     Optional[int] ,     )      ->							List[Any]:
           __UpperCAmelCase     				=UMTaModel(config=__SCREAMING_SNAKE_CASE      )
           model.to(__SCREAMING_SNAKE_CASE      )
           model.eval()
           __UpperCAmelCase     				=model(
               input_ids=__SCREAMING_SNAKE_CASE ,     decoder_input_ids=__SCREAMING_SNAKE_CASE ,     attention_mask=__SCREAMING_SNAKE_CASE ,     decoder_attention_mask=__SCREAMING_SNAKE_CASE ,     )
           __UpperCAmelCase     				=model(input_ids=__SCREAMING_SNAKE_CASE ,     decoder_input_ids=__SCREAMING_SNAKE_CASE      )
           __UpperCAmelCase     				=result.last_hidden_state
           __UpperCAmelCase     				=result.past_key_values
           __UpperCAmelCase     				=result.encoder_last_hidden_state

           self.parent.assertEqual(encoder_output.size() ,     (self.batch_size, self.encoder_seq_length, self.hidden_size)      )
           self.parent.assertEqual(decoder_output.size() ,     (self.batch_size, self.decoder_seq_length, self.hidden_size)      )
           # There should be `num_layers` key value embeddings stored in decoder_past
           self.parent.assertEqual(len(__SCREAMING_SNAKE_CASE      ) ,     config.num_layers      )
           # There should be a self attn key, a self attn value, a cross attn key and a cross attn value stored in each decoder_past tuple
           self.parent.assertEqual(len(decoder_past[0]      ) ,     4      )



    def _a							(				self      :     int ,     __SCREAMING_SNAKE_CASE      :     Tuple ,     __SCREAMING_SNAKE_CASE      :     Union[str, Any] ,     __SCREAMING_SNAKE_CASE      :     Tuple ,     __SCREAMING_SNAKE_CASE      :     str ,     __SCREAMING_SNAKE_CASE      :     Dict ,     __SCREAMING_SNAKE_CASE      :     Tuple ,     )      ->							Dict:
           __UpperCAmelCase     				=UMTaModel(config=__SCREAMING_SNAKE_CASE      ).get_decoder().to(__SCREAMING_SNAKE_CASE      ).eval()
           # first forward pass
           __UpperCAmelCase     				=model(__SCREAMING_SNAKE_CASE ,     use_cache=__SCREAMING_SNAKE_CASE      )
           __UpperCAmelCase     				=model(__SCREAMING_SNAKE_CASE      )
           __UpperCAmelCase     				=model(__SCREAMING_SNAKE_CASE ,     use_cache=__SCREAMING_SNAKE_CASE      )

           self.parent.assertTrue(len(__SCREAMING_SNAKE_CASE      ) == len(__SCREAMING_SNAKE_CASE      )      )
           self.parent.assertTrue(len(__SCREAMING_SNAKE_CASE      ) == len(__SCREAMING_SNAKE_CASE      ) + 1      )

           __UpperCAmelCase				, __UpperCAmelCase     				=outputs.to_tuple()

           # create hypothetical next token and extent to next_input_ids
           __UpperCAmelCase     				=ids_tensor((self.batch_size, 1) ,     config.vocab_size      )

           # append to next input_ids and
           __UpperCAmelCase     				=torch.cat([input_ids, next_tokens] ,     dim=-1      )

           __UpperCAmelCase     				=model(__SCREAMING_SNAKE_CASE      )["""last_hidden_state"""]
           __UpperCAmelCase     				=model(__SCREAMING_SNAKE_CASE ,     past_key_values=__SCREAMING_SNAKE_CASE      )["""last_hidden_state"""]

           # select random slice
           __UpperCAmelCase     				=ids_tensor((1,) ,     output_from_past.shape[-1]      ).item()
           __UpperCAmelCase     				=output_from_no_past[:, -1, random_slice_idx].detach()
           __UpperCAmelCase     				=output_from_past[:, 0, random_slice_idx].detach()

           # test that outputs are equal for slice
           self.parent.assertTrue(torch.allclose(__SCREAMING_SNAKE_CASE ,     __SCREAMING_SNAKE_CASE ,     atol=1e-3      )      )



    def _a							(				self      :     List[str] ,     __SCREAMING_SNAKE_CASE      :     List[Any] ,     __SCREAMING_SNAKE_CASE      :     Any ,     )      ->							Any:
           __UpperCAmelCase     				=UMTaModel(config=__SCREAMING_SNAKE_CASE      ).to(__SCREAMING_SNAKE_CASE      ).half().eval()
           __UpperCAmelCase     				=model(**__SCREAMING_SNAKE_CASE      )["""last_hidden_state"""]
           self.parent.assertFalse(torch.isnan(__SCREAMING_SNAKE_CASE      ).any().item()      )




@require_torch
class 				_A			(     UpperCamelCase					,					UpperCamelCase					,					UpperCamelCase					,					unittest.TestCase				):
    """simple docstring"""

    lowerCamelCase	:							Optional[Any]				= (
        (UMTaModel, UMTaForConditionalGeneration, UMTaForQuestionAnswering) if is_torch_available() else ()
    )
    lowerCamelCase	:							str				= (UMTaForConditionalGeneration,) if is_torch_available() else ()
    lowerCamelCase	:							Tuple				= (
        {
            'conversational': UMTaForConditionalGeneration,
            'feature-extraction': UMTaModel,
            'summarization': UMTaForConditionalGeneration,
            'text2text-generation': UMTaForConditionalGeneration,
            'translation': UMTaForConditionalGeneration,
            'question-answering': UMTaForQuestionAnswering,
        }
        if is_torch_available()
        else {}
    )
    lowerCamelCase	:							Dict				= True
    lowerCamelCase	:							Optional[Any]				= False
    lowerCamelCase	:							List[str]				= False
    lowerCamelCase	:							int				= True
    lowerCamelCase	:							Optional[Any]				= True
    # The small UMT5 model needs higher percentages for CPU/MP tests
    lowerCamelCase	:							Dict				= [0.8, 0.9]



    def _a							(				self      :     int      )      ->							Any:
           __UpperCAmelCase     				=UMTaModelTester(self      )



    @unittest.skip("""Test has a segmentation fault on torch 1.8.0"""      )
    def _a							(				self      :     str      )      ->							Any:
           __UpperCAmelCase     				=self.model_tester.prepare_config_and_inputs()
           __UpperCAmelCase     				=UMTaModel(config_and_inputs[0]      ).to(__SCREAMING_SNAKE_CASE      )
           with tempfile.TemporaryDirectory() as tmpdirname:
                  torch.onnx.export(
                      __SCREAMING_SNAKE_CASE ,     (config_and_inputs[1], config_and_inputs[3], config_and_inputs[2]) ,     f'''{tmpdirname}/t5_test.onnx''' ,     export_params=__SCREAMING_SNAKE_CASE ,     opset_version=9 ,     input_names=["""input_ids""", """decoder_input_ids"""] ,     )



    @unittest.skipIf(torch_device == """cpu""" ,     """Cant do half precision"""      )
    def _a							(				self      :     int      )      ->							Dict:
           __UpperCAmelCase     				=self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model_fpaa_forward(*__SCREAMING_SNAKE_CASE      )



    def _a							(				self      :     Dict      )      ->							Union[str, Any]:
           __UpperCAmelCase     				=["""encoder_attentions""", """decoder_attentions""", """cross_attentions"""]
           __UpperCAmelCase     				=self.model_tester.prepare_config_and_inputs()
           __UpperCAmelCase     				=config_and_inputs[0]
           __UpperCAmelCase     				=UMTaForConditionalGeneration(__SCREAMING_SNAKE_CASE      ).eval()
           model.to(__SCREAMING_SNAKE_CASE      )

           __UpperCAmelCase     				={
               """head_mask""": torch.zeros(config.num_layers ,     config.num_heads ,     device=__SCREAMING_SNAKE_CASE      ),
               """decoder_head_mask""": torch.zeros(config.num_decoder_layers ,     config.num_heads ,     device=__SCREAMING_SNAKE_CASE      ),
               """cross_attn_head_mask""": torch.zeros(config.num_decoder_layers ,     config.num_heads ,     device=__SCREAMING_SNAKE_CASE      ),
           }

           for attn_name, (name, mask) in zip(__SCREAMING_SNAKE_CASE ,     head_masking.items()      ):
                  __UpperCAmelCase     				={name: mask}
                  # Explicitly pass decoder_head_mask as it is required from T5 model when head_mask specified
                  if name == "head_mask":
                         __UpperCAmelCase     				=torch.ones(
                             config.num_decoder_layers ,     config.num_heads ,     device=__SCREAMING_SNAKE_CASE      )

                  __UpperCAmelCase     				=model.generate(
                      config_and_inputs[1]["""input_ids"""] ,     num_beams=1 ,     max_length=3 ,     output_attentions=__SCREAMING_SNAKE_CASE ,     return_dict_in_generate=__SCREAMING_SNAKE_CASE ,     **__SCREAMING_SNAKE_CASE ,     )
                  # We check the state of decoder_attentions and cross_attentions just from the last step
                  __UpperCAmelCase     				=out[attn_name] if attn_name == attention_names[0] else out[attn_name][-1]
                  self.assertEqual(sum([w.sum().item() for w in attn_weights]      ) ,     0.0      )



    @unittest.skip("""Does not work on the tiny model as we keep hitting edge cases."""      )
    def _a							(				self      :     str      )      ->							str:
           pass




@require_torch
@require_sentencepiece
@require_tokenizers
class 				_A			(     unittest.TestCase				):
    """simple docstring"""

    @slow
    @unittest.skip(
        """Unless we stop stripping left and right by default for all special tokens, the expected ids obtained here will not match the original ones. Wait for https://github.com/huggingface/transformers/pull/23909 to be merged"""      )
    def _a							(				self      :     List[Any]      )      ->							Dict:
           __UpperCAmelCase     				=UMTaForConditionalGeneration.from_pretrained("""google/umt5-small""" ,     return_dict=__SCREAMING_SNAKE_CASE      ).to(__SCREAMING_SNAKE_CASE      )
           __UpperCAmelCase     				=AutoTokenizer.from_pretrained("""google/umt5-small""" ,     use_fast=__SCREAMING_SNAKE_CASE ,     legacy=__SCREAMING_SNAKE_CASE      )
           __UpperCAmelCase     				=[
               """Bonjour monsieur <extra_id_0> bien <extra_id_1>.""",
               """No se como puedo <extra_id_0>.""",
               """This is the reason why we <extra_id_0> them.""",
               """The <extra_id_0> walks in <extra_id_1>, seats""",
               """A <extra_id_0> walks into a bar and orders a <extra_id_1> with <extra_id_2> pinch of <extra_id_3>.""",
           ]
           __UpperCAmelCase     				=tokenizer(__SCREAMING_SNAKE_CASE ,     return_tensors="""pt""" ,     padding=__SCREAMING_SNAKE_CASE      ).input_ids
           # fmt: off
           __UpperCAmelCase     				=torch.tensor(
               [
                   [ 38530, 210703, 256299, 1410, 256298, 274, 1, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0],
                   [   826, 321, 671, 25922, 256299, 274, 1, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0],
                   [  1460, 339, 312, 19014, 10620, 758, 256299, 2355,274, 1, 0, 0, 0, 0, 0, 0,0, 0],
                   [   517, 256299, 14869, 281, 301, 256298, 275, 119983,1, 0, 0, 0, 0, 0, 0, 0,0, 0],
                   [   320, 256299, 14869, 281, 2234, 289, 2275, 333,61391, 289, 256298, 543, 256297, 168714, 329, 256296,274, 1],
               ]      )
           # fmt: on
           torch.testing.assert_allclose(__SCREAMING_SNAKE_CASE ,     __SCREAMING_SNAKE_CASE      )

           __UpperCAmelCase     				=model.generate(input_ids.to(__SCREAMING_SNAKE_CASE      )      )
           __UpperCAmelCase     				=[
               """<pad><extra_id_0> et<extra_id_1> [eod] <extra_id_2><extra_id_55>.. [eod] 💐 💐 💐 💐 💐 💐 💐 💐 💐 💐 💐 <extra_id_56>ajšietosto<extra_id_56>lleux<extra_id_19><extra_id_6>ajšie</s>""",
               """<pad><extra_id_0>.<extra_id_1>.,<0x0A>...spech <0x0A><extra_id_20> <extra_id_21></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>""",
               """<pad><extra_id_0> are not going to be a part of the world. We are not going to be a part of<extra_id_1> and<extra_id_2><0x0A><extra_id_48>.<extra_id_48></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>""",
               """<pad><extra_id_0> door<extra_id_1>, the door<extra_id_2> 피해[/</s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>""",
               """<pad><extra_id_0>nyone who<extra_id_1> drink<extra_id_2> a<extra_id_3> alcohol<extra_id_4> A<extra_id_5> A. This<extra_id_6> I<extra_id_7><extra_id_52><extra_id_53></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>""",
           ]
           __UpperCAmelCase     				=tokenizer.batch_decode(__SCREAMING_SNAKE_CASE      )
           self.assertEqual(__SCREAMING_SNAKE_CASE ,     __SCREAMING_SNAKE_CASE      )











'''simple docstring'''

import inspect
import unittest

from transformers import RegNetConfig
from transformers.file_utils import cached_property, is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

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


if is_torch_available():
    import torch
    from torch import nn

    from transformers import RegNetForImageClassification, RegNetModel
    from transformers.models.regnet.modeling_regnet import REGNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
    from PIL import Image

    from transformers import AutoImageProcessor







class __a			:





   def __init__(       self					:      Any					,lowerCamelCase					:      Any					,lowerCamelCase					:      int=3					,lowerCamelCase					:      Optional[int]=32					,lowerCamelCase					:      Any=3					,lowerCamelCase					:      Dict=10					,lowerCamelCase					:      Union[str, Any]=[10, 20, 30, 40]					,lowerCamelCase					:      Any=[1, 1, 2, 1]					,lowerCamelCase					:      int=True					,lowerCamelCase					:      Optional[Any]=True					,lowerCamelCase					:      Dict="relu"					,lowerCamelCase					:      str=3					,lowerCamelCase					:      Union[str, Any]=None					,):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							parent
      __SCREAMING_SNAKE_CASE   				=							batch_size
      __SCREAMING_SNAKE_CASE   				=							image_size
      __SCREAMING_SNAKE_CASE   				=							num_channels
      __SCREAMING_SNAKE_CASE   				=							embeddings_size
      __SCREAMING_SNAKE_CASE   				=							hidden_sizes
      __SCREAMING_SNAKE_CASE   				=							depths
      __SCREAMING_SNAKE_CASE   				=							is_training
      __SCREAMING_SNAKE_CASE   				=							use_labels
      __SCREAMING_SNAKE_CASE   				=							hidden_act
      __SCREAMING_SNAKE_CASE   				=							num_labels
      __SCREAMING_SNAKE_CASE   				=							scope
      __SCREAMING_SNAKE_CASE   				=							len(lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      Union[str, Any]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )

      __SCREAMING_SNAKE_CASE   				=							None
      if self.use_labels:
         __SCREAMING_SNAKE_CASE   				=							ids_tensor([self.batch_size]					,self.num_labels     )

      __SCREAMING_SNAKE_CASE   				=							self.get_config()

      return config, pixel_values, labels





   def   UpperCAmelCase__  (       self					:      Any     ):

      '''simple docstring'''

      return RegNetConfig(
          num_channels=self.num_channels					,embeddings_size=self.embeddings_size					,hidden_sizes=self.hidden_sizes					,depths=self.depths					,hidden_act=self.hidden_act					,num_labels=self.num_labels					,)





   def   UpperCAmelCase__  (       self					:      Tuple					,lowerCamelCase					:      int					,lowerCamelCase					:      List[str]					,lowerCamelCase					:      Optional[int]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							RegNetModel(config=lowerCamelCase     )
      model.to(lowerCamelCase     )
      model.eval()
      __SCREAMING_SNAKE_CASE   				=							model(lowerCamelCase     )
      # expected last hidden states: B, C, H // 32, W // 32
      self.parent.assertEqual(
          result.last_hidden_state.shape					,(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)					,)





   def   UpperCAmelCase__  (       self					:      List[Any]					,lowerCamelCase					:      int					,lowerCamelCase					:      Dict					,lowerCamelCase					:      Any     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							self.num_labels
      __SCREAMING_SNAKE_CASE   				=							RegNetForImageClassification(lowerCamelCase     )
      model.to(lowerCamelCase     )
      model.eval()
      __SCREAMING_SNAKE_CASE   				=							model(lowerCamelCase					,labels=lowerCamelCase     )
      self.parent.assertEqual(result.logits.shape					,(self.batch_size, self.num_labels)     )





   def   UpperCAmelCase__  (       self					:      Dict     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							self.prepare_config_and_inputs()
      __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE   				=							config_and_inputs
      __SCREAMING_SNAKE_CASE   				=							{"""pixel_values""": pixel_values}
      return config, inputs_dict







@require_torch
class __a			( _snake_case, _snake_case, unittest.TestCase      ):
   __UpperCamelCase :			List[str]						   =						(RegNetModel, RegNetForImageClassification) if is_torch_available() else ()
   __UpperCamelCase :			Optional[int]						   =						(
       {'feature-extraction': RegNetModel, 'image-classification': RegNetForImageClassification}
       if is_torch_available()
       else {}
   )

   __UpperCamelCase :			Dict						   =						False
   __UpperCamelCase :			str						   =						False
   __UpperCamelCase :			Any						   =						False
   __UpperCamelCase :			Tuple						   =						False





   def   UpperCAmelCase__  (       self					:      List[str]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							RegNetModelTester(self     )
      __SCREAMING_SNAKE_CASE   				=							ConfigTester(self					,config_class=lowerCamelCase					,has_text_modality=lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      Optional[int]     ):

      '''simple docstring'''

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





   def   UpperCAmelCase__  (       self					:      Any     ):

      '''simple docstring'''

      return





   @unittest.skip(reason="""RegNet does not use inputs_embeds"""     )
   def   UpperCAmelCase__  (       self					:      str     ):

      '''simple docstring'''

      pass





   @unittest.skip(reason="""RegNet does not support input and output embeddings"""     )
   def   UpperCAmelCase__  (       self					:      Tuple     ):

      '''simple docstring'''

      pass





   def   UpperCAmelCase__  (       self					:      Tuple     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE   				=							self.model_tester.prepare_config_and_inputs_for_common()

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

         __SCREAMING_SNAKE_CASE   				=							["""pixel_values"""]
         self.assertListEqual(arg_names[:1]					,lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      Any     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      int     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE   				=							self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
         __SCREAMING_SNAKE_CASE   				=							model_class(config=lowerCamelCase     )
         for name, module in model.named_modules():
            if isinstance(lowerCamelCase					,(nn.BatchNormad, nn.GroupNorm)     ):
               self.assertTrue(
                   torch.all(module.weight == 1     )					,msg=f"""Parameter {name} of model {model_class} seems not properly initialized"""					,)
               self.assertTrue(
                   torch.all(module.bias == 0     )					,msg=f"""Parameter {name} of model {model_class} seems not properly initialized"""					,)





   def   UpperCAmelCase__  (       self					:      Tuple     ):

      '''simple docstring'''

      def check_hidden_states_output(lowerCamelCase					:      Union[str, Any]					,lowerCamelCase					:      Tuple					,lowerCamelCase					:      Optional[int]     ):
         __SCREAMING_SNAKE_CASE   				=							model_class(lowerCamelCase     )
         model.to(lowerCamelCase     )
         model.eval()

         with torch.no_grad():
            __SCREAMING_SNAKE_CASE   				=							model(**self._prepare_for_class(lowerCamelCase					,lowerCamelCase     )     )

         __SCREAMING_SNAKE_CASE   				=							outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

         __SCREAMING_SNAKE_CASE   				=							self.model_tester.num_stages
         self.assertEqual(len(lowerCamelCase     )					,expected_num_stages + 1     )

         # RegNet's feature maps are of shape (batch_size, num_channels, height, width)
         self.assertListEqual(
             list(hidden_states[0].shape[-2:]     )					,[self.model_tester.image_size // 2, self.model_tester.image_size // 2]					,)

      __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE   				=							self.model_tester.prepare_config_and_inputs_for_common()
      __SCREAMING_SNAKE_CASE   				=							["""basic""", """bottleneck"""]
      for model_class in self.all_model_classes:
         for layer_type in layers_type:
            __SCREAMING_SNAKE_CASE   				=							layer_type
            __SCREAMING_SNAKE_CASE   				=							True
            check_hidden_states_output(lowerCamelCase					,lowerCamelCase					,lowerCamelCase     )

            # check that output_hidden_states also work using config
            del inputs_dict["output_hidden_states"]
            __SCREAMING_SNAKE_CASE   				=							True

            check_hidden_states_output(lowerCamelCase					,lowerCamelCase					,lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      Dict     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*lowerCamelCase     )





   @slow
   def   UpperCAmelCase__  (       self					:      Union[str, Any]     ):

      '''simple docstring'''

      for model_name in REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         __SCREAMING_SNAKE_CASE   				=							RegNetModel.from_pretrained(lowerCamelCase     )
         self.assertIsNotNone(lowerCamelCase     )





def     __magic_name__							(				)    ->       List[Any]:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE   				=							Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""   )
   return image







@require_torch
@require_vision
class __a			( unittest.TestCase      ):





   @cached_property
   def   UpperCAmelCase__  (       self					:      List[str]     ):

      '''simple docstring'''

      return (
          AutoImageProcessor.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]     )
          if is_vision_available()
          else None
      )





   @slow
   def   UpperCAmelCase__  (       self					:      int     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							RegNetForImageClassification.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]     ).to(lowerCamelCase     )

      __SCREAMING_SNAKE_CASE   				=							self.default_image_processor
      __SCREAMING_SNAKE_CASE   				=							prepare_img()
      __SCREAMING_SNAKE_CASE   				=							image_processor(images=lowerCamelCase					,return_tensors="""pt"""     ).to(lowerCamelCase     )

      # forward pass
      with torch.no_grad():
         __SCREAMING_SNAKE_CASE   				=							model(**lowerCamelCase     )

      # verify the logits
      __SCREAMING_SNAKE_CASE   				=							torch.Size((1, 1000)     )
      self.assertEqual(outputs.logits.shape					,lowerCamelCase     )

      __SCREAMING_SNAKE_CASE   				=							torch.tensor([-0.4_180, -1.5_051, -3.4_836]     ).to(lowerCamelCase     )

      self.assertTrue(torch.allclose(outputs.logits[0, :3]					,lowerCamelCase					,atol=1E-4     )     )





