






"""simple docstring"""







import os
import unittest

from transformers import RealmTokenizerFast
from transformers.models.bert.tokenization_bert import (
    VOCAB_FILES_NAMES,
    BasicTokenizer,
    WordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.models.realm.tokenization_realm import RealmTokenizer
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english


@require_tokenizers
class     __UpperCAmelCase(   SCREAMING_SNAKE_CASE__  ,  unittest.TestCase							):




						"""simple docstring"""




						__lowerCamelCase				       =					RealmTokenizer
						__lowerCamelCase				       =					RealmTokenizerFast
						__lowerCamelCase				       =					True
						__lowerCamelCase				       =					True
						__lowerCamelCase				       =					filter_non_english




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												super().setUp()

												lowercase__				:      int=       [
												    "[UNK]",
												    "[CLS]",
												    "[SEP]",
												    "[PAD]",
												    "[MASK]",
												    "want",
												    "##want",
												    "##ed",
												    "wa",
												    "un",
												    "runn",
												    "##ing",
												    ",",
												    "low",
												    "lowest",
												]
												lowercase__				:      int=       os.path.join(self.tmpdirname       ,  VOCAB_FILES_NAMES["vocab_file"]			)
												with open(self.vocab_file       ,  "w"       ,  encoding="utf-8"			) as vocab_writer:
																		vocab_writer.write("".join([x + "\n" for x in vocab_tokens]			)			)




						def 		UpperCAmelCase_       (   self       ,  snake_case__			):
												'''simple docstring'''
												lowercase__				:      Tuple=       "UNwant\u00E9d,running"
												lowercase__				:      Tuple=       "unwanted, running"
												return input_text, output_text




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      Tuple=       self.tokenizer_class(self.vocab_file			)

												lowercase__				:      Optional[Any]=       tokenizer.tokenize("UNwant\u00E9d,running"			)
												self.assertListEqual(snake_case__       ,  ["un", "##want", "##ed", ",", "runn", "##ing"]			)
												self.assertListEqual(tokenizer.convert_tokens_to_ids(snake_case__			)       ,  [9, 6, 7, 12, 10, 11]			)




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												if not self.test_rust_tokenizer:
																		return

												lowercase__				:      List[str]=       self.get_tokenizer()
												lowercase__				:      Dict=       self.get_rust_tokenizer()

												lowercase__				:      int=       "UNwant\u00E9d,running"

												lowercase__				:      Dict=       tokenizer.tokenize(snake_case__			)
												lowercase__				:      Optional[Any]=       rust_tokenizer.tokenize(snake_case__			)
												self.assertListEqual(snake_case__       ,  snake_case__			)

												lowercase__				:      str=       tokenizer.encode(snake_case__       ,  add_special_tokens=snake_case__			)
												lowercase__				:      Dict=       rust_tokenizer.encode(snake_case__       ,  add_special_tokens=snake_case__			)
												self.assertListEqual(snake_case__       ,  snake_case__			)

												lowercase__				:      Dict=       self.get_rust_tokenizer()
												lowercase__				:      List[Any]=       tokenizer.encode(snake_case__			)
												lowercase__				:      Dict=       rust_tokenizer.encode(snake_case__			)
												self.assertListEqual(snake_case__       ,  snake_case__			)

												# With lower casing
												lowercase__				:      Union[str, Any]=       self.get_tokenizer(do_lower_case=snake_case__			)
												lowercase__				:      Dict=       self.get_rust_tokenizer(do_lower_case=snake_case__			)

												lowercase__				:      Optional[Any]=       "UNwant\u00E9d,running"

												lowercase__				:      Optional[int]=       tokenizer.tokenize(snake_case__			)
												lowercase__				:      Any=       rust_tokenizer.tokenize(snake_case__			)
												self.assertListEqual(snake_case__       ,  snake_case__			)

												lowercase__				:      Optional[int]=       tokenizer.encode(snake_case__       ,  add_special_tokens=snake_case__			)
												lowercase__				:      Tuple=       rust_tokenizer.encode(snake_case__       ,  add_special_tokens=snake_case__			)
												self.assertListEqual(snake_case__       ,  snake_case__			)

												lowercase__				:      Optional[Any]=       self.get_rust_tokenizer()
												lowercase__				:      str=       tokenizer.encode(snake_case__			)
												lowercase__				:      Union[str, Any]=       rust_tokenizer.encode(snake_case__			)
												self.assertListEqual(snake_case__       ,  snake_case__			)




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      Dict=       BasicTokenizer()

												self.assertListEqual(tokenizer.tokenize("ah\u535A\u63A8zz"			)       ,  ["ah", "\u535A", "\u63A8", "zz"]			)




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      int=       BasicTokenizer(do_lower_case=snake_case__			)

												self.assertListEqual(
												    tokenizer.tokenize(" \tHeLLo!how  \n Are yoU?  "			)       ,  ["hello", "!", "how", "are", "you", "?"]			)
												self.assertListEqual(tokenizer.tokenize("H\u00E9llo"			)       ,  ["hello"]			)




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      Tuple=       BasicTokenizer(do_lower_case=snake_case__       ,  strip_accents=snake_case__			)

												self.assertListEqual(
												    tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "			)       ,  ["hällo", "!", "how", "are", "you", "?"]			)
												self.assertListEqual(tokenizer.tokenize("H\u00E9llo"			)       ,  ["h\u00E9llo"]			)




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      Tuple=       BasicTokenizer(do_lower_case=snake_case__       ,  strip_accents=snake_case__			)

												self.assertListEqual(
												    tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "			)       ,  ["hallo", "!", "how", "are", "you", "?"]			)
												self.assertListEqual(tokenizer.tokenize("H\u00E9llo"			)       ,  ["hello"]			)




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      Optional[int]=       BasicTokenizer(do_lower_case=snake_case__			)

												self.assertListEqual(
												    tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "			)       ,  ["hallo", "!", "how", "are", "you", "?"]			)
												self.assertListEqual(tokenizer.tokenize("H\u00E9llo"			)       ,  ["hello"]			)




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      List[Any]=       BasicTokenizer(do_lower_case=snake_case__			)

												self.assertListEqual(
												    tokenizer.tokenize(" \tHeLLo!how  \n Are yoU?  "			)       ,  ["HeLLo", "!", "how", "Are", "yoU", "?"]			)




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      Tuple=       BasicTokenizer(do_lower_case=snake_case__       ,  strip_accents=snake_case__			)

												self.assertListEqual(
												    tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "			)       ,  ["HäLLo", "!", "how", "Are", "yoU", "?"]			)




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      Any=       BasicTokenizer(do_lower_case=snake_case__       ,  strip_accents=snake_case__			)

												self.assertListEqual(
												    tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "			)       ,  ["HaLLo", "!", "how", "Are", "yoU", "?"]			)




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      Optional[Any]=       BasicTokenizer(do_lower_case=snake_case__       ,  never_split=["[UNK]"]			)

												self.assertListEqual(
												    tokenizer.tokenize(" \tHeLLo!how  \n Are yoU? [UNK]"			)       ,  ["HeLLo", "!", "how", "Are", "yoU", "?", "[UNK]"]			)




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      Optional[int]=       ["[UNK]", "[CLS]", "[SEP]", "want", "##want", "##ed", "wa", "un", "runn", "##ing"]

												lowercase__				:      Optional[int]=       {}
												for i, token in enumerate(snake_case__			):
																		lowercase__				:      Union[str, Any]=       i
												lowercase__				:      Optional[Any]=       WordpieceTokenizer(vocab=snake_case__       ,  unk_token="[UNK]"			)

												self.assertListEqual(tokenizer.tokenize(""			)       ,  []			)

												self.assertListEqual(tokenizer.tokenize("unwanted running"			)       ,  ["un", "##want", "##ed", "runn", "##ing"]			)

												self.assertListEqual(tokenizer.tokenize("unwantedX running"			)       ,  ["[UNK]", "runn", "##ing"]			)




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												self.assertTrue(_is_whitespace(" "			)			)
												self.assertTrue(_is_whitespace("\t"			)			)
												self.assertTrue(_is_whitespace("\r"			)			)
												self.assertTrue(_is_whitespace("\n"			)			)
												self.assertTrue(_is_whitespace("\u00A0"			)			)

												self.assertFalse(_is_whitespace("A"			)			)
												self.assertFalse(_is_whitespace("-"			)			)




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												self.assertTrue(_is_control("\u0005"			)			)

												self.assertFalse(_is_control("A"			)			)
												self.assertFalse(_is_control(" "			)			)
												self.assertFalse(_is_control("\t"			)			)
												self.assertFalse(_is_control("\r"			)			)




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												self.assertTrue(_is_punctuation("-"			)			)
												self.assertTrue(_is_punctuation("$"			)			)
												self.assertTrue(_is_punctuation("`"			)			)
												self.assertTrue(_is_punctuation("."			)			)

												self.assertFalse(_is_punctuation("A"			)			)
												self.assertFalse(_is_punctuation(" "			)			)




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      Optional[int]=       self.get_tokenizer()

												# Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
												self.assertListEqual([tokenizer.tokenize(snake_case__			) for t in ["Test", "\xad", "test"]]       ,  [["[UNK]"], [], ["[UNK]"]]			)

												if self.test_rust_tokenizer:
																		lowercase__				:      Union[str, Any]=       self.get_rust_tokenizer()
																		self.assertListEqual(
																		    [rust_tokenizer.tokenize(snake_case__			) for t in ["Test", "\xad", "test"]]       ,  [["[UNK]"], [], ["[UNK]"]]			)




						@slow
						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      Dict=       self.tokenizer_class.from_pretrained("bert-base-uncased"			)

												lowercase__				:      int=       tokenizer.encode("sequence builders"       ,  add_special_tokens=snake_case__			)
												lowercase__				:      Optional[int]=       tokenizer.encode("multi-sequence build"       ,  add_special_tokens=snake_case__			)

												lowercase__				:      Tuple=       tokenizer.build_inputs_with_special_tokens(snake_case__			)
												lowercase__				:      List[str]=       tokenizer.build_inputs_with_special_tokens(snake_case__       ,  snake_case__			)

												assert encoded_sentence == [101] + text + [102]
												assert encoded_pair == [101] + text + [102] + text_a + [102]




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
																		with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''			):
																								lowercase__				:      Union[str, Any]=       self.rust_tokenizer_class.from_pretrained(snake_case__       ,  **snake_case__			)

																								lowercase__				:      Optional[int]=       F'''A, naïve {tokenizer_r.mask_token} AllenNLP sentence.'''
																								lowercase__				:      Union[str, Any]=       tokenizer_r.encode_plus(
																								    snake_case__       ,  return_attention_mask=snake_case__       ,  return_token_type_ids=snake_case__       ,  return_offsets_mapping=snake_case__       ,  add_special_tokens=snake_case__       ,  )

																								lowercase__				:      Tuple=       tokenizer_r.do_lower_case if hasattr(snake_case__       ,  "do_lower_case"			) else False
																								lowercase__				:      Union[str, Any]=       (
																								    [
																								        ((0, 0), tokenizer_r.cls_token),
																								        ((0, 1), "A"),
																								        ((1, 2), ","),
																								        ((3, 5), "na"),
																								        ((5, 6), "##ï"),
																								        ((6, 8), "##ve"),
																								        ((9, 15), tokenizer_r.mask_token),
																								        ((16, 21), "Allen"),
																								        ((21, 23), "##NL"),
																								        ((23, 24), "##P"),
																								        ((25, 33), "sentence"),
																								        ((33, 34), "."),
																								        ((0, 0), tokenizer_r.sep_token),
																								    ]
																								    if not do_lower_case
																								    else [
																								        ((0, 0), tokenizer_r.cls_token),
																								        ((0, 1), "a"),
																								        ((1, 2), ","),
																								        ((3, 8), "naive"),
																								        ((9, 15), tokenizer_r.mask_token),
																								        ((16, 21), "allen"),
																								        ((21, 23), "##nl"),
																								        ((23, 24), "##p"),
																								        ((25, 33), "sentence"),
																								        ((33, 34), "."),
																								        ((0, 0), tokenizer_r.sep_token),
																								    ]
																								)

																								self.assertEqual(
																								    [e[1] for e in expected_results]       ,  tokenizer_r.convert_ids_to_tokens(tokens["input_ids"]			)			)
																								self.assertEqual([e[0] for e in expected_results]       ,  tokens["offset_mapping"]			)




						@slow
						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
																		with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''			):
																								lowercase__				:      Tuple=       self.rust_tokenizer_class.from_pretrained(snake_case__       ,  **snake_case__			)
																								lowercase__				:      Tuple=       self.tokenizer_class.from_pretrained(snake_case__       ,  **snake_case__			)
																								lowercase__				:      List[Any]=       [["Hello world!", "Nice to meet you!"], ["The cute cat.", "The adorable dog."]]

																								lowercase__				:      Optional[int]=       tokenizer_r.batch_encode_candidates(snake_case__       ,  max_length=10       ,  return_tensors="np"			)
																								lowercase__				:      str=       tokenizer_p.batch_encode_candidates(snake_case__       ,  max_length=10       ,  return_tensors="np"			)

																								lowercase__				:      Dict=       (2, 2, 10)

																								self.assertEqual(encoded_sentence_r["input_ids"].shape       ,  snake_case__			)
																								self.assertEqual(encoded_sentence_r["attention_mask"].shape       ,  snake_case__			)
																								self.assertEqual(encoded_sentence_r["token_type_ids"].shape       ,  snake_case__			)

																								self.assertEqual(encoded_sentence_p["input_ids"].shape       ,  snake_case__			)
																								self.assertEqual(encoded_sentence_p["attention_mask"].shape       ,  snake_case__			)
																								self.assertEqual(encoded_sentence_p["token_type_ids"].shape       ,  snake_case__			)












from typing import Optional, Tuple, Union

import tensorflow as tf

from ...activations_tf import ACTaFN
from ...modeling_tf_outputs import (
    TFBaseModelOutputWithNoAttention,
    TFBaseModelOutputWithPoolingAndNoAttention,
    TFImageClassifierOutputWithNoAttention,
)
from ...modeling_tf_utils import TFPreTrainedModel, TFSequenceClassificationLoss, keras_serializable, unpack_inputs
from ...tf_utils import shape_list
from ...utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward, logging
from .configuration_resnet import ResNetConfig


lowercase__      :			int           =					logging.get_logger(__name__)

# General docstring
lowercase__      :			str           =					"ResNetConfig"

# Base docstring
lowercase__      :			Dict           =					"microsoft/resnet-50"
lowercase__      :			Dict           =					[1, 2_048, 7, 7]

# Image classification docstring
lowercase__      :			Optional[Any]           =					"microsoft/resnet-50"
lowercase__      :			str           =					"tiger cat"

lowercase__      :			Union[str, Any]           =					[
    "microsoft/resnet-50",
    # See all resnet models at https://huggingface.co/models?filter=resnet
]




class 			a__       (					tf.keras.layers.Layer      ):







     def __init__(	self  ,		A  ,		A = 3  ,		A = 1  ,		A = "relu"  ,		**A )  ->    None:



          '''simple docstring'''



          super().__init__(**A )
          a      =      kernel_size // 2
          a      =      tf.keras.layers.ConvaD(
              A  ,		kernel_size=A  ,		strides=A  ,		padding="valid"  ,		use_bias=A  ,		name="convolution" )
          # Use same default momentum and epsilon as PyTorch equivalent
          a      =      tf.keras.layers.BatchNormalization(epsilon=1e-5  ,		momentum=0.9  ,		name="normalization" )
          a      =      ACTaFN[activation] if activation is not None else tf.keras.layers.Activation("linear" )







     def 			lowerCAmelCase_				(	self  ,		A )  ->    tf.Tensor:



          '''simple docstring'''



          a      =      a      =      (self.pad_value, self.pad_value)
          a      =      tf.pad(A  ,		[(0, 0), height_pad, width_pad, (0, 0)] )
          a      =      self.conv(A )
          return hidden_state







     def 			lowerCAmelCase_				(	self  ,		A  ,		A = False )  ->    tf.Tensor:



          '''simple docstring'''



          a      =      self.convolution(A )
          a      =      self.normalization(A  ,		training=A )
          a      =      self.activation(A )
          return hidden_state







class 			a__       (					tf.keras.layers.Layer      ):







     def __init__(	self  ,		A  ,		**A )  ->    None:



          '''simple docstring'''



          super().__init__(**A )
          a      =      TFResNetConvLayer(
              config.embedding_size  ,		kernel_size=7  ,		stride=2  ,		activation=config.hidden_act  ,		name="embedder"  ,		)
          a      =      tf.keras.layers.MaxPoolaD(pool_size=3  ,		strides=2  ,		padding="valid"  ,		name="pooler" )
          a      =      config.num_channels







     def 			lowerCAmelCase_				(	self  ,		A  ,		A = False )  ->    tf.Tensor:



          '''simple docstring'''



          a  ,      a  ,      a  ,      a      =      shape_list(A )
          if tf.executing_eagerly() and num_channels != self.num_channels:
               raise ValueError(
                   "Make sure that the channel dimension of the pixel values match with the one set in the configuration." )
          a      =      pixel_values
          a      =      self.embedder(A )
          a      =      tf.pad(A  ,		[[0, 0], [1, 1], [1, 1], [0, 0]] )
          a      =      self.pooler(A )
          return hidden_state







class 			a__       (					tf.keras.layers.Layer      ):







     def __init__(	self  ,		A  ,		A = 2  ,		**A )  ->    None:



          '''simple docstring'''



          super().__init__(**A )
          a      =      tf.keras.layers.ConvaD(
              A  ,		kernel_size=1  ,		strides=A  ,		use_bias=A  ,		name="convolution" )
          # Use same default momentum and epsilon as PyTorch equivalent
          a      =      tf.keras.layers.BatchNormalization(epsilon=1e-5  ,		momentum=0.9  ,		name="normalization" )







     def 			lowerCAmelCase_				(	self  ,		A  ,		A = False )  ->    tf.Tensor:



          '''simple docstring'''



          a      =      x
          a      =      self.convolution(A )
          a      =      self.normalization(A  ,		training=A )
          return hidden_state







class 			a__       (					tf.keras.layers.Layer      ):







     def __init__(	self  ,		A  ,		A  ,		A = 1  ,		A = "relu"  ,		**A )  ->    None:



          '''simple docstring'''



          super().__init__(**A )
          a      =      in_channels != out_channels or stride != 1
          a      =      TFResNetConvLayer(A  ,		stride=A  ,		name="layer.0" )
          a      =      TFResNetConvLayer(A  ,		activation=A  ,		name="layer.1" )
          a      =      (
              TFResNetShortCut(A  ,		stride=A  ,		name="shortcut" )
              if should_apply_shortcut
              else tf.keras.layers.Activation("linear"  ,		name="shortcut" )
          )
          a      =      ACTaFN[activation]







     def 			lowerCAmelCase_				(	self  ,		A  ,		A = False )  ->    tf.Tensor:



          '''simple docstring'''



          a      =      hidden_state
          a      =      self.conva(A  ,		training=A )
          a      =      self.conva(A  ,		training=A )
          a      =      self.shortcut(A  ,		training=A )
          hidden_state += residual
          a      =      self.activation(A )
          return hidden_state







class 			a__       (					tf.keras.layers.Layer      ):







     def __init__(	self  ,		A  ,		A  ,		A = 1  ,		A = "relu"  ,		A = 4  ,		**A  ,		)  ->    None:



          '''simple docstring'''



          super().__init__(**A )
          a      =      in_channels != out_channels or stride != 1
          a      =      out_channels // reduction
          a      =      TFResNetConvLayer(A  ,		kernel_size=1  ,		name="layer.0" )
          a      =      TFResNetConvLayer(A  ,		stride=A  ,		name="layer.1" )
          a      =      TFResNetConvLayer(A  ,		kernel_size=1  ,		activation=A  ,		name="layer.2" )
          a      =      (
              TFResNetShortCut(A  ,		stride=A  ,		name="shortcut" )
              if should_apply_shortcut
              else tf.keras.layers.Activation("linear"  ,		name="shortcut" )
          )
          a      =      ACTaFN[activation]







     def 			lowerCAmelCase_				(	self  ,		A  ,		A = False )  ->    tf.Tensor:



          '''simple docstring'''



          a      =      hidden_state
          a      =      self.conva(A  ,		training=A )
          a      =      self.conva(A  ,		training=A )
          a      =      self.conva(A  ,		training=A )
          a      =      self.shortcut(A  ,		training=A )
          hidden_state += residual
          a      =      self.activation(A )
          return hidden_state







class 			a__       (					tf.keras.layers.Layer      ):







     def __init__(	self  ,		A  ,		A  ,		A  ,		A = 2  ,		A = 2  ,		**A )  ->    None:



          '''simple docstring'''



          super().__init__(**A )

          a      =      TFResNetBottleNeckLayer if config.layer_type == "bottleneck" else TFResNetBasicLayer

          a      =      [layer(A  ,		A  ,		stride=A  ,		activation=config.hidden_act  ,		name="layers.0" )]
          layers += [
              layer(A  ,		A  ,		activation=config.hidden_act  ,		name=F'''layers.{i + 1}''' )
              for i in range(depth - 1 )
          ]
          a      =      layers







     def 			lowerCAmelCase_				(	self  ,		A  ,		A = False )  ->    tf.Tensor:



          '''simple docstring'''



          for layer in self.stage_layers:
               a      =      layer(A  ,		training=A )
          return hidden_state







class 			a__       (					tf.keras.layers.Layer      ):







     def __init__(	self  ,		A  ,		**A )  ->    None:



          '''simple docstring'''



          super().__init__(**A )
          # based on `downsample_in_first_stage` the first layer of the first stage may or may not downsample the input
          a      =      [
              TFResNetStage(
                  A  ,		config.embedding_size  ,		config.hidden_sizes[0]  ,		stride=2 if config.downsample_in_first_stage else 1  ,		depth=config.depths[0]  ,		name="stages.0"  ,		)
          ]
          for i, (in_channels, out_channels, depth) in enumerate(
              zip(config.hidden_sizes  ,		config.hidden_sizes[1:]  ,		config.depths[1:] ) ):
               self.stages.append(TFResNetStage(A  ,		A  ,		A  ,		depth=A  ,		name=F'''stages.{i + 1}''' ) )







     def 			lowerCAmelCase_				(	self  ,		A  ,		A = False  ,		A = True  ,		A = False  ,		)  ->    TFBaseModelOutputWithNoAttention:



          '''simple docstring'''



          a      =      () if output_hidden_states else None

          for stage_module in self.stages:
               if output_hidden_states:
                    a      =      hidden_states + (hidden_state,)

               a      =      stage_module(A  ,		training=A )

          if output_hidden_states:
               a      =      hidden_states + (hidden_state,)

          if not return_dict:
               return tuple(v for v in [hidden_state, hidden_states] if v is not None )

          return TFBaseModelOutputWithNoAttention(last_hidden_state=A  ,		hidden_states=A )







class 			a__       (					UpperCamelCase__      ):
     a		:			List[Any]							=	ResNetConfig
     a		:			str							=	"""resnet"""
     a		:			List[str]							=	"""pixel_values"""







     @property
     def 			lowerCAmelCase_				(	self )  ->    Union[str, Any]:



          '''simple docstring'''



          return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 224, 224)  ,		dtype=tf.floataa )}







lowercase__      :			Any           =					R"\n    This model is a TensorFlow\n    [tf.keras.layers.Layer](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Layer) sub-class. Use it as a\n    regular TensorFlow Module and refer to the TensorFlow documentation for all matter related to general usage and\n    behavior.\n\n    Parameters:\n        config ([`ResNetConfig`]): Model configuration class with all the parameters of the model.\n            Initializing with a config file does not load the weights associated with the model, only the\n            configuration. Check out the [`~TFPreTrainedModel.from_pretrained`] method to load the model weights.\n"


lowercase__      :			Dict           =					R"\n    Args:\n        pixel_values (`tf.Tensor` of shape `(batch_size, num_channels, height, width)`):\n            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See\n            [`ConvNextImageProcessor.__call__`] for details.\n\n        output_hidden_states (`bool`, *optional*):\n            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for\n            more detail.\n        return_dict (`bool`, *optional*):\n            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.\n"




@keras_serializable
class 			a__       (					tf.keras.layers.Layer      ):
     a		:			List[str]							=	ResNetConfig







     def __init__(	self  ,		A  ,		**A )  ->    None:



          '''simple docstring'''



          super().__init__(**A )
          a      =      config
          a      =      TFResNetEmbeddings(A  ,		name="embedder" )
          a      =      TFResNetEncoder(A  ,		name="encoder" )
          a      =      tf.keras.layers.GlobalAveragePoolingaD(keepdims=A )







     @unpack_inputs
     def 			lowerCAmelCase_				(	self  ,		A  ,		A = None  ,		A = None  ,		A = False  ,		)  ->    Union[Tuple[tf.Tensor], TFBaseModelOutputWithPoolingAndNoAttention]:



          '''simple docstring'''



          a      =      (
              output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
          )
          a      =      return_dict if return_dict is not None else self.config.use_return_dict

          # TF 2.0 image layers can't use NCHW format when running on CPU.
          # We transpose to NHWC format and then transpose back after the full forward pass.
          # (batch_size, num_channels, height, width) -> (batch_size, height, width, num_channels)
          a      =      tf.transpose(A  ,		perm=[0, 2, 3, 1] )
          a      =      self.embedder(A  ,		training=A )

          a      =      self.encoder(
              A  ,		output_hidden_states=A  ,		return_dict=A  ,		training=A )

          a      =      encoder_outputs[0]

          a      =      self.pooler(A )

          # Transpose all the outputs to the NCHW format
          # (batch_size, height, width, num_channels) -> (batch_size, num_channels, height, width)
          a      =      tf.transpose(A  ,		(0, 3, 1, 2) )
          a      =      tf.transpose(A  ,		(0, 3, 1, 2) )
          a      =      ()
          for hidden_state in encoder_outputs[1:]:
               a      =      hidden_states + tuple(tf.transpose(A  ,		(0, 3, 1, 2) ) for h in hidden_state )

          if not return_dict:
               return (last_hidden_state, pooled_output) + hidden_states

          a      =      hidden_states if output_hidden_states else None

          return TFBaseModelOutputWithPoolingAndNoAttention(
              last_hidden_state=A  ,		pooler_output=A  ,		hidden_states=A  ,		)







@add_start_docstrings(
    """The bare ResNet model outputting raw features without any specific head on top."""   ,					UpperCamelCase__   ,					)
class 			a__       (					UpperCamelCase__      ):







     def __init__(	self  ,		A  ,		**A )  ->    None:



          '''simple docstring'''



          super().__init__(A  ,		**A )
          a      =      TFResNetMainLayer(config=A  ,		name="resnet" )







     @add_start_docstrings_to_model_forward(A )
     @add_code_sample_docstrings(
         checkpoint=_CHECKPOINT_FOR_DOC  ,		output_type=A  ,		config_class=_CONFIG_FOR_DOC  ,		modality="vision"  ,		expected_output=_EXPECTED_OUTPUT_SHAPE  ,		)
     @unpack_inputs
     def 			lowerCAmelCase_				(	self  ,		A  ,		A = None  ,		A = None  ,		A = False  ,		)  ->    Union[Tuple[tf.Tensor], TFBaseModelOutputWithPoolingAndNoAttention]:



          '''simple docstring'''



          a      =      (
              output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
          )
          a      =      return_dict if return_dict is not None else self.config.use_return_dict

          a      =      self.resnet(
              pixel_values=A  ,		output_hidden_states=A  ,		return_dict=A  ,		training=A  ,		)
          return resnet_outputs







@add_start_docstrings(
    """
    ResNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for
    ImageNet.
    """   ,					UpperCamelCase__   ,					)
class 			a__       (					UpperCamelCase__   ,					UpperCamelCase__      ):







     def __init__(	self  ,		A  ,		**A )  ->    None:



          '''simple docstring'''



          super().__init__(A  ,		**A )
          a      =      config.num_labels
          a      =      TFResNetMainLayer(A  ,		name="resnet" )
          # classification head
          a      =      (
              tf.keras.layers.Dense(config.num_labels  ,		name="classifier.1" )
              if config.num_labels > 0
              else tf.keras.layers.Activation("linear"  ,		name="classifier.1" )
          )







     def 			lowerCAmelCase_				(	self  ,		A )  ->    tf.Tensor:



          '''simple docstring'''



          a      =      tf.keras.layers.Flatten()(A )
          a      =      self.classifier_layer(A )
          return logits







     @add_start_docstrings_to_model_forward(A )
     @add_code_sample_docstrings(
         checkpoint=_IMAGE_CLASS_CHECKPOINT  ,		output_type=A  ,		config_class=_CONFIG_FOR_DOC  ,		expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT  ,		)
     @unpack_inputs
     def 			lowerCAmelCase_				(	self  ,		A = None  ,		A = None  ,		A = None  ,		A = None  ,		A = False  ,		)  ->    Union[Tuple[tf.Tensor], TFImageClassifierOutputWithNoAttention]:



          '''simple docstring'''



          a      =      return_dict if return_dict is not None else self.config.use_return_dict

          a      =      self.resnet(
              A  ,		output_hidden_states=A  ,		return_dict=A  ,		training=A )

          a      =      outputs.pooler_output if return_dict else outputs[1]

          a      =      self.classifier(A )

          a      =      None if labels is None else self.hf_compute_loss(A  ,		A )

          if not return_dict:
               a      =      (logits,) + outputs[2:]
               return (loss,) + output if loss is not None else output

          return TFImageClassifierOutputWithNoAttention(loss=A  ,		logits=A  ,		hidden_states=outputs.hidden_states )

