code: 
  
  
  
  
  
  
  """simple docstring"""
  
  
  
  
  
  
  from typing import TYPE_CHECKING
  
  from ...utils import (
      OptionalDependencyNotAvailable,
      _LazyModule,
      is_sentencepiece_available,
      is_tokenizers_available,
      is_torch_available,
  )
  
  
  A_			  =    {
      "configuration_open_llama": ["OPEN_LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP", "OpenLlamaConfig"],
  }
  
  try:
      if not is_sentencepiece_available():
          raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
      pass
  else:
      A_			  =    ["LlamaTokenizer"]
  
  try:
      if not is_tokenizers_available():
          raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
      pass
  else:
      A_			  =    ["LlamaTokenizerFast"]
  
  try:
      if not is_torch_available():
          raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
      pass
  else:
      A_			  =    [
          "OpenLlamaForCausalLM",
          "OpenLlamaModel",
          "OpenLlamaPreTrainedModel",
          "OpenLlamaForSequenceClassification",
      ]
  
  
  if TYPE_CHECKING:
      from .configuration_open_llama import OPEN_LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP, OpenLlamaConfig
  
      try:
          if not is_sentencepiece_available():
              raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
          pass
      else:
          from transformers import LlamaTokenizer
  
      try:
          if not is_tokenizers_available():
              raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
          pass
      else:
          from transformers import LlamaTokenizerFast
  
      try:
          if not is_torch_available():
              raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
          pass
      else:
          from .modeling_open_llama import (
              OpenLlamaForCausalLM,
              OpenLlamaForSequenceClassification,
              OpenLlamaModel,
              OpenLlamaPreTrainedModel,
          )
  
  
  else:
      import sys
  
      A_			  =    _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
  
