

import argparse
import copy
import json
import multiprocessing
import os
import time

from create_dummy_models import COMPOSITE_MODELS, create_tiny_models
from huggingface_hub import ModelFilter, hf_api

import transformers
from transformers import AutoFeatureExtractor, AutoImageProcessor, AutoTokenizer
from transformers.image_processing_utils import BaseImageProcessor

def 							__SCREAMING_SNAKE_CASE							( )      ->				List[Any]:
				_UpperCAmelCase				:						Union[str, Any]       						=			set()
				# Each auto modeling files contains multiple mappings. Let's get them in a dynamic way.
				for module_name in ["modeling_auto", "modeling_tf_auto", "modeling_flax_auto"]:
								_UpperCAmelCase				:						Dict       						=			getattr(transformers.models.auto     ,					lowerCAmelCase     ,					lowerCAmelCase       )
								if module is None:
												continue
								# all mappings in a single auto modeling file
								_UpperCAmelCase				:						Optional[int]       						=			[
								    x
								    for x in dir(lowerCAmelCase       )
								    if x.endswith("_MAPPING_NAMES"       )
								    and (x.startswith("MODEL_"       ) or x.startswith("TF_MODEL_"       ) or x.startswith("FLAX_MODEL_"       ))
								]
								for name in mapping_names:
												_UpperCAmelCase				:						Optional[int]       						=			getattr(lowerCAmelCase     ,					lowerCAmelCase       )
												if mapping is not None:
																for v in mapping.values():
																				if isinstance(lowerCAmelCase     ,					(list, tuple)       ):
																								model_names.update(lowerCAmelCase       )
																				elif isinstance(lowerCAmelCase     ,					lowerCAmelCase       ):
																								model_names.add(lowerCAmelCase       )

				return sorted(lowerCAmelCase       )

def 							__SCREAMING_SNAKE_CASE							( )      ->				Optional[int]:
				# All model names defined in auto mappings
				_UpperCAmelCase				:						Tuple       						=			set(get_all_model_names()       )

				with open("tests/utils/tiny_model_summary.json"       ) as fp:
								_UpperCAmelCase				:						Tuple       						=			json.load(lowerCAmelCase       )
				_UpperCAmelCase				:						Union[str, Any]       						=			set()
				for model_base_name in tiny_model_info:
								tiny_models_names.update(tiny_model_info[model_base_name]["model_classes"]       )

				# Remove a tiny model name if one of its framework implementation hasn't yet a tiny version on the Hub.
				_UpperCAmelCase				:						Union[str, Any]       						=			model_names.difference(lowerCAmelCase       )
				for model_name in copy.copy(lowerCAmelCase       ):
								if not model_name.startswith("TF"       ) and F'TF{model_name}' in not_on_hub:
												tiny_models_names.remove(lowerCAmelCase       )
								elif model_name.startswith("TF"       ) and model_name[2:] in not_on_hub:
												tiny_models_names.remove(lowerCAmelCase       )

				return sorted(lowerCAmelCase       )

