



class 						snake_case  :



   '''simple docstring'''






   def __init__(   self							:     Tuple			,						lowerCAmelCase							:     int)			->			None:

    """simple docstring"""







    _snake_case      :					Tuple					=   data
    _snake_case      :					BinaryTreeNode | None					=   None
    _snake_case      :					BinaryTreeNode | None					=   None



def  lowercase    (				SCREAMING_SNAKE_CASE__    :		BinaryTreeNode | None			,    SCREAMING_SNAKE_CASE__    :		int			)					->       BinaryTreeNode | None:






 """simple docstring"""




 if node is None:
  _snake_case      :					Optional[int]					=   BinaryTreeNode(SCREAMING_SNAKE_CASE__			)
  return node

 # binary search tree is not empty,
 # so we will insert it into the tree
 # if new_value is less than value of data in node,
 #  add it to left subtree and proceed recursively
 if new_value < node.data:
  _snake_case      :					Dict					=   insert(node.left_child			,    SCREAMING_SNAKE_CASE__			)
 else:
  # if new_value is greater than value of data in node,
  #  add it to right subtree and proceed recursively
  _snake_case      :					List[str]					=   insert(node.right_child			,    SCREAMING_SNAKE_CASE__			)
 return node



def  lowercase    (				SCREAMING_SNAKE_CASE__    :		None | BinaryTreeNode			)					->       list[int]:  # if node is None,return






 """simple docstring"""




 if node:
  _snake_case      :					str					=   inorder(node.left_child			)
  _snake_case      :					Dict					=   [*inorder_array, node.data]
  _snake_case      :					List[str]					=   inorder_array + inorder(node.right_child			)
 else:
  _snake_case      :					Optional[int]					=   []
 return inorder_array



def  lowercase    (				)					->       BinaryTreeNode | None:






 """simple docstring"""




 _snake_case      :					Tuple					=   insert(SCREAMING_SNAKE_CASE__			,    15			)
 insert(SCREAMING_SNAKE_CASE__			,    10			)
 insert(SCREAMING_SNAKE_CASE__			,    25			)
 insert(SCREAMING_SNAKE_CASE__			,    6			)
 insert(SCREAMING_SNAKE_CASE__			,    14			)
 insert(SCREAMING_SNAKE_CASE__			,    20			)
 insert(SCREAMING_SNAKE_CASE__			,    60			)
 return root



def  lowercase    (				)					->       None:






 """simple docstring"""




 _snake_case      :					Dict					=   make_tree()
 print("""Printing values of binary search tree in Inorder Traversal."""			)
 inorder(SCREAMING_SNAKE_CASE__			)


if __name__ == "__main__":
  import doctest

  doctest.testmod()
  main()





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


a__      =		logging.get_logger(__name__)

# General docstring
a__      =		"""ResNetConfig"""

# Base docstring
a__      =		"""microsoft/resnet-50"""
a__      =		[1, 20_48, 7, 7]

