


"""simple docstring"""


from typing import Optional, Tuple, Union

import tensorflow as tf

from ...activations_tf import ACTaFN
from ...file_utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward
from ...modeling_tf_outputs import (
    TFBaseModelOutputWithNoAttention,
    TFBaseModelOutputWithPoolingAndNoAttention,
    TFSequenceClassifierOutput,
)
from ...modeling_tf_utils import TFPreTrainedModel, TFSequenceClassificationLoss, keras_serializable, unpack_inputs
from ...tf_utils import shape_list
from ...utils import logging
from .configuration_regnet import RegNetConfig


_snake_case          =							logging.get_logger(__name__)

# General docstring
_snake_case          =							"RegNetConfig"

# Base docstring
_snake_case          =							"facebook/regnet-y-040"
_snake_case          =							[1, 1088, 7, 7]

# Image classification docstring
_snake_case          =							"facebook/regnet-y-040"
_snake_case          =							"tabby, tabby cat"

_snake_case          =							[
    "facebook/regnet-y-040",
    # See all regnet models at https://huggingface.co/models?filter=regnet
]



class   _a      (      tf.keras.layers.Layer ):
    def __init__( self							:					Dict							,					SCREAMING_SNAKE_CASE__							:					int							,					SCREAMING_SNAKE_CASE__							:					int = 3							,					SCREAMING_SNAKE_CASE__							:					int = 1							,					SCREAMING_SNAKE_CASE__							:					int = 1							,					SCREAMING_SNAKE_CASE__							:					Optional[str] = "relu"							,					**SCREAMING_SNAKE_CASE__							:					Optional[int]							,					):
          super().__init__(**SCREAMING_SNAKE_CASE__				)
          # The padding and conv has been verified in
          # https://colab.research.google.com/gist/sayakpaul/854bc10eeaf21c9ee2119e0b9f3841a7/scratchpad.ipynb
          lowerCamelCase__           =		tf.keras.layers.ZeroPaddingaD(padding=kernel_size // 2				)
          lowerCamelCase__           =		tf.keras.layers.ConvaD(
              filters=SCREAMING_SNAKE_CASE__							,					kernel_size=SCREAMING_SNAKE_CASE__							,					strides=SCREAMING_SNAKE_CASE__							,					padding='VALID'							,					groups=SCREAMING_SNAKE_CASE__							,					use_bias=SCREAMING_SNAKE_CASE__							,					name='convolution'							,					)
          lowerCamelCase__           =		tf.keras.layers.BatchNormalization(epsilon=1e-5							,					momentum=0.9							,					name='normalization'				)
          lowerCamelCase__           =		ACTaFN[activation] if activation is not None else tf.identity


    def      _UpperCamelCase       ( self							:					str							,					SCREAMING_SNAKE_CASE__							:					Tuple				):
          lowerCamelCase__           =		self.convolution(self.padding(SCREAMING_SNAKE_CASE__				)				)
          lowerCamelCase__           =		self.normalization(SCREAMING_SNAKE_CASE__				)
          lowerCamelCase__           =		self.activation(SCREAMING_SNAKE_CASE__				)
          return hidden_state





class   _a      (      tf.keras.layers.Layer ):
    def __init__( self							:					Union[str, Any]							,					SCREAMING_SNAKE_CASE__							:					RegNetConfig							,					**SCREAMING_SNAKE_CASE__							:					List[Any]				):
          super().__init__(**SCREAMING_SNAKE_CASE__				)
          lowerCamelCase__           =		config.num_channels
          lowerCamelCase__           =		TFRegNetConvLayer(
              out_channels=config.embedding_size							,					kernel_size=3							,					stride=2							,					activation=config.hidden_act							,					name='embedder'							,					)


    def      _UpperCamelCase       ( self							:					Any							,					SCREAMING_SNAKE_CASE__							:					List[Any]				):
          lowerCamelCase__           =		shape_list(SCREAMING_SNAKE_CASE__				)[1]
          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.'				)

          # When running on CPU, `tf.keras.layers.Conv2D` doesn't support `NCHW` format.
          # So change the input format from `NCHW` to `NHWC`.
          # shape = (batch_size, in_height, in_width, in_channels=num_channels)
          lowerCamelCase__           =		tf.transpose(SCREAMING_SNAKE_CASE__							,					perm=(0, 2, 3, 1)				)
          lowerCamelCase__           =		self.embedder(SCREAMING_SNAKE_CASE__				)
          return hidden_state





class   _a      (      tf.keras.layers.Layer ):
    def __init__( self							:					Dict							,					SCREAMING_SNAKE_CASE__							:					int							,					SCREAMING_SNAKE_CASE__							:					int = 2							,					**SCREAMING_SNAKE_CASE__							:					str				):
          super().__init__(**SCREAMING_SNAKE_CASE__				)
          lowerCamelCase__           =		tf.keras.layers.ConvaD(
              filters=SCREAMING_SNAKE_CASE__							,					kernel_size=1							,					strides=SCREAMING_SNAKE_CASE__							,					use_bias=SCREAMING_SNAKE_CASE__							,					name='convolution'				)
          lowerCamelCase__           =		tf.keras.layers.BatchNormalization(epsilon=1e-5							,					momentum=0.9							,					name='normalization'				)


    def      _UpperCamelCase       ( self							:					List[str]							,					SCREAMING_SNAKE_CASE__							:					tf.Tensor							,					SCREAMING_SNAKE_CASE__							:					bool = False				):
          return self.normalization(self.convolution(SCREAMING_SNAKE_CASE__				)							,					training=SCREAMING_SNAKE_CASE__				)





class   _a      (      tf.keras.layers.Layer ):
    def __init__( self							:					List[Any]							,					SCREAMING_SNAKE_CASE__							:					int							,					SCREAMING_SNAKE_CASE__							:					int							,					**SCREAMING_SNAKE_CASE__							:					Tuple				):
          super().__init__(**SCREAMING_SNAKE_CASE__				)
          lowerCamelCase__           =		tf.keras.layers.GlobalAveragePoolingaD(keepdims=SCREAMING_SNAKE_CASE__							,					name='pooler'				)
          lowerCamelCase__           =		[
              tf.keras.layers.ConvaD(filters=SCREAMING_SNAKE_CASE__							,					kernel_size=1							,					activation='relu'							,					name='attention.0'				),
              tf.keras.layers.ConvaD(filters=SCREAMING_SNAKE_CASE__							,					kernel_size=1							,					activation='sigmoid'							,					name='attention.2'				),
          ]


    def      _UpperCamelCase       ( self							:					List[str]							,					SCREAMING_SNAKE_CASE__							:					int				):
          # [batch_size, h, w, num_channels] -> [batch_size, 1, 1, num_channels]
          lowerCamelCase__           =		self.pooler(SCREAMING_SNAKE_CASE__				)
          for layer_module in self.attention:
                lowerCamelCase__           =		layer_module(SCREAMING_SNAKE_CASE__				)
          lowerCamelCase__           =		hidden_state * pooled
          return hidden_state





class   _a      (      tf.keras.layers.Layer ):
    def __init__( self							:					Any							,					SCREAMING_SNAKE_CASE__							:					RegNetConfig							,					SCREAMING_SNAKE_CASE__							:					int							,					SCREAMING_SNAKE_CASE__							:					int							,					SCREAMING_SNAKE_CASE__							:					int = 1							,					**SCREAMING_SNAKE_CASE__							:					Dict				):
          super().__init__(**SCREAMING_SNAKE_CASE__				)
          lowerCamelCase__           =		in_channels != out_channels or stride != 1
          lowerCamelCase__           =		max(1							,					out_channels // config.groups_width				)
          lowerCamelCase__           =		(
              TFRegNetShortCut(SCREAMING_SNAKE_CASE__							,					stride=SCREAMING_SNAKE_CASE__							,					name='shortcut'				)
              if should_apply_shortcut
              else tf.keras.layers.Activation('linear'							,					name='shortcut'				)
          )
          # `self.layers` instead of `self.layer` because that is a reserved argument.
          lowerCamelCase__           =		[
              TFRegNetConvLayer(SCREAMING_SNAKE_CASE__							,					kernel_size=1							,					activation=config.hidden_act							,					name='layer.0'				),
              TFRegNetConvLayer(
                  SCREAMING_SNAKE_CASE__							,					stride=SCREAMING_SNAKE_CASE__							,					groups=SCREAMING_SNAKE_CASE__							,					activation=config.hidden_act							,					name='layer.1'				),
              TFRegNetConvLayer(SCREAMING_SNAKE_CASE__							,					kernel_size=1							,					activation=SCREAMING_SNAKE_CASE__							,					name='layer.2'				),
          ]
          lowerCamelCase__           =		ACTaFN[config.hidden_act]


    def      _UpperCamelCase       ( self							:					Optional[Any]							,					SCREAMING_SNAKE_CASE__							:					str				):
          lowerCamelCase__           =		hidden_state
          for layer_module in self.layers:
                lowerCamelCase__           =		layer_module(SCREAMING_SNAKE_CASE__				)
          lowerCamelCase__           =		self.shortcut(SCREAMING_SNAKE_CASE__				)
          hidden_state += residual
          lowerCamelCase__           =		self.activation(SCREAMING_SNAKE_CASE__				)
          return hidden_state





class   _a      (      tf.keras.layers.Layer ):
    def __init__( self							:					List[str]							,					SCREAMING_SNAKE_CASE__							:					RegNetConfig							,					SCREAMING_SNAKE_CASE__							:					int							,					SCREAMING_SNAKE_CASE__							:					int							,					SCREAMING_SNAKE_CASE__							:					int = 1							,					**SCREAMING_SNAKE_CASE__							:					Any				):
          super().__init__(**SCREAMING_SNAKE_CASE__				)
          lowerCamelCase__           =		in_channels != out_channels or stride != 1
          lowerCamelCase__           =		max(1							,					out_channels // config.groups_width				)
          lowerCamelCase__           =		(
              TFRegNetShortCut(SCREAMING_SNAKE_CASE__							,					stride=SCREAMING_SNAKE_CASE__							,					name='shortcut'				)
              if should_apply_shortcut
              else tf.keras.layers.Activation('linear'							,					name='shortcut'				)
          )
          lowerCamelCase__           =		[
              TFRegNetConvLayer(SCREAMING_SNAKE_CASE__							,					kernel_size=1							,					activation=config.hidden_act							,					name='layer.0'				),
              TFRegNetConvLayer(
                  SCREAMING_SNAKE_CASE__							,					stride=SCREAMING_SNAKE_CASE__							,					groups=SCREAMING_SNAKE_CASE__							,					activation=config.hidden_act							,					name='layer.1'				),
              TFRegNetSELayer(SCREAMING_SNAKE_CASE__							,					reduced_channels=int(round(in_channels / 4				)				)							,					name='layer.2'				),
              TFRegNetConvLayer(SCREAMING_SNAKE_CASE__							,					kernel_size=1							,					activation=SCREAMING_SNAKE_CASE__							,					name='layer.3'				),
          ]
          lowerCamelCase__           =		ACTaFN[config.hidden_act]


    def      _UpperCamelCase       ( self							:					int							,					SCREAMING_SNAKE_CASE__							:					Optional[Any]				):
          lowerCamelCase__           =		hidden_state
          for layer_module in self.layers:
                lowerCamelCase__           =		layer_module(SCREAMING_SNAKE_CASE__				)
          lowerCamelCase__           =		self.shortcut(SCREAMING_SNAKE_CASE__				)
          hidden_state += residual
          lowerCamelCase__           =		self.activation(SCREAMING_SNAKE_CASE__				)
          return hidden_state





class   _a      (      tf.keras.layers.Layer ):
    def __init__( self							:					Optional[Any]							,					SCREAMING_SNAKE_CASE__							:					RegNetConfig							,					SCREAMING_SNAKE_CASE__							:					int							,					SCREAMING_SNAKE_CASE__							:					int							,					SCREAMING_SNAKE_CASE__							:					int = 2							,					SCREAMING_SNAKE_CASE__							:					int = 2							,					**SCREAMING_SNAKE_CASE__							:					Optional[Any]				):
          super().__init__(**SCREAMING_SNAKE_CASE__				)

          lowerCamelCase__           =		TFRegNetXLayer if config.layer_type == 'x' else TFRegNetYLayer
          lowerCamelCase__           =		[
              # downsampling is done in the first layer with stride of 2
              layer(SCREAMING_SNAKE_CASE__							,					SCREAMING_SNAKE_CASE__							,					SCREAMING_SNAKE_CASE__							,					stride=SCREAMING_SNAKE_CASE__							,					name='layers.0'				),
              *[layer(SCREAMING_SNAKE_CASE__							,					SCREAMING_SNAKE_CASE__							,					SCREAMING_SNAKE_CASE__							,					name=F'layers.{i+1}'				) for i in range(depth - 1				)],
          ]


    def      _UpperCamelCase       ( self							:					Optional[Any]							,					SCREAMING_SNAKE_CASE__							:					Optional[int]				):
          for layer_module in self.layers:
                lowerCamelCase__           =		layer_module(SCREAMING_SNAKE_CASE__				)
          return hidden_state





class   _a      (      tf.keras.layers.Layer ):
    def __init__( self							:					Optional[int]							,					SCREAMING_SNAKE_CASE__							:					RegNetConfig							,					**SCREAMING_SNAKE_CASE__							:					Optional[Any]				):
          super().__init__(**SCREAMING_SNAKE_CASE__				)
          lowerCamelCase__           =		[]
          # based on `downsample_in_first_stage`, the first layer of the first stage may or may not downsample the input
          self.stages.append(
              TFRegNetStage(
                  SCREAMING_SNAKE_CASE__							,					config.embedding_size							,					config.hidden_sizes[0]							,					stride=2 if config.downsample_in_first_stage else 1							,					depth=config.depths[0]							,					name='stages.0'							,					)				)
          lowerCamelCase__           =		zip(config.hidden_sizes							,					config.hidden_sizes[1:]				)
          for i, ((in_channels, out_channels), depth) in enumerate(zip(SCREAMING_SNAKE_CASE__							,					config.depths[1:]				)				):
                self.stages.append(TFRegNetStage(SCREAMING_SNAKE_CASE__							,					SCREAMING_SNAKE_CASE__							,					SCREAMING_SNAKE_CASE__							,					depth=SCREAMING_SNAKE_CASE__							,					name=F'stages.{i+1}'				)				)


    def      _UpperCamelCase       ( self							:					Dict							,					SCREAMING_SNAKE_CASE__							:					tf.Tensor							,					SCREAMING_SNAKE_CASE__							:					bool = False							,					SCREAMING_SNAKE_CASE__							:					bool = True				):
          lowerCamelCase__           =		() if output_hidden_states else None

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

                lowerCamelCase__           =		stage_module(SCREAMING_SNAKE_CASE__				)

          if output_hidden_states:
                lowerCamelCase__           =		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=SCREAMING_SNAKE_CASE__							,					hidden_states=SCREAMING_SNAKE_CASE__				)





@keras_serializable
class   _a      (      tf.keras.layers.Layer ):
    a_    :				Optional[int]             =    RegNetConfig
    def __init__( self							:					int							,					SCREAMING_SNAKE_CASE__							:					Optional[int]							,					**SCREAMING_SNAKE_CASE__							:					Dict				):
          super().__init__(**SCREAMING_SNAKE_CASE__				)
          lowerCamelCase__           =		config
          lowerCamelCase__           =		TFRegNetEmbeddings(SCREAMING_SNAKE_CASE__							,					name='embedder'				)
          lowerCamelCase__           =		TFRegNetEncoder(SCREAMING_SNAKE_CASE__							,					name='encoder'				)
          lowerCamelCase__           =		tf.keras.layers.GlobalAveragePoolingaD(keepdims=SCREAMING_SNAKE_CASE__							,					name='pooler'				)


    @unpack_inputs
    def      _UpperCamelCase       ( self							:					Optional[Any]							,					SCREAMING_SNAKE_CASE__							:					tf.Tensor							,					SCREAMING_SNAKE_CASE__							:					Optional[bool] = None							,					SCREAMING_SNAKE_CASE__							:					Optional[bool] = None							,					SCREAMING_SNAKE_CASE__							:					bool = False							,					):
          lowerCamelCase__           =		(
              output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
          )
          lowerCamelCase__           =		return_dict if return_dict is not None else self.config.use_return_dict

          lowerCamelCase__           =		self.embedder(SCREAMING_SNAKE_CASE__							,					training=SCREAMING_SNAKE_CASE__				)

          lowerCamelCase__           =		self.encoder(
              SCREAMING_SNAKE_CASE__							,					output_hidden_states=SCREAMING_SNAKE_CASE__							,					return_dict=SCREAMING_SNAKE_CASE__							,					training=SCREAMING_SNAKE_CASE__				)

          lowerCamelCase__           =		encoder_outputs[0]
          lowerCamelCase__           =		self.pooler(SCREAMING_SNAKE_CASE__				)

          # Change to NCHW output format have uniformity in the modules
          lowerCamelCase__           =		tf.transpose(SCREAMING_SNAKE_CASE__							,					perm=(0, 3, 1, 2)				)
          lowerCamelCase__           =		tf.transpose(SCREAMING_SNAKE_CASE__							,					perm=(0, 3, 1, 2)				)

          # Change the other hidden state outputs to NCHW as well
          if output_hidden_states:
                lowerCamelCase__           =		tuple([tf.transpose(SCREAMING_SNAKE_CASE__							,					perm=(0, 3, 1, 2)				) for h in encoder_outputs[1]]				)

          if not return_dict:
                return (last_hidden_state, pooled_output) + encoder_outputs[1:]

          return TFBaseModelOutputWithPoolingAndNoAttention(
              last_hidden_state=SCREAMING_SNAKE_CASE__							,					pooler_output=SCREAMING_SNAKE_CASE__							,					hidden_states=hidden_states if output_hidden_states else encoder_outputs.hidden_states							,					)





class   _a      (      SCREAMING_SNAKE_CASE_ ):
    a_    :				Optional[Any]             =    RegNetConfig
    a_    :				Optional[int]             =    'regnet'
    a_    :				str             =    'pixel_values'
    @property
    def      _UpperCamelCase       ( self							:					Tuple				):
          return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 2_24, 2_24)							,					dtype=tf.floataa				)}