def 							__SCREAMING_SNAKE_CASE							( lowerCAmelCase:     Any       )      ->				Dict:
				_UpperCAmelCase				:						str       						=			COMPOSITE_MODELS.values()

				# All tiny model base names on Hub
				_UpperCAmelCase				:						Optional[int]       						=			get_all_model_names()
				_UpperCAmelCase				:						Dict       						=			hf_api.list_models(
				    filter=ModelFilter(
				        author="hf-internal-testing"     ,					)       )
				_UpperCAmelCase				:						str       						=			set()
				for x in models:
								_UpperCAmelCase				:						Union[str, Any]       						=			x.modelId
								_UpperCAmelCase						,							_UpperCAmelCase				:						Any       						=			model.split("/"       )
								if not model.startswith("tiny-random-"       ):
												continue
								_UpperCAmelCase				:						Dict       						=			model.replace("tiny-random-"     ,					""       )
								if not model[0].isupper():
												continue
								if model not in model_names and model not in special_models:
												continue
								_models.add(lowerCAmelCase       )

				_UpperCAmelCase				:						List[Any]       						=			sorted(_models       )
				# All tiny model names on Hub
				_UpperCAmelCase				:						Optional[Any]       						=			{}
				for model in models:
								_UpperCAmelCase				:						Optional[Any]       						=			F'hf-internal-testing/tiny-random-{model}'
								_UpperCAmelCase				:						Any       						=			model.split("-"       )[0]
								try:
												_UpperCAmelCase				:						int       						=			hf_api.repo_info(lowerCAmelCase       )
												_UpperCAmelCase				:						Dict       						=			{
												    "tokenizer_classes": set(),
												    "processor_classes": set(),
												    "model_classes": set(),
												    "sha": repo_info.sha,
												}
								except Exception:
												continue
								try:
												time.sleep(1       )
												_UpperCAmelCase				:						Dict       						=			AutoTokenizer.from_pretrained(lowerCAmelCase       )
												content["tokenizer_classes"].add(tokenizer_fast.__class__.__name__       )
								except Exception:
												pass
								try:
												time.sleep(1       )
												_UpperCAmelCase				:						int       						=			AutoTokenizer.from_pretrained(lowerCAmelCase     ,					use_fast=lowerCAmelCase       )
												content["tokenizer_classes"].add(tokenizer_slow.__class__.__name__       )
								except Exception:
												pass
								try:
												time.sleep(1       )
												_UpperCAmelCase				:						str       						=			AutoImageProcessor.from_pretrained(lowerCAmelCase       )
												content["processor_classes"].add(img_p.__class__.__name__       )
								except Exception:
												pass
								try:
												time.sleep(1       )
												_UpperCAmelCase				:						int       						=			AutoFeatureExtractor.from_pretrained(lowerCAmelCase       )
												if not isinstance(lowerCAmelCase     ,					lowerCAmelCase       ):
																content["processor_classes"].add(feat_p.__class__.__name__       )
								except Exception:
												pass
								try:
												time.sleep(1       )
												_UpperCAmelCase				:						Union[str, Any]       						=			getattr(lowerCAmelCase     ,					lowerCAmelCase       )
												_UpperCAmelCase				:						Tuple       						=			model_class.from_pretrained(lowerCAmelCase       )
												content["model_classes"].add(m.__class__.__name__       )
								except Exception:
												pass
								try:
												time.sleep(1       )
												_UpperCAmelCase				:						str       						=			getattr(lowerCAmelCase     ,					F'TF{model}'       )
												_UpperCAmelCase				:						Union[str, Any]       						=			model_class.from_pretrained(lowerCAmelCase       )
												content["model_classes"].add(m.__class__.__name__       )
								except Exception:
												pass

								_UpperCAmelCase				:						str       						=			sorted(content["tokenizer_classes"]       )
								_UpperCAmelCase				:						Union[str, Any]       						=			sorted(content["processor_classes"]       )
								_UpperCAmelCase				:						List[Any]       						=			sorted(content["model_classes"]       )

								_UpperCAmelCase				:						List[Any]       						=			content
								with open(os.path.join(lowerCAmelCase     ,					"hub_tiny_model_summary.json"       )     ,					"w"       ) as fp:
												json.dump(lowerCAmelCase     ,					lowerCAmelCase     ,					ensure_ascii=lowerCAmelCase     ,					indent=4       )


if __name__ == "__main__":
					SCREAMING_SNAKE_CASE_						=					argparse.ArgumentParser()
					parser.add_argument('--num_workers', default=1, type=int, help='The number of workers to run.')
					SCREAMING_SNAKE_CASE_						=					parser.parse_args()

					# This has to be `spawn` to avoid hanging forever!
					multiprocessing.set_start_method('spawn')

					SCREAMING_SNAKE_CASE_						=					'tiny_models'
					SCREAMING_SNAKE_CASE_						=					True
					SCREAMING_SNAKE_CASE_						=					None
					SCREAMING_SNAKE_CASE_						=					get_tiny_model_names_from_repo()
					SCREAMING_SNAKE_CASE_						=					True
					SCREAMING_SNAKE_CASE_						=					True
					SCREAMING_SNAKE_CASE_						=					'hf-internal-testing'

					create_tiny_models(
					    output_path,
					    all,
					    model_types,
					    models_to_skip,
					    no_check,
					    upload,
					    organization,
					    token=os.environ.get('TOKEN', None),
					    num_workers=args.num_workers,
					)





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


SCREAMING_SNAKE_CASE_						=					logging.get_logger(__name__)

# General docstring
SCREAMING_SNAKE_CASE_						=					'ResNetConfig'

