






from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import ResNetConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
 import tensorflow as tf

 from transformers import TFResNetForImageClassification, TFResNetModel
 from transformers.models.resnet.modeling_tf_resnet import TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
 from PIL import Image

 from transformers import AutoImageProcessor





class 			__a  :







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


      '''simple docstring'''






      UpperCamelCase__			:   Optional[int]       				=  parent
      UpperCamelCase__			:   Optional[Any]       				=  batch_size
      UpperCamelCase__			:   Union[str, Any]       				=  image_size
      UpperCamelCase__			:   str       				=  num_channels
      UpperCamelCase__			:   List[str]       				=  embeddings_size
      UpperCamelCase__			:   Dict       				=  hidden_sizes
      UpperCamelCase__			:   List[Any]       				=  depths
      UpperCamelCase__			:   Union[str, Any]       				=  is_training
      UpperCamelCase__			:   Optional[int]       				=  use_labels
      UpperCamelCase__			:   List[Any]       				=  hidden_act
      UpperCamelCase__			:   Dict       				=  num_labels
      UpperCamelCase__			:   int       				=  scope
      UpperCamelCase__			:   Optional[int]       				=  len(SCREAMING_SNAKE_CASE						)







 def 					__lowercase					(		self					:   List[Any]						):


      '''simple docstring'''






      UpperCamelCase__			:   Union[str, Any]       				=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

      UpperCamelCase__			:   Optional[int]       				=  None
      if self.use_labels:
           UpperCamelCase__			:   int       				=  ids_tensor([self.batch_size]							,   self.num_labels						)

      UpperCamelCase__			:   str       				=  self.get_config()

      return config, pixel_values, labels







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


      '''simple docstring'''






      return ResNetConfig(
          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							,   image_size=self.image_size							,   )







 def 					__lowercase					(		self					:   Optional[int]							,   SCREAMING_SNAKE_CASE					:   List[str]							,   SCREAMING_SNAKE_CASE					:   Any							,   SCREAMING_SNAKE_CASE					:   Optional[int]						):


      '''simple docstring'''






      UpperCamelCase__			:   List[Any]       				=  TFResNetModel(config=SCREAMING_SNAKE_CASE						)
      UpperCamelCase__			:   Any       				=  model(SCREAMING_SNAKE_CASE						)
      # 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 					__lowercase					(		self					:   str							,   SCREAMING_SNAKE_CASE					:   Any							,   SCREAMING_SNAKE_CASE					:   Any							,   SCREAMING_SNAKE_CASE					:   Tuple						):


      '''simple docstring'''






      UpperCamelCase__			:   Union[str, Any]       				=  self.num_labels
      UpperCamelCase__			:   List[str]       				=  TFResNetForImageClassification(SCREAMING_SNAKE_CASE						)
      UpperCamelCase__			:   Dict       				=  model(SCREAMING_SNAKE_CASE							,   labels=SCREAMING_SNAKE_CASE						)
      self.parent.assertEqual(result.logits.shape							,   (self.batch_size, self.num_labels)						)







 def 					__lowercase					(		self					:   List[Any]						):


      '''simple docstring'''






      UpperCamelCase__			:   Optional[Any]       				=  self.prepare_config_and_inputs()
      UpperCamelCase__				,     UpperCamelCase__				,     UpperCamelCase__			:   Optional[int]       				=  config_and_inputs
      UpperCamelCase__			:   List[Any]       				=  {"pixel_values": pixel_values}
      return config, inputs_dict