# Image classification docstring
a__      =		"""microsoft/resnet-50"""
a__      =		"""tiger cat"""

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







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



   '''simple docstring'''






   def __init__(   self							:     Union[str, Any]			,						lowerCAmelCase							:     int			,						lowerCAmelCase							:     int = 3			,						lowerCAmelCase							:     int = 1			,						lowerCAmelCase							:     str = "relu"			,						**lowerCAmelCase							:     Any)			->			None:

    """simple docstring"""







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

   def        UpperCamelCase_					(   self							:     Tuple			,						lowerCAmelCase							:     tf.Tensor)			->			tf.Tensor:

    """simple docstring"""







    _snake_case      :					List[Any]					=   (self.pad_value, self.pad_value)
    _snake_case      :					Optional[Any]					=   tf.pad(lowerCAmelCase			,						[(0, 0), height_pad, width_pad, (0, 0)])
    _snake_case      :					Optional[Any]					=   self.conv(lowerCAmelCase)
    return hidden_state


   def        UpperCamelCase_					(   self							:     Optional[Any]			,						lowerCAmelCase							:     tf.Tensor			,						lowerCAmelCase							:     bool = False)			->			tf.Tensor:

    """simple docstring"""







    _snake_case      :					Optional[Any]					=   self.convolution(lowerCAmelCase)
    _snake_case      :					List[Any]					=   self.normalization(lowerCAmelCase			,						training=lowerCAmelCase)
    _snake_case      :					List[Any]					=   self.activation(lowerCAmelCase)
    return hidden_state







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



   '''simple docstring'''






   def __init__(   self							:     Optional[int]			,						lowerCAmelCase							:     ResNetConfig			,						**lowerCAmelCase							:     Optional[Any])			->			None:

    """simple docstring"""







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


   def        UpperCamelCase_					(   self							:     List[Any]			,						lowerCAmelCase							:     tf.Tensor			,						lowerCAmelCase							:     bool = False)			->			tf.Tensor:

    """simple docstring"""







    _snake_case		,      _snake_case		,      _snake_case		,      _snake_case      :					Optional[Any]					=   shape_list(lowerCAmelCase)
    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.""")
    _snake_case      :					str					=   pixel_values
    _snake_case      :					str					=   self.embedder(lowerCAmelCase)
    _snake_case      :					Tuple					=   tf.pad(lowerCAmelCase			,						[[0, 0], [1, 1], [1, 1], [0, 0]])
    _snake_case      :					Dict					=   self.pooler(lowerCAmelCase)
    return hidden_state







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



   '''simple docstring'''






   def __init__(   self							:     Union[str, Any]			,						lowerCAmelCase							:     int			,						lowerCAmelCase							:     int = 2			,						**lowerCAmelCase							:     str)			->			None:

    """simple docstring"""







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


   def        UpperCamelCase_					(   self							:     List[Any]			,						lowerCAmelCase							:     tf.Tensor			,						lowerCAmelCase							:     bool = False)			->			tf.Tensor:

    """simple docstring"""







    _snake_case      :					Optional[int]					=   x
    _snake_case      :					Optional[Any]					=   self.convolution(lowerCAmelCase)
    _snake_case      :					int					=   self.normalization(lowerCAmelCase			,						training=lowerCAmelCase)
    return hidden_state







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



   '''simple docstring'''






   def __init__(   self							:     List[str]			,						lowerCAmelCase							:     int			,						lowerCAmelCase							:     int			,						lowerCAmelCase							:     int = 1			,						lowerCAmelCase							:     str = "relu"			,						**lowerCAmelCase							:     Tuple)			->			None:

    """simple docstring"""







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


   def        UpperCamelCase_					(   self							:     Optional[Any]			,						lowerCAmelCase							:     tf.Tensor			,						lowerCAmelCase							:     bool = False)			->			tf.Tensor:

    """simple docstring"""







    _snake_case      :					List[Any]					=   hidden_state
    _snake_case      :					Tuple					=   self.conva(lowerCAmelCase			,						training=lowerCAmelCase)
    _snake_case      :					List[Any]					=   self.conva(lowerCAmelCase			,						training=lowerCAmelCase)
    _snake_case      :					str					=   self.shortcut(lowerCAmelCase			,						training=lowerCAmelCase)
    hidden_state += residual
    _snake_case      :					Dict					=   self.activation(lowerCAmelCase)
    return hidden_state







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



   '''simple docstring'''






   def __init__(   self							:     Union[str, Any]			,						lowerCAmelCase							:     int			,						lowerCAmelCase							:     int			,						lowerCAmelCase							:     int = 1			,						lowerCAmelCase							:     str = "relu"			,						lowerCAmelCase							:     int = 4			,						**lowerCAmelCase							:     Dict			,						)			->			None:

    """simple docstring"""







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


   def        UpperCamelCase_					(   self							:     List[Any]			,						lowerCAmelCase							:     tf.Tensor			,						lowerCAmelCase							:     bool = False)			->			tf.Tensor:

    """simple docstring"""







    _snake_case      :					Optional[int]					=   hidden_state
    _snake_case      :					Dict					=   self.conva(lowerCAmelCase			,						training=lowerCAmelCase)
    _snake_case      :					Any					=   self.conva(lowerCAmelCase			,						training=lowerCAmelCase)
    _snake_case      :					Optional[int]					=   self.conva(lowerCAmelCase			,						training=lowerCAmelCase)
    _snake_case      :					str					=   self.shortcut(lowerCAmelCase			,						training=lowerCAmelCase)
    hidden_state += residual
    _snake_case      :					Tuple					=   self.activation(lowerCAmelCase)
    return hidden_state







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



   '''simple docstring'''






   def __init__(   self							:     Optional[Any]			,						lowerCAmelCase							:     ResNetConfig			,						lowerCAmelCase							:     int			,						lowerCAmelCase							:     int			,						lowerCAmelCase							:     int = 2			,						lowerCAmelCase							:     int = 2			,						**lowerCAmelCase							:     Optional[int])			->			None:

    """simple docstring"""







    super().__init__(**lowerCAmelCase)

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

    _snake_case      :					Dict					=   [layer(lowerCAmelCase			,						lowerCAmelCase			,						stride=lowerCAmelCase			,						activation=config.hidden_act			,						name="""layers.0""")]
    layers += [
        layer(lowerCAmelCase			,						lowerCAmelCase			,						activation=config.hidden_act			,						name=F'''layers.{i + 1}''')
        for i in range(depth - 1)
    ]
    _snake_case      :					List[str]					=   layers


   def        UpperCamelCase_					(   self							:     Union[str, Any]			,						lowerCAmelCase							:     tf.Tensor			,						lowerCAmelCase							:     bool = False)			->			tf.Tensor:

    """simple docstring"""







    for layer in self.stage_layers:
     _snake_case      :					int					=   layer(lowerCAmelCase			,						training=lowerCAmelCase)
    return hidden_state







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



   '''simple docstring'''






   def __init__(   self							:     List[str]			,						lowerCAmelCase							:     ResNetConfig			,						**lowerCAmelCase							:     List[Any])			->			None:

    """simple docstring"""







    super().__init__(**lowerCAmelCase)
    # based on `downsample_in_first_stage` the first layer of the first stage may or may not downsample the input
    _snake_case      :					Tuple					=   [
        TFResNetStage(
            lowerCAmelCase			,						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(lowerCAmelCase			,						lowerCAmelCase			,						lowerCAmelCase			,						depth=lowerCAmelCase			,						name=F'''stages.{i + 1}'''))


   def        UpperCamelCase_					(   self							:     int			,						lowerCAmelCase							:     tf.Tensor			,						lowerCAmelCase							:     bool = False			,						lowerCAmelCase							:     bool = True			,						lowerCAmelCase							:     bool = False			,						)			->			TFBaseModelOutputWithNoAttention:

    """simple docstring"""







    _snake_case      :					List[Any]					=   () if output_hidden_states else None

    for stage_module in self.stages:
     if output_hidden_states:
      _snake_case      :					Optional[Any]					=   hidden_states + (hidden_state,)

     _snake_case      :					Union[str, Any]					=   stage_module(lowerCAmelCase			,						training=lowerCAmelCase)

    if output_hidden_states:
     _snake_case      :					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=lowerCAmelCase			,						hidden_states=lowerCAmelCase)







class 						snake_case  (		SCREAMING_SNAKE_CASE_					):



   '''simple docstring'''






   snake_case_   :	Optional[int]       =						ResNetConfig
   snake_case_   :	Any       =						"""resnet"""
   snake_case_   :	Union[str, Any]       =						"""pixel_values"""

   @property
   def        UpperCamelCase_					(   self							:     int)			->			Dict:

    """simple docstring"""







    return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 224, 224)			,						dtype=tf.floataa)}
a__      =		R"""
    This model is a TensorFlow
    [tf.keras.layers.Layer](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Layer) sub-class. Use it as a
    regular TensorFlow Module and refer to the TensorFlow documentation for all matter related to general usage and
    behavior.

    Parameters:
        config ([`ResNetConfig`]): Model configuration class with all the parameters of the model.
            Initializing with a config file does not load the weights associated with the model, only the
            configuration. Check out the [`~TFPreTrainedModel.from_pretrained`] method to load the model weights.