# Base docstring
SCREAMING_SNAKE_CASE_						=					'microsoft/resnet-50'
SCREAMING_SNAKE_CASE_						=					[1, 2048, 7, 7]

# Image classification docstring
SCREAMING_SNAKE_CASE_						=					'microsoft/resnet-50'
SCREAMING_SNAKE_CASE_						=					'tiger cat'

SCREAMING_SNAKE_CASE_						=					[
    '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_		):







										'''simple docstring'''


										super().__init__(**A_		)
										_UpperCAmelCase				:						int       						=			kernel_size // 2
										_UpperCAmelCase				:						Dict       						=			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
										_UpperCAmelCase				:						Tuple       						=			tf.keras.layers.BatchNormalization(epsilon=1e-5  ,    momentum=0.9  ,    name="normalization"		)
										_UpperCAmelCase				:						int       						=			ACTaFN[activation] if activation is not None else tf.keras.layers.Activation("linear"		)


						def 				_UpperCAmelCase (				self  ,    A_		):







										'''simple docstring'''


										_UpperCAmelCase				:						Dict       						=			(self.pad_value, self.pad_value)
										_UpperCAmelCase				:						List[Any]       						=			tf.pad(A_  ,    [(0, 0), height_pad, width_pad, (0, 0)]		)
										_UpperCAmelCase				:						int       						=			self.conv(A_		)
										return hidden_state





						def 				_UpperCAmelCase (				self  ,    A_  ,    A_ = False		):







										'''simple docstring'''


										_UpperCAmelCase				:						Optional[int]       						=			self.convolution(A_		)
										_UpperCAmelCase				:						Optional[Any]       						=			self.normalization(A_  ,    training=A_		)
										_UpperCAmelCase				:						Dict       						=			self.activation(A_		)
										return hidden_state







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


						def __init__(				self  ,    A_  ,    **A_		):







										'''simple docstring'''


										super().__init__(**A_		)
										_UpperCAmelCase				:						Optional[int]       						=			TFResNetConvLayer(
										    config.embedding_size  ,    kernel_size=7  ,    stride=2  ,    activation=config.hidden_act  ,    name="embedder"  ,    )
										_UpperCAmelCase				:						List[Any]       						=			tf.keras.layers.MaxPoolaD(pool_size=3  ,    strides=2  ,    padding="valid"  ,    name="pooler"		)
										_UpperCAmelCase				:						List[Any]       						=			config.num_channels





						def 				_UpperCAmelCase (				self  ,    A_  ,    A_ = False		):







										'''simple docstring'''


										_UpperCAmelCase						,							_UpperCAmelCase						,							_UpperCAmelCase						,							_UpperCAmelCase				:						Dict       						=			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."		)
										_UpperCAmelCase				:						Any       						=			pixel_values
										_UpperCAmelCase				:						List[str]       						=			self.embedder(A_		)
										_UpperCAmelCase				:						int       						=			tf.pad(A_  ,    [[0, 0], [1, 1], [1, 1], [0, 0]]		)
										_UpperCAmelCase				:						Dict       						=			self.pooler(A_		)
										return hidden_state







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


						def __init__(				self  ,    A_  ,    A_ = 2  ,    **A_		):







										'''simple docstring'''


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





						def 				_UpperCAmelCase (				self  ,    A_  ,    A_ = False		):







										'''simple docstring'''


										_UpperCAmelCase				:						str       						=			x
										_UpperCAmelCase				:						str       						=			self.convolution(A_		)
										_UpperCAmelCase				:						str       						=			self.normalization(A_  ,    training=A_		)
										return hidden_state







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


						def __init__(				self  ,    A_  ,    A_  ,    A_ = 1  ,    A_ = "relu"  ,    **A_		):







										'''simple docstring'''


										super().__init__(**A_		)
										_UpperCAmelCase				:						Optional[Any]       						=			in_channels != out_channels or stride != 1
										_UpperCAmelCase				:						Optional[int]       						=			TFResNetConvLayer(A_  ,    stride=A_  ,    name="layer.0"		)
										_UpperCAmelCase				:						Optional[int]       						=			TFResNetConvLayer(A_  ,    activation=A_  ,    name="layer.1"		)
										_UpperCAmelCase				:						int       						=			(
										    TFResNetShortCut(A_  ,    stride=A_  ,    name="shortcut"		)
										    if should_apply_shortcut
										    else tf.keras.layers.Activation("linear"  ,    name="shortcut"		)
										)
										_UpperCAmelCase				:						List[str]       						=			ACTaFN[activation]





						def 				_UpperCAmelCase (				self  ,    A_  ,    A_ = False		):







										'''simple docstring'''


										_UpperCAmelCase				:						Union[str, Any]       						=			hidden_state
										_UpperCAmelCase				:						Optional[int]       						=			self.conva(A_  ,    training=A_		)
										_UpperCAmelCase				:						Union[str, Any]       						=			self.conva(A_  ,    training=A_		)
										_UpperCAmelCase				:						List[Any]       						=			self.shortcut(A_  ,    training=A_		)
										hidden_state += residual
										_UpperCAmelCase				:						Any       						=			self.activation(A_		)
										return hidden_state







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


						def __init__(				self  ,    A_  ,    A_  ,    A_ = 1  ,    A_ = "relu"  ,    A_ = 4  ,    **A_  ,    ):







										'''simple docstring'''


										super().__init__(**A_		)
										_UpperCAmelCase				:						List[str]       						=			in_channels != out_channels or stride != 1
										_UpperCAmelCase				:						Dict       						=			out_channels // reduction
										_UpperCAmelCase				:						Optional[int]       						=			TFResNetConvLayer(A_  ,    kernel_size=1  ,    name="layer.0"		)
										_UpperCAmelCase				:						str       						=			TFResNetConvLayer(A_  ,    stride=A_  ,    name="layer.1"		)
										_UpperCAmelCase				:						Optional[Any]       						=			TFResNetConvLayer(A_  ,    kernel_size=1  ,    activation=A_  ,    name="layer.2"		)
										_UpperCAmelCase				:						List[str]       						=			(
										    TFResNetShortCut(A_  ,    stride=A_  ,    name="shortcut"		)
										    if should_apply_shortcut
										    else tf.keras.layers.Activation("linear"  ,    name="shortcut"		)
										)
										_UpperCAmelCase				:						Optional[int]       						=			ACTaFN[activation]





						def 				_UpperCAmelCase (				self  ,    A_  ,    A_ = False		):







										'''simple docstring'''


										_UpperCAmelCase				:						Optional[Any]       						=			hidden_state
										_UpperCAmelCase				:						Union[str, Any]       						=			self.conva(A_  ,    training=A_		)
										_UpperCAmelCase				:						Tuple       						=			self.conva(A_  ,    training=A_		)
										_UpperCAmelCase				:						Dict       						=			self.conva(A_  ,    training=A_		)
										_UpperCAmelCase				:						Optional[Any]       						=			self.shortcut(A_  ,    training=A_		)
										hidden_state += residual
										_UpperCAmelCase				:						Any       						=			self.activation(A_		)
										return hidden_state







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


						def __init__(				self  ,    A_  ,    A_  ,    A_  ,    A_ = 2  ,    A_ = 2  ,    **A_		):







										'''simple docstring'''


										super().__init__(**A_		)

										_UpperCAmelCase				:						str       						=			TFResNetBottleNeckLayer if config.layer_type == "bottleneck" else TFResNetBasicLayer

										_UpperCAmelCase				:						List[str]       						=			[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		)
										]
										_UpperCAmelCase				:						Optional[Any]       						=			layers





						def 				_UpperCAmelCase (				self  ,    A_  ,    A_ = False		):







										'''simple docstring'''


										for layer in self.stage_layers:
														_UpperCAmelCase				:						Union[str, Any]       						=			layer(A_  ,    training=A_		)
										return hidden_state







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


						def __init__(				self  ,    A_  ,    **A_		):







										'''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
										_UpperCAmelCase				:						List[str]       						=			[
										    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 				_UpperCAmelCase (				self  ,    A_  ,    A_ = False  ,    A_ = True  ,    A_ = False  ,    ):







										'''simple docstring'''


										_UpperCAmelCase				:						str       						=			() if output_hidden_states else None

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

														_UpperCAmelCase				:						Union[str, Any]       						=			stage_module(A_  ,    training=A_		)

										if output_hidden_states:
														_UpperCAmelCase				:						Union[str, Any]       						=			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 ):
						_lowercase			  =	ResNetConfig
						_lowercase			  =	"resnet"
						_lowercase			  =	"pixel_values"


						@property
						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


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







SCREAMING_SNAKE_CASE_						=					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'


SCREAMING_SNAKE_CASE_						=					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 ):
						_lowercase			  =	ResNetConfig


						def __init__(				self  ,    A_  ,    **A_		):







										'''simple docstring'''


										super().__init__(**A_		)
										_UpperCAmelCase				:						List[Any]       						=			config
										_UpperCAmelCase				:						Optional[Any]       						=			TFResNetEmbeddings(A_  ,    name="embedder"		)
										_UpperCAmelCase				:						Tuple       						=			TFResNetEncoder(A_  ,    name="encoder"		)
										_UpperCAmelCase				:						Tuple       						=			tf.keras.layers.GlobalAveragePoolingaD(keepdims=A_		)





						@unpack_inputs
						def 				_UpperCAmelCase (				self  ,    A_  ,    A_ = None  ,    A_ = None  ,    A_ = False  ,    ):







										'''simple docstring'''


										_UpperCAmelCase				:						Dict       						=			(
										    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
										)
										_UpperCAmelCase				:						int       						=			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)
										_UpperCAmelCase				:						List[Any]       						=			tf.transpose(A_  ,    perm=[0, 2, 3, 1]		)
										_UpperCAmelCase				:						Dict       						=			self.embedder(A_  ,    training=A_		)

										_UpperCAmelCase				:						Any       						=			self.encoder(
										    A_  ,    output_hidden_states=A_  ,    return_dict=A_  ,    training=A_		)

										_UpperCAmelCase				:						Optional[int]       						=			encoder_outputs[0]

										_UpperCAmelCase				:						Tuple       						=			self.pooler(A_		)

										# Transpose all the outputs to the NCHW format
										# (batch_size, height, width, num_channels) -> (batch_size, num_channels, height, width)
										_UpperCAmelCase				:						Union[str, Any]       						=			tf.transpose(A_  ,    (0, 3, 1, 2)		)
										_UpperCAmelCase				:						Any       						=			tf.transpose(A_  ,    (0, 3, 1, 2)		)
										_UpperCAmelCase				:						Tuple       						=			()
										for hidden_state in encoder_outputs[1:]:
														_UpperCAmelCase				:						Optional[int]       						=			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

										_UpperCAmelCase				:						Any       						=			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_		):







										'''simple docstring'''


										super().__init__(A_  ,    **A_		)
										_UpperCAmelCase				:						int       						=			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 				_UpperCAmelCase (				self  ,    A_  ,    A_ = None  ,    A_ = None  ,    A_ = False  ,    ):







										'''simple docstring'''


										_UpperCAmelCase				:						List[Any]       						=			(
										    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
										)
										_UpperCAmelCase				:						str       						=			return_dict if return_dict is not None else self.config.use_return_dict

										_UpperCAmelCase				:						List[Any]       						=			self.resnet(
										    pixel_values=A_  ,    output_hidden_states=A_  ,    return_dict=A_  ,    training=A_  ,    )
										return resnet_outputs







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


						def __init__(				self  ,    A_  ,    **A_		):







										'''simple docstring'''


										super().__init__(A_  ,    **A_		)
										_UpperCAmelCase				:						Dict       						=			config.num_labels
										_UpperCAmelCase				:						List[Any]       						=			TFResNetMainLayer(A_  ,    name="resnet"		)
										# classification head
										_UpperCAmelCase				:						Union[str, Any]       						=			(
										    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 				_UpperCAmelCase (				self  ,    A_		):







										'''simple docstring'''


										_UpperCAmelCase				:						Tuple       						=			tf.keras.layers.Flatten()(A_		)
										_UpperCAmelCase				:						Dict       						=			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 				_UpperCAmelCase (				self  ,    A_ = None  ,    A_ = None  ,    A_ = None  ,    A_ = None  ,    A_ = False  ,    ):







										'''simple docstring'''


										_UpperCAmelCase				:						int       						=			return_dict if return_dict is not None else self.config.use_return_dict

										_UpperCAmelCase				:						Optional[Any]       						=			self.resnet(
										    A_  ,    output_hidden_states=A_  ,    return_dict=A_  ,    training=A_		)

										_UpperCAmelCase				:						Tuple       						=			outputs.pooler_output if return_dict else outputs[1]

										_UpperCAmelCase				:						int       						=			self.classifier(A_		)

										_UpperCAmelCase				:						str       						=			None if labels is None else self.hf_compute_loss(A_  ,    A_		)

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

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