_snake_case          =							R"\n    Parameters:\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        config ([`RegNetConfig`]): 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"

_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            [`ConveNextImageProcessor.__call__`] for details.\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"



@add_start_docstrings(
    'The bare RegNet model outputting raw features without any specific head on top.'		,		SCREAMING_SNAKE_CASE_		,		)
class   _a      (      SCREAMING_SNAKE_CASE_ ):
    def __init__( self							:					Optional[Any]							,					SCREAMING_SNAKE_CASE__							:					RegNetConfig							,					*SCREAMING_SNAKE_CASE__							:					Dict							,					**SCREAMING_SNAKE_CASE__							:					int				):
          super().__init__(SCREAMING_SNAKE_CASE__							,					*SCREAMING_SNAKE_CASE__							,					**SCREAMING_SNAKE_CASE__				)
          lowerCamelCase__           =		TFRegNetMainLayer(SCREAMING_SNAKE_CASE__							,					name='regnet'				)


    @unpack_inputs
    @add_start_docstrings_to_model_forward(SCREAMING_SNAKE_CASE__				)
    @add_code_sample_docstrings(
        checkpoint=_CHECKPOINT_FOR_DOC							,					output_type=SCREAMING_SNAKE_CASE__							,					config_class=_CONFIG_FOR_DOC							,					modality='vision'							,					expected_output=_EXPECTED_OUTPUT_SHAPE							,					)
    def      _UpperCamelCase       ( self							:					Optional[Any]							,					SCREAMING_SNAKE_CASE__							:					tf.Tensor							,					SCREAMING_SNAKE_CASE__							:					Optional[bool] = None							,					SCREAMING_SNAKE_CASE__							:					Optional[bool] = None							,					SCREAMING_SNAKE_CASE__							:					Any=False							,					):
          lowerCamelCase__           =		(
              output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
          )
          lowerCamelCase__           =		return_dict if return_dict is not None else self.config.use_return_dict

          lowerCamelCase__           =		self.regnet(
              pixel_values=SCREAMING_SNAKE_CASE__							,					output_hidden_states=SCREAMING_SNAKE_CASE__							,					return_dict=SCREAMING_SNAKE_CASE__							,					training=SCREAMING_SNAKE_CASE__							,					)
          if not return_dict:
                return (outputs[0],) + outputs[1:]

          return TFBaseModelOutputWithPoolingAndNoAttention(
              last_hidden_state=outputs.last_hidden_state							,					pooler_output=outputs.pooler_output							,					hidden_states=outputs.hidden_states							,					)