style_context: 
  
  
  
  
  
  
  """simple docstring"""
  
  
  
  
  
  
  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, 2048, 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 						__lowerCAmelCase   (			tf.keras.layers.Layer       ):
  
  
  
  
  
  
  
    '''simple docstring'''
  
  
    def __init__(      self:		Dict				,			UpperCamelCase_:		int				,			UpperCamelCase_:		int = 3				,			UpperCamelCase_:		int = 1				,			UpperCamelCase_:		str = "relu"				,			**UpperCamelCase_:		List[Any]					):
       super().__init__(**UpperCamelCase_					)
       UpperCamelCase_     =kernel_size // 2
       UpperCamelCase_     =tf.keras.layers.ConvaD(
           UpperCamelCase_				,			kernel_size=UpperCamelCase_				,			strides=UpperCamelCase_				,			padding="valid"				,			use_bias=UpperCamelCase_				,			name="convolution"					)
       # Use same default momentum and epsilon as PyTorch equivalent
       UpperCamelCase_     =tf.keras.layers.BatchNormalization(epsilon=1e-5				,			momentum=0.9				,			name="normalization"					)
       UpperCamelCase_     =ACTaFN[activation] if activation is not None else tf.keras.layers.Activation("linear"					)
    def 					UpperCamelCase__   (      self:		List[str]				,			UpperCamelCase_:		tf.Tensor					):
       # Pad to match that done in the PyTorch Conv2D model
       UpperCamelCase_     =UpperCamelCase_     =(self.pad_value, self.pad_value)
       UpperCamelCase_     =tf.pad(UpperCamelCase_				,			[(0, 0), height_pad, width_pad, (0, 0)]					)
       UpperCamelCase_     =self.conv(UpperCamelCase_					)
       return hidden_state
  
  
  
  
  
    def 					UpperCamelCase__   (      self:		Optional[int]				,			UpperCamelCase_:		tf.Tensor				,			UpperCamelCase_:		bool = False					):
       UpperCamelCase_     =self.convolution(UpperCamelCase_					)
       UpperCamelCase_     =self.normalization(UpperCamelCase_				,			training=UpperCamelCase_					)
       UpperCamelCase_     =self.activation(UpperCamelCase_					)
       return hidden_state
  
  
  
  
  class 						__lowerCAmelCase   (			tf.keras.layers.Layer       ):
  
  
  
  
  
  
  
    '''simple docstring'''
  
  
    def __init__(      self:		Optional[int]				,			UpperCamelCase_:		ResNetConfig				,			**UpperCamelCase_:		Dict					):
       super().__init__(**UpperCamelCase_					)
       UpperCamelCase_     =TFResNetConvLayer(
           config.embedding_size				,			kernel_size=7				,			stride=2				,			activation=config.hidden_act				,			name="embedder"				,			)
       UpperCamelCase_     =tf.keras.layers.MaxPoolaD(pool_size=3				,			strides=2				,			padding="valid"				,			name="pooler"					)
       UpperCamelCase_     =config.num_channels
  
  
  
  
  
    def 					UpperCamelCase__   (      self:		Dict				,			UpperCamelCase_:		tf.Tensor				,			UpperCamelCase_:		bool = False					):
       UpperCamelCase_    ,							UpperCamelCase_    ,							UpperCamelCase_    ,							UpperCamelCase_     =shape_list(UpperCamelCase_					)
       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_     =pixel_values
       UpperCamelCase_     =self.embedder(UpperCamelCase_					)
       UpperCamelCase_     =tf.pad(UpperCamelCase_				,			[[0, 0], [1, 1], [1, 1], [0, 0]]					)
       UpperCamelCase_     =self.pooler(UpperCamelCase_					)
       return hidden_state
  
  
  
  
  class 						__lowerCAmelCase   (			tf.keras.layers.Layer       ):
  
  
  
  
  
  
  
    '''simple docstring'''
  
  
    def __init__(      self:		Optional[int]				,			UpperCamelCase_:		int				,			UpperCamelCase_:		int = 2				,			**UpperCamelCase_:		Tuple					):
       super().__init__(**UpperCamelCase_					)
       UpperCamelCase_     =tf.keras.layers.ConvaD(
           UpperCamelCase_				,			kernel_size=1				,			strides=UpperCamelCase_				,			use_bias=UpperCamelCase_				,			name="convolution"					)
       # Use same default momentum and epsilon as PyTorch equivalent
       UpperCamelCase_     =tf.keras.layers.BatchNormalization(epsilon=1e-5				,			momentum=0.9				,			name="normalization"					)
  
  
  
  
  
    def 					UpperCamelCase__   (      self:		Optional[int]				,			UpperCamelCase_:		tf.Tensor				,			UpperCamelCase_:		bool = False					):
       UpperCamelCase_     =x
       UpperCamelCase_     =self.convolution(UpperCamelCase_					)
       UpperCamelCase_     =self.normalization(UpperCamelCase_				,			training=UpperCamelCase_					)
       return hidden_state
  
  
  
  
  class 						__lowerCAmelCase   (			tf.keras.layers.Layer       ):
  
  
  
  
  
  
  
    '''simple docstring'''
  
  
    def __init__(      self:		Optional[Any]				,			UpperCamelCase_:		int				,			UpperCamelCase_:		int				,			UpperCamelCase_:		int = 1				,			UpperCamelCase_:		str = "relu"				,			**UpperCamelCase_:		Dict					):
       super().__init__(**UpperCamelCase_					)
       UpperCamelCase_     =in_channels != out_channels or stride != 1
       UpperCamelCase_     =TFResNetConvLayer(UpperCamelCase_				,			stride=UpperCamelCase_				,			name="layer.0"					)
       UpperCamelCase_     =TFResNetConvLayer(UpperCamelCase_				,			activation=UpperCamelCase_				,			name="layer.1"					)
       UpperCamelCase_     =(
           TFResNetShortCut(UpperCamelCase_				,			stride=UpperCamelCase_				,			name="shortcut"					)
           if should_apply_shortcut
           else tf.keras.layers.Activation("linear"				,			name="shortcut"					)
       )
       UpperCamelCase_     =ACTaFN[activation]
  
  
  
  
  
    def 					UpperCamelCase__   (      self:		Optional[Any]				,			UpperCamelCase_:		tf.Tensor				,			UpperCamelCase_:		bool = False					):
       UpperCamelCase_     =hidden_state
       UpperCamelCase_     =self.conva(UpperCamelCase_				,			training=UpperCamelCase_					)
       UpperCamelCase_     =self.conva(UpperCamelCase_				,			training=UpperCamelCase_					)
       UpperCamelCase_     =self.shortcut(UpperCamelCase_				,			training=UpperCamelCase_					)
       hidden_state += residual
       UpperCamelCase_     =self.activation(UpperCamelCase_					)
       return hidden_state
  
  
  
  
  class 						__lowerCAmelCase   (			tf.keras.layers.Layer       ):
  
  
  
  
  
  
  
    '''simple docstring'''
  
  
    def __init__(      self:		Dict				,			UpperCamelCase_:		int				,			UpperCamelCase_:		int				,			UpperCamelCase_:		int = 1				,			UpperCamelCase_:		str = "relu"				,			UpperCamelCase_:		int = 4				,			**UpperCamelCase_:		Union[str, Any]				,			):
       super().__init__(**UpperCamelCase_					)
       UpperCamelCase_     =in_channels != out_channels or stride != 1
       UpperCamelCase_     =out_channels // reduction
       UpperCamelCase_     =TFResNetConvLayer(UpperCamelCase_				,			kernel_size=1				,			name="layer.0"					)
       UpperCamelCase_     =TFResNetConvLayer(UpperCamelCase_				,			stride=UpperCamelCase_				,			name="layer.1"					)
       UpperCamelCase_     =TFResNetConvLayer(UpperCamelCase_				,			kernel_size=1				,			activation=UpperCamelCase_				,			name="layer.2"					)
       UpperCamelCase_     =(
           TFResNetShortCut(UpperCamelCase_				,			stride=UpperCamelCase_				,			name="shortcut"					)
           if should_apply_shortcut
           else tf.keras.layers.Activation("linear"				,			name="shortcut"					)
       )
       UpperCamelCase_     =ACTaFN[activation]
  
  
  
  
  
    def 					UpperCamelCase__   (      self:		Optional[Any]				,			UpperCamelCase_:		tf.Tensor				,			UpperCamelCase_:		bool = False					):
       UpperCamelCase_     =hidden_state
       UpperCamelCase_     =self.conva(UpperCamelCase_				,			training=UpperCamelCase_					)
       UpperCamelCase_     =self.conva(UpperCamelCase_				,			training=UpperCamelCase_					)
       UpperCamelCase_     =self.conva(UpperCamelCase_				,			training=UpperCamelCase_					)
       UpperCamelCase_     =self.shortcut(UpperCamelCase_				,			training=UpperCamelCase_					)
       hidden_state += residual
       UpperCamelCase_     =self.activation(UpperCamelCase_					)
       return hidden_state
  
  
  
  
  class 						__lowerCAmelCase   (			tf.keras.layers.Layer       ):
  
  
  
  
  
  
  
    '''simple docstring'''
  
  
    def __init__(      self:		Optional[int]				,			UpperCamelCase_:		ResNetConfig				,			UpperCamelCase_:		int				,			UpperCamelCase_:		int				,			UpperCamelCase_:		int = 2				,			UpperCamelCase_:		int = 2				,			**UpperCamelCase_:		Optional[Any]					):
       super().__init__(**UpperCamelCase_					)
  
       UpperCamelCase_     =TFResNetBottleNeckLayer if config.layer_type == "bottleneck" else TFResNetBasicLayer
  
       UpperCamelCase_     =[layer(UpperCamelCase_				,			UpperCamelCase_				,			stride=UpperCamelCase_				,			activation=config.hidden_act				,			name="layers.0"					)]
       layers += [
           layer(UpperCamelCase_				,			UpperCamelCase_				,			activation=config.hidden_act				,			name=f"""layers.{i + 1}"""					)
           for i in range(depth - 1					)
       ]
       UpperCamelCase_     =layers
  
  
  
  
  
    def 					UpperCamelCase__   (      self:		str				,			UpperCamelCase_:		tf.Tensor				,			UpperCamelCase_:		bool = False					):
       for layer in self.stage_layers:
          UpperCamelCase_     =layer(UpperCamelCase_				,			training=UpperCamelCase_					)
       return hidden_state
  
  
  
  
  class 						__lowerCAmelCase   (			tf.keras.layers.Layer       ):
  
  
  
  
  
  
  
    '''simple docstring'''
  
  
    def __init__(      self:		Dict				,			UpperCamelCase_:		ResNetConfig				,			**UpperCamelCase_:		Any					):
       super().__init__(**UpperCamelCase_					)
       # based on `downsample_in_first_stage` the first layer of the first stage may or may not downsample the input
       UpperCamelCase_     =[
           TFResNetStage(
               UpperCamelCase_				,			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(UpperCamelCase_				,			UpperCamelCase_				,			UpperCamelCase_				,			depth=UpperCamelCase_				,			name=f"""stages.{i + 1}"""					)					)
  
  
  
  
  
    def 					UpperCamelCase__   (      self:		List[str]				,			UpperCamelCase_:		tf.Tensor				,			UpperCamelCase_:		bool = False				,			UpperCamelCase_:		bool = True				,			UpperCamelCase_:		bool = False				,			):
       UpperCamelCase_     =() if output_hidden_states else None
  
       for stage_module in self.stages:
          if output_hidden_states:
             UpperCamelCase_     =hidden_states + (hidden_state,)
  
          UpperCamelCase_     =stage_module(UpperCamelCase_				,			training=UpperCamelCase_					)
  
       if output_hidden_states:
          UpperCamelCase_     =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=UpperCamelCase_				,			hidden_states=UpperCamelCase_					)
  
  
  
  
  class 						__lowerCAmelCase   (			UpperCAmelCase       ):
  
  
  
  
  
  
  
    '''simple docstring'''
  
  
    __lowerCamelCase       :    Any     	=			ResNetConfig
    __lowerCamelCase       :    Dict     	=			"resnet"
    __lowerCamelCase       :    str     	=			"pixel_values"
    @property
    def 					UpperCamelCase__   (      self:		List[str]					):
       return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 224, 224)				,			dtype=tf.floataa					)}
  
  
  
  
  A_			  =    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"
  
  
  A_			  =    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 						__lowerCAmelCase   (			tf.keras.layers.Layer       ):
  
  
  
  
  
  
  
    '''simple docstring'''
  
  
    __lowerCamelCase       :    str     	=			ResNetConfig
    def __init__(      self:		str				,			UpperCamelCase_:		ResNetConfig				,			**UpperCamelCase_:		Any					):
       super().__init__(**UpperCamelCase_					)
       UpperCamelCase_     =config
       UpperCamelCase_     =TFResNetEmbeddings(UpperCamelCase_				,			name="embedder"					)
       UpperCamelCase_     =TFResNetEncoder(UpperCamelCase_				,			name="encoder"					)
       UpperCamelCase_     =tf.keras.layers.GlobalAveragePoolingaD(keepdims=UpperCamelCase_					)
  
  
  
  
  
    @unpack_inputs
    def 					UpperCamelCase__   (      self:		Any				,			UpperCamelCase_:		tf.Tensor				,			UpperCamelCase_:		Optional[bool] = None				,			UpperCamelCase_:		Optional[bool] = None				,			UpperCamelCase_:		bool = False				,			):
       UpperCamelCase_     =(
           output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
       )
       UpperCamelCase_     =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_     =tf.transpose(UpperCamelCase_				,			perm=[0, 2, 3, 1]					)
       UpperCamelCase_     =self.embedder(UpperCamelCase_				,			training=UpperCamelCase_					)
  
       UpperCamelCase_     =self.encoder(
           UpperCamelCase_				,			output_hidden_states=UpperCamelCase_				,			return_dict=UpperCamelCase_				,			training=UpperCamelCase_					)
  
       UpperCamelCase_     =encoder_outputs[0]
  
       UpperCamelCase_     =self.pooler(UpperCamelCase_					)
  
       # Transpose all the outputs to the NCHW format
       # (batch_size, height, width, num_channels) -> (batch_size, num_channels, height, width)
       UpperCamelCase_     =tf.transpose(UpperCamelCase_				,			(0, 3, 1, 2)					)
       UpperCamelCase_     =tf.transpose(UpperCamelCase_				,			(0, 3, 1, 2)					)
       UpperCamelCase_     =()
       for hidden_state in encoder_outputs[1:]:
          UpperCamelCase_     =hidden_states + tuple(tf.transpose(UpperCamelCase_				,			(0, 3, 1, 2)					) for h in hidden_state					)
  
       if not return_dict:
          return (last_hidden_state, pooled_output) + hidden_states
  
       UpperCamelCase_     =hidden_states if output_hidden_states else None
  
       return TFBaseModelOutputWithPoolingAndNoAttention(
           last_hidden_state=UpperCamelCase_				,			pooler_output=UpperCamelCase_				,			hidden_states=UpperCamelCase_				,			)
  
  
  
  
  @add_start_docstrings(
      "The bare ResNet model outputting raw features without any specific head on top."       ,   UpperCAmelCase       ,   )
  class 						__lowerCAmelCase   (			UpperCAmelCase       ):
  
  
  
  
  
  
  
    '''simple docstring'''
  
  
    def __init__(      self:		Tuple				,			UpperCamelCase_:		ResNetConfig				,			**UpperCamelCase_:		int					):
       super().__init__(UpperCamelCase_				,			**UpperCamelCase_					)
       UpperCamelCase_     =TFResNetMainLayer(config=UpperCamelCase_				,			name="resnet"					)
  
  
  
  
  
    @add_start_docstrings_to_model_forward(UpperCamelCase_					)
    @add_code_sample_docstrings(
        checkpoint=_CHECKPOINT_FOR_DOC				,			output_type=UpperCamelCase_				,			config_class=_CONFIG_FOR_DOC				,			modality="vision"				,			expected_output=_EXPECTED_OUTPUT_SHAPE				,			)
    @unpack_inputs
    def 					UpperCamelCase__   (      self:		List[str]				,			UpperCamelCase_:		tf.Tensor				,			UpperCamelCase_:		Optional[bool] = None				,			UpperCamelCase_:		Optional[bool] = None				,			UpperCamelCase_:		bool = False				,			):
       UpperCamelCase_     =(
           output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
       )
       UpperCamelCase_     =return_dict if return_dict is not None else self.config.use_return_dict
  
       UpperCamelCase_     =self.resnet(
           pixel_values=UpperCamelCase_				,			output_hidden_states=UpperCamelCase_				,			return_dict=UpperCamelCase_				,			training=UpperCamelCase_				,			)
       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 						__lowerCAmelCase   (			UpperCAmelCase       ,   UpperCAmelCase       ):
  
  
  
  
  
  
  
    '''simple docstring'''
  
  
    def __init__(      self:		List[Any]				,			UpperCamelCase_:		ResNetConfig				,			**UpperCamelCase_:		List[str]					):
       super().__init__(UpperCamelCase_				,			**UpperCamelCase_					)
       UpperCamelCase_     =config.num_labels
       UpperCamelCase_     =TFResNetMainLayer(UpperCamelCase_				,			name="resnet"					)
       # classification head
       UpperCamelCase_     =(
           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]				,			UpperCamelCase_:		tf.Tensor					):
       UpperCamelCase_     =tf.keras.layers.Flatten()(UpperCamelCase_					)
       UpperCamelCase_     =self.classifier_layer(UpperCamelCase_					)
       return logits
  
  
  
  
  
    @add_start_docstrings_to_model_forward(UpperCamelCase_					)
    @add_code_sample_docstrings(
        checkpoint=_IMAGE_CLASS_CHECKPOINT				,			output_type=UpperCamelCase_				,			config_class=_CONFIG_FOR_DOC				,			expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT				,			)
    @unpack_inputs
    def 					UpperCamelCase__   (      self:		Any				,			UpperCamelCase_:		tf.Tensor = None				,			UpperCamelCase_:		tf.Tensor = None				,			UpperCamelCase_:		bool = None				,			UpperCamelCase_:		bool = None				,			UpperCamelCase_:		bool = False				,			):
       UpperCamelCase_     =return_dict if return_dict is not None else self.config.use_return_dict
  
       UpperCamelCase_     =self.resnet(
           UpperCamelCase_				,			output_hidden_states=UpperCamelCase_				,			return_dict=UpperCamelCase_				,			training=UpperCamelCase_					)
  
       UpperCamelCase_     =outputs.pooler_output if return_dict else outputs[1]
  
       UpperCamelCase_     =self.classifier(UpperCamelCase_					)
  
       UpperCamelCase_     =None if labels is None else self.hf_compute_loss(UpperCamelCase_				,			UpperCamelCase_					)
  
       if not return_dict:
          UpperCamelCase_     =(logits,) + outputs[2:]
          return (loss,) + output if loss is not None else output
  
       return TFImageClassifierOutputWithNoAttention(loss=UpperCamelCase_				,			logits=UpperCamelCase_				,			hidden_states=outputs.hidden_states					)
  