@require_tf
class 			__a  (    A__       ,   A__       ,   unittest.TestCase       ):
 _lowerCAmelCase       :       Union[str, Any]        = (TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
 _lowerCAmelCase       :       List[str]        = (
     {'''feature-extraction''': TFResNetModel, '''image-classification''': TFResNetForImageClassification}
     if is_tf_available()
     else {}
 )

 _lowerCAmelCase       :       Optional[Any]        = False
 _lowerCAmelCase       :       str        = False
 _lowerCAmelCase       :       str        = False
 _lowerCAmelCase       :       Optional[int]        = False
 _lowerCAmelCase       :       str        = False







 def 					__lowercase					(		self					:   Dict						):


      '''simple docstring'''






      UpperCamelCase__			:   Optional[Any]       				=  TFResNetModelTester(self						)
      UpperCamelCase__			:   Optional[Any]       				=  ConfigTester(self							,   config_class=SCREAMING_SNAKE_CASE							,   has_text_modality=SCREAMING_SNAKE_CASE						)







 def 					__lowercase					(		self					:   Any						):


      '''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 					__lowercase					(		self					:   Tuple						):


      '''simple docstring'''






      return







 @unittest.skip(reason="ResNet does not use inputs_embeds"						)
 def 					__lowercase					(		self					:   int						):


      '''simple docstring'''






      pass







 @unittest.skip(reason="ResNet does not support input and output embeddings"						)
 def 					__lowercase					(		self					:   Optional[Any]						):


      '''simple docstring'''






      pass







 def 					__lowercase					(		self					:   List[Any]						):


      '''simple docstring'''






      UpperCamelCase__				,     UpperCamelCase__			:   Tuple       				=  self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
           UpperCamelCase__			:   Tuple       				=  model_class(SCREAMING_SNAKE_CASE						)
           UpperCamelCase__			:   int       				=  inspect.signature(model.call						)
           # signature.parameters is an OrderedDict => so arg_names order is deterministic
           UpperCamelCase__			:   Any       				=  [*signature.parameters.keys()]

           UpperCamelCase__			:   Dict       				=  ["pixel_values"]
           self.assertListEqual(arg_names[:1]							,   SCREAMING_SNAKE_CASE						)







 def 					__lowercase					(		self					:   Dict						):


      '''simple docstring'''






      UpperCamelCase__			:   Optional[int]       				=  self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE						)







 def 					__lowercase					(		self					:   Dict						):


      '''simple docstring'''






      def check_hidden_states_output(SCREAMING_SNAKE_CASE					:   Optional[int]							,   SCREAMING_SNAKE_CASE					:   Optional[Any]							,   SCREAMING_SNAKE_CASE					:   str						):
           UpperCamelCase__			:   Any       				=  model_class(SCREAMING_SNAKE_CASE						)
           UpperCamelCase__			:   str       				=  model(**self._prepare_for_class(SCREAMING_SNAKE_CASE							,   SCREAMING_SNAKE_CASE						)						)

           UpperCamelCase__			:   List[Any]       				=  outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

           UpperCamelCase__			:   Any       				=  self.model_tester.num_stages
           self.assertEqual(len(SCREAMING_SNAKE_CASE						)							,   expected_num_stages + 1						)

           # ResNet'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 // 4, self.model_tester.image_size // 4]							,   )

      UpperCamelCase__				,     UpperCamelCase__			:   Optional[Any]       				=  self.model_tester.prepare_config_and_inputs_for_common()
      UpperCamelCase__			:   Union[str, Any]       				=  ["basic", "bottleneck"]
      for model_class in self.all_model_classes:
           for layer_type in layers_type:
                UpperCamelCase__			:   Optional[Any]       				=  layer_type
                UpperCamelCase__			:   Dict       				=  True
                check_hidden_states_output(SCREAMING_SNAKE_CASE							,   SCREAMING_SNAKE_CASE							,   SCREAMING_SNAKE_CASE						)

                # check that output_hidden_states also work using config
                del inputs_dict["output_hidden_states"]
                UpperCamelCase__			:   Union[str, Any]       				=  True

                check_hidden_states_output(SCREAMING_SNAKE_CASE							,   SCREAMING_SNAKE_CASE							,   SCREAMING_SNAKE_CASE						)







 def 					__lowercase					(		self					:   List[str]						):


      '''simple docstring'''






      UpperCamelCase__			:   int       				=  self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE						)







 @slow
 def 					__lowercase					(		self					:   Optional[int]						):


      '''simple docstring'''






      for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           UpperCamelCase__			:   Union[str, Any]       				=  TFResNetModel.from_pretrained(SCREAMING_SNAKE_CASE						)
           self.assertIsNotNone(SCREAMING_SNAKE_CASE						)







def 		SCREAMING_SNAKE_CASE							(					) ->	Any:
     UpperCamelCase__			:   List[str]       				=  Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"			)
     return image





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







 @cached_property
 def 					__lowercase					(		self					:   List[Any]						):


      '''simple docstring'''






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







 @slow
 def 					__lowercase					(		self					:   List[Any]						):


      '''simple docstring'''






      UpperCamelCase__			:   List[Any]       				=  TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]						)

      UpperCamelCase__			:   Optional[int]       				=  self.default_image_processor
      UpperCamelCase__			:   Dict       				=  prepare_img()
      UpperCamelCase__			:   List[str]       				=  image_processor(images=SCREAMING_SNAKE_CASE							,   return_tensors="tf"						)

      # forward pass
      UpperCamelCase__			:   Dict       				=  model(**SCREAMING_SNAKE_CASE						)

      # verify the logits
      UpperCamelCase__			:   List[Any]       				=  tf.TensorShape((1, 10_00)						)
      self.assertEqual(outputs.logits.shape							,   SCREAMING_SNAKE_CASE						)

      UpperCamelCase__			:   Optional[Any]       				=  tf.constant([-1_1.1_0_6_9, -9.7_8_7_7, -8.3_7_7_7]						)

      self.assertTrue(np.allclose(outputs.logits[0, :3].numpy()							,   SCREAMING_SNAKE_CASE							,   atol=1e-4						)						)







from google.protobuf import descriptor as _descriptor
from google.protobuf import descriptor_pool as _descriptor_pool
from google.protobuf import symbol_database as _symbol_database
from google.protobuf.internal import builder as _builder


# @@protoc_insertion_point(imports)

lowerCamelCase	:							Tuple				=_symbol_database.Default()


lowerCamelCase	:							List[str]				=_descriptor_pool.Default().AddSerializedFile(
    b'''\n\x19sentencepiece_model.proto\x12\rsentencepiece"\x80\x0c\n\x0bTrainerSpec\x12\r\n\x05input\x18\x01 \x03(\t\x12\x14\n\x0cinput_format\x18\x07 \x01(\t\x12\x14\n\x0cmodel_prefix\x18\x02 \x01(\t\x12\x41\n\nmodel_type\x18\x03 \x01(\x0e\x32$.sentencepiece.TrainerSpec.ModelType:\x07UNIGRAM\x12\x18\n\nvocab_size\x18\x04 \x01(\x05:\x04\x38\x30\x30\x30\x12\x17\n\x0f\x61\x63\x63\x65pt_language\x18\x05 \x03(\t\x12 \n\x15self_test_sample_size\x18\x06 \x01(\x05:\x01\x30\x12*\n\x1b\x65nable_differential_privacy\x18\x32 \x01(\x08:\x05\x66\x61lse\x12+\n differential_privacy_noise_level\x18\x33 \x01(\x02:\x01\x30\x12\x32\n\'differential_privacy_clipping_threshold\x18\x34 \x01(\x04:\x01\x30\x12"\n\x12\x63haracter_coverage\x18\n \x01(\x02:\x06\x30.9995\x12\x1e\n\x13input_sentence_size\x18\x0b \x01(\x04:\x01\x30\x12$\n\x16shuffle_input_sentence\x18\x13 \x01(\x08:\x04true\x12 \n\x14mining_sentence_size\x18\x0c \x01(\x05\x42\x02\x18\x01\x12"\n\x16training_sentence_size\x18\r \x01(\x05\x42\x02\x18\x01\x12(\n\x17seed_sentencepiece_size\x18\x0e \x01(\x05:\x07\x31\x30\x30\x30\x30\x30\x30\x12\x1e\n\x10shrinking_factor\x18\x0f \x01(\x02:\x04\x30.75\x12!\n\x13max_sentence_length\x18\x12 \x01(\x05:\x04\x34\x31\x39\x32\x12\x17\n\x0bnum_threads\x18\x10 \x01(\x05:\x02\x31\x36\x12\x1d\n\x12num_sub_iterations\x18\x11 \x01(\x05:\x01\x32\x12$\n\x18max_sentencepiece_length\x18\x14 \x01(\x05:\x02\x31\x36\x12%\n\x17split_by_unicode_script\x18\x15 \x01(\x08:\x04true\x12\x1d\n\x0fsplit_by_number\x18\x17 \x01(\x08:\x04true\x12!\n\x13split_by_whitespace\x18\x16 \x01(\x08:\x04true\x12)\n\x1atreat_whitespace_as_suffix\x18\x18 \x01(\x08:\x05\x66\x61lse\x12+\n\x1c\x61llow_whitespace_only_pieces\x18\x1a \x01(\x08:\x05\x66\x61lse\x12\x1b\n\x0csplit_digits\x18\x19 \x01(\x08:\x05\x66\x61lse\x12#\n\x19pretokenization_delimiter\x18\x35 \x01(\t:\x00\x12\x17\n\x0f\x63ontrol_symbols\x18\x1e \x03(\t\x12\x1c\n\x14user_defined_symbols\x18\x1f \x03(\t\x12\x16\n\x0erequired_chars\x18$ \x01(\t\x12\x1c\n\rbyte_fallback\x18# \x01(\x08:\x05\x66\x61lse\x12+\n\x1dvocabulary_output_piece_score\x18  \x01(\x08:\x04true\x12\x1e\n\x10hard_vocab_limit\x18! \x01(\x08:\x04true\x12\x1c\n\ruse_all_vocab\x18" \x01(\x08:\x05\x66\x61lse\x12\x11\n\x06unk_id\x18( \x01(\x05:\x01\x30\x12\x11\n\x06\x62os_id\x18) \x01(\x05:\x01\x31\x12\x11\n\x06\x65os_id\x18* \x01(\x05:\x01\x32\x12\x12\n\x06pad_id\x18+ \x01(\x05:\x02-1\x12\x18\n\tunk_piece\x18- \x01(\t:\x05<unk>\x12\x16\n\tbos_piece\x18. \x01(\t:\x03<s>\x12\x17\n\teos_piece\x18/ \x01(\t:\x04</s>\x12\x18\n\tpad_piece\x18\x30 \x01(\t:\x05<pad>\x12\x1a\n\x0bunk_surface\x18, \x01(\t:\x05 \xe2\x81\x87 \x12+\n\x1ctrain_extremely_large_corpus\x18\x31 \x01(\x08:\x05\x66\x61lse"5\n\tModelType\x12\x0b\n\x07UNIGRAM\x10\x01\x12\x07\n\x03\x42PE\x10\x02\x12\x08\n\x04WORD\x10\x03\x12\x08\n\x04\x43HAR\x10\x04*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02"\xd1\x01\n\x0eNormalizerSpec\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x1c\n\x14precompiled_charsmap\x18\x02 \x01(\x0c\x12\x1e\n\x10\x61\x64\x64_dummy_prefix\x18\x03 \x01(\x08:\x04true\x12&\n\x18remove_extra_whitespaces\x18\x04 \x01(\x08:\x04true\x12 \n\x12\x65scape_whitespaces\x18\x05 \x01(\x08:\x04true\x12\x1e\n\x16normalization_rule_tsv\x18\x06 \x01(\t*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02"y\n\x0cSelfTestData\x12\x33\n\x07samples\x18\x01 \x03(\x0b\x32".sentencepiece.SelfTestData.Sample\x1a)\n\x06Sample\x12\r\n\x05input\x18\x01 \x01(\t\x12\x10\n\x08\x65xpected\x18\x02 \x01(\t*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02"\xfe\x03\n\nModelProto\x12\x37\n\x06pieces\x18\x01 \x03(\x0b\x32\'.sentencepiece.ModelProto.SentencePiece\x12\x30\n\x0ctrainer_spec\x18\x02 \x01(\x0b\x32\x1a.sentencepiece.TrainerSpec\x12\x36\n\x0fnormalizer_spec\x18\x03 \x01(\x0b\x32\x1d.sentencepiece.NormalizerSpec\x12\x33\n\x0eself_test_data\x18\x04 \x01(\x0b\x32\x1b.sentencepiece.SelfTestData\x12\x38\n\x11\x64\x65normalizer_spec\x18\x05 \x01(\x0b\x32\x1d.sentencepiece.NormalizerSpec\x1a\xd2\x01\n\rSentencePiece\x12\r\n\x05piece\x18\x01 \x01(\t\x12\r\n\x05score\x18\x02 \x01(\x02\x12\x42\n\x04type\x18\x03 \x01(\x0e\x32,.sentencepiece.ModelProto.SentencePiece.Type:\x06NORMAL"T\n\x04Type\x12\n\n\x06NORMAL\x10\x01\x12\x0b\n\x07UNKNOWN\x10\x02\x12\x0b\n\x07\x43ONTROL\x10\x03\x12\x10\n\x0cUSER_DEFINED\x10\x04\x12\x08\n\x04\x42YTE\x10\x06\x12\n\n\x06UNUSED\x10\x05*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02\x42\x02H\x03'''
)

lowerCamelCase	:							str				=globals()
_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, '''sentencepiece_model_pb2''', _globals)
if _descriptor._USE_C_DESCRIPTORS is False:
 lowerCamelCase	:							Optional[int]				=None
 lowerCamelCase	:							Tuple				=b'''H\003'''
 # (generated by protobuf compiler, but `_TRAINERSPEC` is not defined)
 # _TRAINERSPEC.fields_by_name["mining_sentence_size"]._options = None
 # _TRAINERSPEC.fields_by_name["mining_sentence_size"]._serialized_options = b"\030\001"
 # _TRAINERSPEC.fields_by_name["training_sentence_size"]._options = None
 # _TRAINERSPEC.fields_by_name["training_sentence_size"]._serialized_options = b"\030\001"
 lowerCamelCase	:							List[str]				=45
 lowerCamelCase	:							List[Any]				=1581
 lowerCamelCase	:							Optional[int]				=1517
 lowerCamelCase	:							Tuple				=1570
 lowerCamelCase	:							Dict				=1584
 lowerCamelCase	:							Optional[Any]				=1793
 lowerCamelCase	:							Dict				=1795
 lowerCamelCase	:							Any				=1916
 lowerCamelCase	:							Dict				=1864
 lowerCamelCase	:							Dict				=1905
 lowerCamelCase	:							Dict				=1919
 lowerCamelCase	:							Union[str, Any]				=2429
 lowerCamelCase	:							List[Any]				=2208
 lowerCamelCase	:							List[Any]				=2418
 lowerCamelCase	:							List[str]				=2323
 lowerCamelCase	:							Dict				=2407
# @@protoc_insertion_point(module_scope)