@add_start_docstrings(
    '\n    RegNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for\n    ImageNet.\n    '		,		SCREAMING_SNAKE_CASE_		,		)
class   _a      (      SCREAMING_SNAKE_CASE_		,		SCREAMING_SNAKE_CASE_ ):
    def __init__( self							:					Optional[int]							,					SCREAMING_SNAKE_CASE__							:					RegNetConfig							,					*SCREAMING_SNAKE_CASE__							:					Any							,					**SCREAMING_SNAKE_CASE__							:					List[Any]				):
          super().__init__(SCREAMING_SNAKE_CASE__							,					*SCREAMING_SNAKE_CASE__							,					**SCREAMING_SNAKE_CASE__				)
          lowerCamelCase__           =		config.num_labels
          lowerCamelCase__           =		TFRegNetMainLayer(SCREAMING_SNAKE_CASE__							,					name='regnet'				)
          # classification head
          lowerCamelCase__           =		[
              tf.keras.layers.Flatten(),
              tf.keras.layers.Dense(config.num_labels							,					name='classifier.1'				) if config.num_labels > 0 else tf.identity,
          ]


    @unpack_inputs
    @add_start_docstrings_to_model_forward(SCREAMING_SNAKE_CASE__				)
    @add_code_sample_docstrings(
        checkpoint=_IMAGE_CLASS_CHECKPOINT							,					output_type=SCREAMING_SNAKE_CASE__							,					config_class=_CONFIG_FOR_DOC							,					expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT							,					)
    def      _UpperCamelCase       ( self							:					List[str]							,					SCREAMING_SNAKE_CASE__							:					tf.Tensor = None							,					SCREAMING_SNAKE_CASE__							:					tf.Tensor = None							,					SCREAMING_SNAKE_CASE__							:					bool = None							,					SCREAMING_SNAKE_CASE__							:					bool = None							,					SCREAMING_SNAKE_CASE__							:					List[str]=False							,					):
          lowerCamelCase__           =		(
              output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
          )
          lowerCamelCase__           =		return_dict if return_dict is not None else self.config.use_return_dict

          lowerCamelCase__           =		self.regnet(
              SCREAMING_SNAKE_CASE__							,					output_hidden_states=SCREAMING_SNAKE_CASE__							,					return_dict=SCREAMING_SNAKE_CASE__							,					training=SCREAMING_SNAKE_CASE__				)

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

          lowerCamelCase__           =		self.classifier[0](SCREAMING_SNAKE_CASE__				)
          lowerCamelCase__           =		self.classifier[1](SCREAMING_SNAKE_CASE__				)

          lowerCamelCase__           =		None if labels is None else self.hf_compute_loss(labels=SCREAMING_SNAKE_CASE__							,					logits=SCREAMING_SNAKE_CASE__				)

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

          return TFSequenceClassifierOutput(loss=SCREAMING_SNAKE_CASE__							,					logits=SCREAMING_SNAKE_CASE__							,					hidden_states=outputs.hidden_states				)







