

import unittest

import numpy as np
import torch
from torch import nn
from transformers import (
    CLIPImageProcessor,
    CLIPTextConfig,
    CLIPTextModelWithProjection,
    CLIPTokenizer,
    CLIPVisionConfig,
    CLIPVisionModelWithProjection,
)

from diffusers import KandinskyPriorPipeline, PriorTransformer, UnCLIPScheduler
from diffusers.utils import torch_device
from diffusers.utils.testing_utils import enable_full_determinism, skip_mps

from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()

class  a     (		UpperCAmelCase							,       unittest.TestCase ):
						_lowercase			  =	KandinskyPriorPipeline
						_lowercase			  =	["prompt"]
						_lowercase			  =	["prompt", "negative_prompt"]
						_lowercase			  =	[
						    "num_images_per_prompt",
						    "generator",
						    "num_inference_steps",
						    "latents",
						    "negative_prompt",
						    "guidance_scale",
						    "output_type",
						    "return_dict",
						]
						_lowercase			  =	False


						@property
						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										return 32


						@property
						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										return 32


						@property
						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										return self.time_input_dim


						@property
						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										return self.time_input_dim * 4


						@property
						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										return 100


						@property
						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										_UpperCAmelCase				:						Union[str, Any]       						=			CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"		)
										return tokenizer


						@property
						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										torch.manual_seed(0		)
										_UpperCAmelCase				:						List[Any]       						=			CLIPTextConfig(
										    bos_token_id=0  ,    eos_token_id=2  ,    hidden_size=self.text_embedder_hidden_size  ,    projection_dim=self.text_embedder_hidden_size  ,    intermediate_size=37  ,    layer_norm_eps=1e-05  ,    num_attention_heads=4  ,    num_hidden_layers=5  ,    pad_token_id=1  ,    vocab_size=1000  ,    )
										return CLIPTextModelWithProjection(A_		)


						@property
						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										torch.manual_seed(0		)

										_UpperCAmelCase				:						str       						=			{
										    "num_attention_heads": 2,
										    "attention_head_dim": 12,
										    "embedding_dim": self.text_embedder_hidden_size,
										    "num_layers": 1,
										}

										_UpperCAmelCase				:						Tuple       						=			PriorTransformer(**A_		)
										# clip_std and clip_mean is initialized to be 0 so PriorTransformer.post_process_latents will always return 0 - set clip_std to be 1 so it won't return 0
										_UpperCAmelCase				:						Optional[Any]       						=			nn.Parameter(torch.ones(model.clip_std.shape		)		)
										return model


						@property
						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										torch.manual_seed(0		)
										_UpperCAmelCase				:						int       						=			CLIPVisionConfig(
										    hidden_size=self.text_embedder_hidden_size  ,    image_size=224  ,    projection_dim=self.text_embedder_hidden_size  ,    intermediate_size=37  ,    num_attention_heads=4  ,    num_channels=3  ,    num_hidden_layers=5  ,    patch_size=14  ,    )

										_UpperCAmelCase				:						Dict       						=			CLIPVisionModelWithProjection(A_		)
										return model


						@property
						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										_UpperCAmelCase				:						Union[str, Any]       						=			CLIPImageProcessor(
										    crop_size=224  ,    do_center_crop=A_  ,    do_normalize=A_  ,    do_resize=A_  ,    image_mean=[0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73]  ,    image_std=[0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11]  ,    resample=3  ,    size=224  ,    )

										return image_processor


						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										_UpperCAmelCase				:						Union[str, Any]       						=			self.dummy_prior
										_UpperCAmelCase				:						List[Any]       						=			self.dummy_image_encoder
										_UpperCAmelCase				:						str       						=			self.dummy_text_encoder
										_UpperCAmelCase				:						Any       						=			self.dummy_tokenizer
										_UpperCAmelCase				:						int       						=			self.dummy_image_processor

										_UpperCAmelCase				:						Union[str, Any]       						=			UnCLIPScheduler(
										    variance_type="fixed_small_log"  ,    prediction_type="sample"  ,    num_train_timesteps=1000  ,    clip_sample=A_  ,    clip_sample_range=10.0  ,    )

										_UpperCAmelCase				:						Optional[int]       						=			{
										    "prior": prior,
										    "image_encoder": image_encoder,
										    "text_encoder": text_encoder,
										    "tokenizer": tokenizer,
										    "scheduler": scheduler,
										    "image_processor": image_processor,
										}

										return components


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







										'''simple docstring'''


										if str(A_		).startswith("mps"		):
														_UpperCAmelCase				:						Tuple       						=			torch.manual_seed(A_		)
										else:
														_UpperCAmelCase				:						Dict       						=			torch.Generator(device=A_		).manual_seed(A_		)
										_UpperCAmelCase				:						List[str]       						=			{
										    "prompt": "horse",
										    "generator": generator,
										    "guidance_scale": 4.0,
										    "num_inference_steps": 2,
										    "output_type": "np",
										}
										return inputs


						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										_UpperCAmelCase				:						Optional[int]       						=			"cpu"

										_UpperCAmelCase				:						int       						=			self.get_dummy_components()

										_UpperCAmelCase				:						str       						=			self.pipeline_class(**A_		)
										_UpperCAmelCase				:						List[str]       						=			pipe.to(A_		)

										pipe.set_progress_bar_config(disable=A_		)

										_UpperCAmelCase				:						Union[str, Any]       						=			pipe(**self.get_dummy_inputs(A_		)		)
										_UpperCAmelCase				:						List[str]       						=			output.image_embeds

										_UpperCAmelCase				:						Tuple       						=			pipe(
										    **self.get_dummy_inputs(A_		)  ,    return_dict=A_  ,    )[0]

										_UpperCAmelCase				:						List[str]       						=			image[0, -10:]
										_UpperCAmelCase				:						Optional[int]       						=			image_from_tuple[0, -10:]

										assert image.shape == (1, 32)

										_UpperCAmelCase				:						Union[str, Any]       						=			np.array(
										    [-0.05_32, 1.71_20, 0.36_56, -1.08_52, -0.89_46, -1.17_56, 0.43_48, 0.24_82, 0.51_46, -0.11_56]		)

										assert np.abs(image_slice.flatten() - expected_slice		).max() < 1e-2
										assert np.abs(image_from_tuple_slice.flatten() - expected_slice		).max() < 1e-2


						@skip_mps
						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										_UpperCAmelCase				:						List[Any]       						=			torch_device == "cpu"
										_UpperCAmelCase				:						Tuple       						=			True
										_UpperCAmelCase				:						Dict       						=			False

										self._test_inference_batch_single_identical(
										    test_max_difference=A_  ,    relax_max_difference=A_  ,    test_mean_pixel_difference=A_  ,    )





						@skip_mps
						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										_UpperCAmelCase				:						List[Any]       						=			torch_device == "cpu"
										_UpperCAmelCase				:						Optional[int]       						=			False

										self._test_attention_slicing_forward_pass(
										    test_max_difference=A_  ,    test_mean_pixel_difference=A_  ,    )





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		)