"""


a__      =		R"""
    Args:
        pixel_values (`tf.Tensor` of shape `(batch_size, num_channels, height, width)`):
            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See
            [`ConvNextImageProcessor.__call__`] for details.

        output_hidden_states (`bool`, *optional*):
            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
            more detail.
        return_dict (`bool`, *optional*):
            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
"""







@keras_serializable
class 						snake_case  (		tf.keras.layers.Layer					):



   '''simple docstring'''






   snake_case_   :	Optional[int]       =						ResNetConfig

   def __init__(   self							:     Union[str, Any]			,						lowerCAmelCase							:     ResNetConfig			,						**lowerCAmelCase							:     Tuple)			->			None:

    """simple docstring"""







    super().__init__(**lowerCAmelCase)
    _snake_case      :					int					=   config
    _snake_case      :					Tuple					=   TFResNetEmbeddings(lowerCAmelCase			,						name="""embedder""")
    _snake_case      :					str					=   TFResNetEncoder(lowerCAmelCase			,						name="""encoder""")
    _snake_case      :					Any					=   tf.keras.layers.GlobalAveragePoolingaD(keepdims=lowerCAmelCase)


   @unpack_inputs
   def        UpperCamelCase_					(   self							:     str			,						lowerCAmelCase							:     tf.Tensor			,						lowerCAmelCase							:     Optional[bool] = None			,						lowerCAmelCase							:     Optional[bool] = None			,						lowerCAmelCase							:     bool = False			,						)			->			Union[Tuple[tf.Tensor], TFBaseModelOutputWithPoolingAndNoAttention]:

    """simple docstring"""







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

    _snake_case      :					List[str]					=   self.encoder(
        lowerCAmelCase			,						output_hidden_states=lowerCAmelCase			,						return_dict=lowerCAmelCase			,						training=lowerCAmelCase)

    _snake_case      :					Dict					=   encoder_outputs[0]

    _snake_case      :					Optional[int]					=   self.pooler(lowerCAmelCase)

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

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

    _snake_case      :					Optional[Any]					=   hidden_states if output_hidden_states else None

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







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



   '''simple docstring'''






   def __init__(   self							:     Optional[Any]			,						lowerCAmelCase							:     ResNetConfig			,						**lowerCAmelCase							:     Any)			->			None:

    """simple docstring"""







    super().__init__(lowerCAmelCase			,						**lowerCAmelCase)
    _snake_case      :					Union[str, Any]					=   TFResNetMainLayer(config=lowerCAmelCase			,						name="""resnet""")


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

    """simple docstring"""







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

    _snake_case      :					Union[str, Any]					=   self.resnet(
        pixel_values=lowerCAmelCase			,						output_hidden_states=lowerCAmelCase			,						return_dict=lowerCAmelCase			,						training=lowerCAmelCase			,						)
    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.
    """   ,SCREAMING_SNAKE_CASE_   ,)
