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


lowerCAmelCase			:							int     =logging.get_logger(__name__)

# General docstring
lowerCAmelCase			:							List[Any]     ="RegNetConfig"

# Base docstring
lowerCAmelCase			:							Union[str, Any]     ="facebook/regnet-y-040"
lowerCAmelCase			:							Optional[int]     =[1, 1088, 7, 7]

# Image classification docstring
lowerCAmelCase			:							Dict     ="facebook/regnet-y-040"
lowerCAmelCase			:							List[Any]     ="tabby, tabby cat"

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




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





      '''simple docstring'''






      def __init__(					self     :				List[Any]    ,  _UpperCamelCase     :				int    ,  _UpperCamelCase     :				int = 3    ,  _UpperCamelCase     :				int = 1    ,  _UpperCamelCase     :				int = 1    ,  _UpperCamelCase     :				Optional[str] = "relu"    ,  **_UpperCamelCase     :				str    ,  )				->Optional[Any]:


          """simple docstring"""


          super().__init__(**_UpperCamelCase)
          # The padding and conv has been verified in
          # https://colab.research.google.com/gist/sayakpaul/854bc10eeaf21c9ee2119e0b9f3841a7/scratchpad.ipynb
          _lowerCamelCase     :		List[Any] 						=						tf.keras.layers.ZeroPaddingaD(padding=kernel_size // 2)
          _lowerCamelCase     :		Optional[int] 						=						tf.keras.layers.ConvaD(
              filters=_UpperCamelCase    ,  kernel_size=_UpperCamelCase    ,  strides=_UpperCamelCase    ,  padding="""VALID"""    ,  groups=_UpperCamelCase    ,  use_bias=_UpperCamelCase    ,  name="""convolution"""    ,  )
          _lowerCamelCase     :		Optional[Any] 						=						tf.keras.layers.BatchNormalization(epsilon=1E-5    ,  momentum=0.9    ,  name="""normalization""")
          _lowerCamelCase     :		Optional[Any] 						=						ACTaFN[activation] if activation is not None else tf.identity




      def 	_SCREAMING_SNAKE_CASE    (					self     :				List[Any]    ,  _UpperCamelCase     :				int)				->int:


          """simple docstring"""


          _lowerCamelCase     :		List[Any] 						=						self.convolution(self.padding(_UpperCamelCase))
          _lowerCamelCase     :		List[Any] 						=						self.normalization(_UpperCamelCase)
          _lowerCamelCase     :		Optional[Any] 						=						self.activation(_UpperCamelCase)
          return hidden_state





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





      '''simple docstring'''






      def __init__(					self     :				Optional[Any]    ,  _UpperCamelCase     :				RegNetConfig    ,  **_UpperCamelCase     :				Union[str, Any])				->Union[str, Any]:


          """simple docstring"""


          super().__init__(**_UpperCamelCase)
          _lowerCamelCase     :		List[str] 						=						config.num_channels
          _lowerCamelCase     :		Any 						=						TFRegNetConvLayer(
              out_channels=config.embedding_size    ,  kernel_size=3    ,  stride=2    ,  activation=config.hidden_act    ,  name="""embedder"""    ,  )




      def 	_SCREAMING_SNAKE_CASE    (					self     :				List[Any]    ,  _UpperCamelCase     :				Dict)				->Any:


          """simple docstring"""


          _lowerCamelCase     :		Optional[int] 						=						shape_list(_UpperCamelCase)[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     :		Union[str, Any] 						=						tf.transpose(_UpperCamelCase    ,  perm=(0, 2, 3, 1))
          _lowerCamelCase     :		Optional[int] 						=						self.embedder(_UpperCamelCase)
          return hidden_state





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





      '''simple docstring'''






      def __init__(					self     :				Any    ,  _UpperCamelCase     :				int    ,  _UpperCamelCase     :				int = 2    ,  **_UpperCamelCase     :				List[Any])				->Dict:


          """simple docstring"""


          super().__init__(**_UpperCamelCase)
          _lowerCamelCase     :		Any 						=						tf.keras.layers.ConvaD(
              filters=_UpperCamelCase    ,  kernel_size=1    ,  strides=_UpperCamelCase    ,  use_bias=_UpperCamelCase    ,  name="""convolution""")
          _lowerCamelCase     :		Any 						=						tf.keras.layers.BatchNormalization(epsilon=1E-5    ,  momentum=0.9    ,  name="""normalization""")




      def 	_SCREAMING_SNAKE_CASE    (					self     :				str    ,  _UpperCamelCase     :				tf.Tensor    ,  _UpperCamelCase     :				bool = False)				->tf.Tensor:


          """simple docstring"""


          return self.normalization(self.convolution(_UpperCamelCase)    ,  training=_UpperCamelCase)





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





      '''simple docstring'''






      def __init__(					self     :				List[Any]    ,  _UpperCamelCase     :				int    ,  _UpperCamelCase     :				int    ,  **_UpperCamelCase     :				List[Any])				->Dict:


          """simple docstring"""


          super().__init__(**_UpperCamelCase)
          _lowerCamelCase     :		Optional[Any] 						=						tf.keras.layers.GlobalAveragePoolingaD(keepdims=_UpperCamelCase    ,  name="""pooler""")
          _lowerCamelCase     :		Optional[Any] 						=						[
              tf.keras.layers.ConvaD(filters=_UpperCamelCase    ,  kernel_size=1    ,  activation="""relu"""    ,  name="""attention.0"""),
              tf.keras.layers.ConvaD(filters=_UpperCamelCase    ,  kernel_size=1    ,  activation="""sigmoid"""    ,  name="""attention.2"""),
          ]




      def 	_SCREAMING_SNAKE_CASE    (					self     :				Dict    ,  _UpperCamelCase     :				int)				->Dict:


          """simple docstring"""


          _lowerCamelCase     :		str 						=						self.pooler(_UpperCamelCase)
          for layer_module in self.attention:
              _lowerCamelCase     :		str 						=						layer_module(_UpperCamelCase)
          _lowerCamelCase     :		Dict 						=						hidden_state * pooled
          return hidden_state





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





      '''simple docstring'''






      def __init__(					self     :				int    ,  _UpperCamelCase     :				RegNetConfig    ,  _UpperCamelCase     :				int    ,  _UpperCamelCase     :				int    ,  _UpperCamelCase     :				int = 1    ,  **_UpperCamelCase     :				List[str])				->List[Any]:


          """simple docstring"""


          super().__init__(**_UpperCamelCase)
          _lowerCamelCase     :		List[Any] 						=						in_channels != out_channels or stride != 1
          _lowerCamelCase     :		Optional[int] 						=						max(1    ,  out_channels // config.groups_width)
          _lowerCamelCase     :		Dict 						=						(
              TFRegNetShortCut(_UpperCamelCase    ,  stride=_UpperCamelCase    ,  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     :		Optional[Any] 						=						[
              TFRegNetConvLayer(_UpperCamelCase    ,  kernel_size=1    ,  activation=config.hidden_act    ,  name="""layer.0"""),
              TFRegNetConvLayer(
                  _UpperCamelCase    ,  stride=_UpperCamelCase    ,  groups=_UpperCamelCase    ,  activation=config.hidden_act    ,  name="""layer.1"""),
              TFRegNetConvLayer(_UpperCamelCase    ,  kernel_size=1    ,  activation=_UpperCamelCase    ,  name="""layer.2"""),
          ]
          _lowerCamelCase     :		Dict 						=						ACTaFN[config.hidden_act]




      def 	_SCREAMING_SNAKE_CASE    (					self     :				Dict    ,  _UpperCamelCase     :				Any)				->Optional[Any]:


          """simple docstring"""


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





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





      '''simple docstring'''






      def __init__(					self     :				Dict    ,  _UpperCamelCase     :				RegNetConfig    ,  _UpperCamelCase     :				int    ,  _UpperCamelCase     :				int    ,  _UpperCamelCase     :				int = 1    ,  **_UpperCamelCase     :				str)				->Any:


          """simple docstring"""


          super().__init__(**_UpperCamelCase)
          _lowerCamelCase     :		Optional[Any] 						=						in_channels != out_channels or stride != 1
          _lowerCamelCase     :		Optional[Any] 						=						max(1    ,  out_channels // config.groups_width)
          _lowerCamelCase     :		Any 						=						(
              TFRegNetShortCut(_UpperCamelCase    ,  stride=_UpperCamelCase    ,  name="""shortcut""")
              if should_apply_shortcut
              else tf.keras.layers.Activation("""linear"""    ,  name="""shortcut""")
          )
          _lowerCamelCase     :		Any 						=						[
              TFRegNetConvLayer(_UpperCamelCase    ,  kernel_size=1    ,  activation=config.hidden_act    ,  name="""layer.0"""),
              TFRegNetConvLayer(
                  _UpperCamelCase    ,  stride=_UpperCamelCase    ,  groups=_UpperCamelCase    ,  activation=config.hidden_act    ,  name="""layer.1"""),
              TFRegNetSELayer(_UpperCamelCase    ,  reduced_channels=int(round(in_channels / 4))    ,  name="""layer.2"""),
              TFRegNetConvLayer(_UpperCamelCase    ,  kernel_size=1    ,  activation=_UpperCamelCase    ,  name="""layer.3"""),
          ]
          _lowerCamelCase     :		List[str] 						=						ACTaFN[config.hidden_act]




      def 	_SCREAMING_SNAKE_CASE    (					self     :				List[str]    ,  _UpperCamelCase     :				Optional[Any])				->Dict:


          """simple docstring"""


          _lowerCamelCase     :		str 						=						hidden_state
          for layer_module in self.layers:
              _lowerCamelCase     :		Tuple 						=						layer_module(_UpperCamelCase)
          _lowerCamelCase     :		Optional[int] 						=						self.shortcut(_UpperCamelCase)
          hidden_state += residual
          _lowerCamelCase     :		Any 						=						self.activation(_UpperCamelCase)
          return hidden_state





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





      '''simple docstring'''






      def __init__(					self     :				Any    ,  _UpperCamelCase     :				RegNetConfig    ,  _UpperCamelCase     :				int    ,  _UpperCamelCase     :				int    ,  _UpperCamelCase     :				int = 2    ,  _UpperCamelCase     :				int = 2    ,  **_UpperCamelCase     :				int)				->Optional[Any]:


          """simple docstring"""


          super().__init__(**_UpperCamelCase)

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




      def 	_SCREAMING_SNAKE_CASE    (					self     :				Tuple    ,  _UpperCamelCase     :				str)				->int:


          """simple docstring"""


          for layer_module in self.layers:
              _lowerCamelCase     :		Union[str, Any] 						=						layer_module(_UpperCamelCase)
          return hidden_state





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





      '''simple docstring'''






      def __init__(					self     :				int    ,  _UpperCamelCase     :				RegNetConfig    ,  **_UpperCamelCase     :				Any)				->Any:


          """simple docstring"""


          super().__init__(**_UpperCamelCase)
          _lowerCamelCase     :		Any 						=						[]
          # based on `downsample_in_first_stage`, the first layer of the first stage may or may not downsample the input
          self.stages.append(
              TFRegNetStage(
                  _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"""    ,  ))
          _lowerCamelCase     :		Tuple 						=						zip(config.hidden_sizes    ,  config.hidden_sizes[1:])
          for i, ((in_channels, out_channels), depth) in enumerate(zip(_UpperCamelCase    ,  config.depths[1:])):
              self.stages.append(TFRegNetStage(_UpperCamelCase    ,  _UpperCamelCase    ,  _UpperCamelCase    ,  depth=_UpperCamelCase    ,  name=F"""stages.{i+1}"""))




      def 	_SCREAMING_SNAKE_CASE    (					self     :				Union[str, Any]    ,  _UpperCamelCase     :				tf.Tensor    ,  _UpperCamelCase     :				bool = False    ,  _UpperCamelCase     :				bool = True)				->TFBaseModelOutputWithNoAttention:


          """simple docstring"""


          _lowerCamelCase     :		Any 						=						() if output_hidden_states else None

          for stage_module in self.stages:
              if output_hidden_states:
                  _lowerCamelCase     :		Union[str, Any] 						=						hidden_states + (hidden_state,)

              _lowerCamelCase     :		Tuple 						=						stage_module(_UpperCamelCase)

          if output_hidden_states:
              _lowerCamelCase     :		List[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=_UpperCamelCase    ,  hidden_states=_UpperCamelCase)





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





      '''simple docstring'''






      _snake_case    		=       RegNetConfig



      def __init__(					self     :				Optional[Any]    ,  _UpperCamelCase     :				List[str]    ,  **_UpperCamelCase     :				Any)				->Tuple:


          """simple docstring"""


          super().__init__(**_UpperCamelCase)
          _lowerCamelCase     :		Optional[Any] 						=						config
          _lowerCamelCase     :		Dict 						=						TFRegNetEmbeddings(_UpperCamelCase    ,  name="""embedder""")
          _lowerCamelCase     :		Optional[int] 						=						TFRegNetEncoder(_UpperCamelCase    ,  name="""encoder""")
          _lowerCamelCase     :		str 						=						tf.keras.layers.GlobalAveragePoolingaD(keepdims=_UpperCamelCase    ,  name="""pooler""")




      @unpack_inputs
      def 	_SCREAMING_SNAKE_CASE    (					self     :				Optional[int]    ,  _UpperCamelCase     :				tf.Tensor    ,  _UpperCamelCase     :				Optional[bool] = None    ,  _UpperCamelCase     :				Optional[bool] = None    ,  _UpperCamelCase     :				bool = False    ,  )				->TFBaseModelOutputWithPoolingAndNoAttention:


          """simple docstring"""


          _lowerCamelCase     :		Tuple 						=						(
              output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
          )
          _lowerCamelCase     :		Optional[Any] 						=						return_dict if return_dict is not None else self.config.use_return_dict

          _lowerCamelCase     :		Optional[int] 						=						self.embedder(_UpperCamelCase    ,  training=_UpperCamelCase)

          _lowerCamelCase     :		int 						=						self.encoder(
              _UpperCamelCase    ,  output_hidden_states=_UpperCamelCase    ,  return_dict=_UpperCamelCase    ,  training=_UpperCamelCase)

          _lowerCamelCase     :		Dict 						=						encoder_outputs[0]
          _lowerCamelCase     :		Any 						=						self.pooler(_UpperCamelCase)

          # Change to NCHW output format have uniformity in the modules
          _lowerCamelCase     :		Optional[int] 						=						tf.transpose(_UpperCamelCase    ,  perm=(0, 3, 1, 2))
          _lowerCamelCase     :		Any 						=						tf.transpose(_UpperCamelCase    ,  perm=(0, 3, 1, 2))

          # Change the other hidden state outputs to NCHW as well
          if output_hidden_states:
              _lowerCamelCase     :		int 						=						tuple([tf.transpose(_UpperCamelCase    ,  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=_UpperCamelCase    ,  pooler_output=_UpperCamelCase    ,  hidden_states=hidden_states if output_hidden_states else encoder_outputs.hidden_states    ,  )





class 	__snake_case	( __lowerCAmelCase		):





      '''simple docstring'''






      _snake_case    		=       RegNetConfig
      _snake_case    		=       'regnet'
      _snake_case    		=       'pixel_values'



      @property
      def 	_SCREAMING_SNAKE_CASE    (					self     :				int)				->Tuple:


          """simple docstring"""


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





lowerCAmelCase			:							Optional[int]     =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"

lowerCAmelCase			:							int     =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.' ,  __lowerCAmelCase ,  )
class 	__snake_case	( __lowerCAmelCase		):





      '''simple docstring'''






      def __init__(					self     :				List[Any]    ,  _UpperCamelCase     :				RegNetConfig    ,  *_UpperCamelCase     :				int    ,  **_UpperCamelCase     :				List[Any])				->List[str]:


          """simple docstring"""


          super().__init__(_UpperCamelCase    ,  *_UpperCamelCase    ,  **_UpperCamelCase)
          _lowerCamelCase     :		int 						=						TFRegNetMainLayer(_UpperCamelCase    ,  name="""regnet""")




      @unpack_inputs
      @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    ,  )
      def 	_SCREAMING_SNAKE_CASE    (					self     :				List[Any]    ,  _UpperCamelCase     :				tf.Tensor    ,  _UpperCamelCase     :				Optional[bool] = None    ,  _UpperCamelCase     :				Optional[bool] = None    ,  _UpperCamelCase     :				Tuple=False    ,  )				->Union[TFBaseModelOutputWithPoolingAndNoAttention, Tuple[tf.Tensor]]:


          """simple docstring"""


          _lowerCamelCase     :		Any 						=						(
              output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
          )
          _lowerCamelCase     :		str 						=						return_dict if return_dict is not None else self.config.use_return_dict

          _lowerCamelCase     :		List[str] 						=						self.regnet(
              pixel_values=_UpperCamelCase    ,  output_hidden_states=_UpperCamelCase    ,  return_dict=_UpperCamelCase    ,  training=_UpperCamelCase    ,  )
          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    ' ,  __lowerCAmelCase ,  )
class 	__snake_case	( __lowerCAmelCase ,  __lowerCAmelCase		):





      '''simple docstring'''






      def __init__(					self     :				str    ,  _UpperCamelCase     :				RegNetConfig    ,  *_UpperCamelCase     :				Optional[Any]    ,  **_UpperCamelCase     :				List[Any])				->Dict:


          """simple docstring"""


          super().__init__(_UpperCamelCase    ,  *_UpperCamelCase    ,  **_UpperCamelCase)
          _lowerCamelCase     :		Any 						=						config.num_labels
          _lowerCamelCase     :		Union[str, Any] 						=						TFRegNetMainLayer(_UpperCamelCase    ,  name="""regnet""")
          # classification head
          _lowerCamelCase     :		Union[str, Any] 						=						[
              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(_UpperCamelCase)
      @add_code_sample_docstrings(
          checkpoint=_IMAGE_CLASS_CHECKPOINT    ,  output_type=_UpperCamelCase    ,  config_class=_CONFIG_FOR_DOC    ,  expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT    ,  )
      def 	_SCREAMING_SNAKE_CASE    (					self     :				Optional[int]    ,  _UpperCamelCase     :				tf.Tensor = None    ,  _UpperCamelCase     :				tf.Tensor = None    ,  _UpperCamelCase     :				bool = None    ,  _UpperCamelCase     :				bool = None    ,  _UpperCamelCase     :				List[Any]=False    ,  )				->Union[TFSequenceClassifierOutput, Tuple[tf.Tensor]]:


          """simple docstring"""


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

          _lowerCamelCase     :		List[str] 						=						self.regnet(
              _UpperCamelCase    ,  output_hidden_states=_UpperCamelCase    ,  return_dict=_UpperCamelCase    ,  training=_UpperCamelCase)

          _lowerCamelCase     :		Dict 						=						outputs.pooler_output if return_dict else outputs[1]

          _lowerCamelCase     :		Any 						=						self.classifier[0](_UpperCamelCase)
          _lowerCamelCase     :		List[Any] 						=						self.classifier[1](_UpperCamelCase)

          _lowerCamelCase     :		List[Any] 						=						None if labels is None else self.hf_compute_loss(labels=_UpperCamelCase    ,  logits=_UpperCamelCase)

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

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





def 						A__  (					__A   , __A	):







    '''simple docstring'''
    _enforce_args(__A   , __A	)
    if n == 0:
        return 0
    _lowerCamelCase     :		Tuple 						=						float("""-inf"""	)
    for i in range(1   , n + 1	):
        _lowerCamelCase     :		Any 						=						max(
            __A   , prices[i - 1] + naive_cut_rod_recursive(n - i   , __A	)	)

    return max_revue







def 						A__  (					__A   , __A	):







    '''simple docstring'''
    _enforce_args(__A   , __A	)
    _lowerCamelCase     :		Optional[Any] 						=						[float("""-inf"""	) for _ in range(n + 1	)]
    return _top_down_cut_rod_recursive(__A   , __A   , __A	)







def 						A__  (					__A   , __A   , __A	):







    '''simple docstring'''
    if max_rev[n] >= 0:
        return max_rev[n]
    elif n == 0:
        return 0
    else:
        _lowerCamelCase     :		int 						=						float("""-inf"""	)
        for i in range(1   , n + 1	):
            _lowerCamelCase     :		Optional[Any] 						=						max(
                __A   , prices[i - 1] + _top_down_cut_rod_recursive(n - i   , __A   , __A	)   , )

        _lowerCamelCase     :		Optional[Any] 						=						max_revenue

    return max_rev[n]







def 						A__  (					__A   , __A	):







    '''simple docstring'''
    _enforce_args(__A   , __A	)

    # length(max_rev) = n + 1, to accommodate for the revenue obtainable from a rod of
    # length 0.
    _lowerCamelCase     :		List[Any] 						=						[float("""-inf"""	) for _ in range(n + 1	)]
    _lowerCamelCase     :		Any 						=						0

    for i in range(1   , n + 1	):
        _lowerCamelCase     :		Any 						=						max_rev[i]
        for j in range(1   , i + 1	):
            _lowerCamelCase     :		List[Any] 						=						max(__A   , prices[j - 1] + max_rev[i - j]	)

        _lowerCamelCase     :		int 						=						max_revenue_i

    return max_rev[n]







def 						A__  (					__A   , __A	):







    '''simple docstring'''
    if n < 0:
        _lowerCamelCase     :		Any 						=						F"""n must be greater than or equal to 0. Got n = {n}"""
        raise ValueError(__A	)

    if n > len(__A	):
        _lowerCamelCase     :		List[Any] 						=						(
            """Each integral piece of rod must have a corresponding price. """
            F"""Got n = {n} but length of prices = {len(__A	)}"""
        )
        raise ValueError(__A	)







def 						A__  (					):







    '''simple docstring'''
    _lowerCamelCase     :		str 						=						[6, 10, 12, 15, 20, 23]
    _lowerCamelCase     :		List[str] 						=						len(__A	)

    # the best revenue comes from cutting the rod into 6 pieces, each
    # of length 1 resulting in a revenue of 6 * 6 = 36.
    _lowerCamelCase     :		Tuple 						=						36

    _lowerCamelCase     :		Any 						=						top_down_cut_rod(__A   , __A	)
    _lowerCamelCase     :		Dict 						=						bottom_up_cut_rod(__A   , __A	)
    _lowerCamelCase     :		List[str] 						=						naive_cut_rod_recursive(__A   , __A	)

    assert expected_max_revenue == max_rev_top_down
    assert max_rev_top_down == max_rev_bottom_up
    assert max_rev_bottom_up == max_rev_naive


if __name__ == "__main__":
    main()