"""simple docstring"""


from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


_snake_case          =							{
    "configuration_blenderbot": [
        "BLENDERBOT_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "BlenderbotConfig",
        "BlenderbotOnnxConfig",
    ],
    "tokenization_blenderbot": ["BlenderbotTokenizer"],
}

try:
   if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _snake_case          =							["BlenderbotTokenizerFast"]

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _snake_case          =							[
       "BLENDERBOT_PRETRAINED_MODEL_ARCHIVE_LIST",
       "BlenderbotForCausalLM",
       "BlenderbotForConditionalGeneration",
       "BlenderbotModel",
       "BlenderbotPreTrainedModel",
   ]


try:
   if not is_tf_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _snake_case          =							[
       "TFBlenderbotForConditionalGeneration",
       "TFBlenderbotModel",
       "TFBlenderbotPreTrainedModel",
   ]


try:
   if not is_flax_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _snake_case          =							[
       "FlaxBlenderbotForConditionalGeneration",
       "FlaxBlenderbotModel",
       "FlaxBlenderbotPreTrainedModel",
   ]


if TYPE_CHECKING:
   from .configuration_blenderbot import (
       BLENDERBOT_PRETRAINED_CONFIG_ARCHIVE_MAP,
       BlenderbotConfig,
       BlenderbotOnnxConfig,
   )
   from .tokenization_blenderbot import BlenderbotTokenizer

   try:
      if not is_tokenizers_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .tokenization_blenderbot_fast import BlenderbotTokenizerFast

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_blenderbot import (
          BLENDERBOT_PRETRAINED_MODEL_ARCHIVE_LIST,
          BlenderbotForCausalLM,
          BlenderbotForConditionalGeneration,
          BlenderbotModel,
          BlenderbotPreTrainedModel,
      )

   try:
      if not is_tf_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_tf_blenderbot import (
          TFBlenderbotForConditionalGeneration,
          TFBlenderbotModel,
          TFBlenderbotPreTrainedModel,
      )

   try:
      if not is_flax_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_flax_blenderbot import (
          FlaxBlenderbotForConditionalGeneration,
          FlaxBlenderbotModel,
          FlaxBlenderbotPreTrainedModel,
      )

else:
   import sys

   _snake_case          =							_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)