class 						snake_case  (		SCREAMING_SNAKE_CASE_   ,SCREAMING_SNAKE_CASE_					):



   '''simple docstring'''






   def __init__(   self							:     Optional[Any]			,						lowerCAmelCase							:     ResNetConfig			,						**lowerCAmelCase							:     Dict)			->			None:

    """simple docstring"""







    super().__init__(lowerCAmelCase			,						**lowerCAmelCase)
    _snake_case      :					Optional[Any]					=   config.num_labels
    _snake_case      :					int					=   TFResNetMainLayer(lowerCAmelCase			,						name="""resnet""")
    # classification head
    _snake_case      :					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							:     List[str]			,						lowerCAmelCase							:     tf.Tensor)			->			tf.Tensor:

    """simple docstring"""







    _snake_case      :					List[str]					=   tf.keras.layers.Flatten()(lowerCAmelCase)
    _snake_case      :					List[str]					=   self.classifier_layer(lowerCAmelCase)
    return logits


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

    """simple docstring"""







    _snake_case      :					Any					=   return_dict if return_dict is not None else self.config.use_return_dict

    _snake_case      :					Dict					=   self.resnet(
        lowerCAmelCase			,						output_hidden_states=lowerCAmelCase			,						return_dict=lowerCAmelCase			,						training=lowerCAmelCase)

    _snake_case      :					int					=   outputs.pooler_output if return_dict else outputs[1]

    _snake_case      :					List[str]					=   self.classifier(lowerCAmelCase)

    _snake_case      :					Optional[int]					=   None if labels is None else self.hf_compute_loss(lowerCAmelCase			,						lowerCAmelCase)

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

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