

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						:Union[str, Any]            = logging.get_logger(__name__)

# General docstring
__a						:Any            = 'ResNetConfig'

# Base docstring
__a						:Optional[Any]            = 'microsoft/resnet-50'
__a						:List[str]            = [1, 2048, 7, 7]

# Image classification docstring
__a						:Optional[Any]            = 'microsoft/resnet-50'
__a						:List[str]            = 'tiger cat'

__a						:List[str]            = [
    'microsoft/resnet-50',
    # See all resnet models at https://huggingface.co/models?filter=resnet
]

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




      """simple docstring"""

      def __init__(      self       :							Dict	, UpperCAmelCase       :							int	, UpperCAmelCase       :							int = 3	, UpperCAmelCase       :							int = 1	, UpperCAmelCase       :							str = "relu"	, **UpperCAmelCase       :							Optional[Any]  ):
            super().__init__(**UpperCAmelCase  )
            A_	     =							kernel_size // 2
            A_	     =							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
            A_	     =							tf.keras.layers.BatchNormalization(epsilon=1E-5	, momentum=0.9	, name="normalization"  )
            A_	     =							ACTaFN[activation] if activation is not None else tf.keras.layers.Activation("linear"  )





      def 		__A  (      self       :							List[Any]	, UpperCAmelCase       :							tf.Tensor  ):
            # Pad to match that done in the PyTorch Conv2D model
            A_	     =							A_	     =							(self.pad_value, self.pad_value)
            A_	     =							tf.pad(UpperCAmelCase	, [(0, 0), height_pad, width_pad, (0, 0)]  )
            A_	     =							self.conv(UpperCAmelCase  )
            return hidden_state







      def 		__A  (      self       :							List[Any]	, UpperCAmelCase       :							tf.Tensor	, UpperCAmelCase       :							bool = False  ):
            A_	     =							self.convolution(UpperCAmelCase  )
            A_	     =							self.normalization(UpperCAmelCase	, training=UpperCAmelCase  )
            A_	     =							self.activation(UpperCAmelCase  )
            return hidden_state




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




      """simple docstring"""

      def __init__(      self       :							Dict	, UpperCAmelCase       :							ResNetConfig	, **UpperCAmelCase       :							Dict  ):
            super().__init__(**UpperCAmelCase  )
            A_	     =							TFResNetConvLayer(
                config.embedding_size	, kernel_size=7	, stride=2	, activation=config.hidden_act	, name="embedder"	, )
            A_	     =							tf.keras.layers.MaxPoolaD(pool_size=3	, strides=2	, padding="valid"	, name="pooler"  )
            A_	     =							config.num_channels







      def 		__A  (      self       :							str	, UpperCAmelCase       :							tf.Tensor	, UpperCAmelCase       :							bool = False  ):
            A_     ,    A_     ,    A_     ,    A_	     =							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."  )
            A_	     =							pixel_values
            A_	     =							self.embedder(UpperCAmelCase  )
            A_	     =							tf.pad(UpperCAmelCase	, [[0, 0], [1, 1], [1, 1], [0, 0]]  )
            A_	     =							self.pooler(UpperCAmelCase  )
            return hidden_state




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




      """simple docstring"""

      def __init__(      self       :							List[str]	, UpperCAmelCase       :							int	, UpperCAmelCase       :							int = 2	, **UpperCAmelCase       :							Tuple  ):
            super().__init__(**UpperCAmelCase  )
            A_	     =							tf.keras.layers.ConvaD(
                UpperCAmelCase	, kernel_size=1	, strides=UpperCAmelCase	, use_bias=UpperCAmelCase	, name="convolution"  )
            # Use same default momentum and epsilon as PyTorch equivalent
            A_	     =							tf.keras.layers.BatchNormalization(epsilon=1E-5	, momentum=0.9	, name="normalization"  )







      def 		__A  (      self       :							Union[str, Any]	, UpperCAmelCase       :							tf.Tensor	, UpperCAmelCase       :							bool = False  ):
            A_	     =							x
            A_	     =							self.convolution(UpperCAmelCase  )
            A_	     =							self.normalization(UpperCAmelCase	, training=UpperCAmelCase  )
            return hidden_state




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




      """simple docstring"""

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







      def 		__A  (      self       :							Dict	, UpperCAmelCase       :							tf.Tensor	, UpperCAmelCase       :							bool = False  ):
            A_	     =							hidden_state
            A_	     =							self.conva(UpperCAmelCase	, training=UpperCAmelCase  )
            A_	     =							self.conva(UpperCAmelCase	, training=UpperCAmelCase  )
            A_	     =							self.shortcut(UpperCAmelCase	, training=UpperCAmelCase  )
            hidden_state += residual
            A_	     =							self.activation(UpperCAmelCase  )
            return hidden_state




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




      """simple docstring"""

      def __init__(      self       :							List[str]	, UpperCAmelCase       :							int	, UpperCAmelCase       :							int	, UpperCAmelCase       :							int = 1	, UpperCAmelCase       :							str = "relu"	, UpperCAmelCase       :							int = 4	, **UpperCAmelCase       :							Optional[int]	, ):
            super().__init__(**UpperCAmelCase  )
            A_	     =							in_channels != out_channels or stride != 1
            A_	     =							out_channels // reduction
            A_	     =							TFResNetConvLayer(UpperCAmelCase	, kernel_size=1	, name="layer.0"  )
            A_	     =							TFResNetConvLayer(UpperCAmelCase	, stride=UpperCAmelCase	, name="layer.1"  )
            A_	     =							TFResNetConvLayer(UpperCAmelCase	, kernel_size=1	, activation=UpperCAmelCase	, name="layer.2"  )
            A_	     =							(
                TFResNetShortCut(UpperCAmelCase	, stride=UpperCAmelCase	, name="shortcut"  )
                if should_apply_shortcut
                else tf.keras.layers.Activation("linear"	, name="shortcut"  )
            )
            A_	     =							ACTaFN[activation]







      def 		__A  (      self       :							str	, UpperCAmelCase       :							tf.Tensor	, UpperCAmelCase       :							bool = False  ):
            A_	     =							hidden_state
            A_	     =							self.conva(UpperCAmelCase	, training=UpperCAmelCase  )
            A_	     =							self.conva(UpperCAmelCase	, training=UpperCAmelCase  )
            A_	     =							self.conva(UpperCAmelCase	, training=UpperCAmelCase  )
            A_	     =							self.shortcut(UpperCAmelCase	, training=UpperCAmelCase  )
            hidden_state += residual
            A_	     =							self.activation(UpperCAmelCase  )
            return hidden_state




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




      """simple docstring"""

      def __init__(      self       :							str	, UpperCAmelCase       :							ResNetConfig	, UpperCAmelCase       :							int	, UpperCAmelCase       :							int	, UpperCAmelCase       :							int = 2	, UpperCAmelCase       :							int = 2	, **UpperCAmelCase       :							str  ):
            super().__init__(**UpperCAmelCase  )

            A_	     =							TFResNetBottleNeckLayer if config.layer_type == "bottleneck" else TFResNetBasicLayer

            A_	     =							[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  )
            ]
            A_	     =							layers







      def 		__A  (      self       :							Optional[Any]	, UpperCAmelCase       :							tf.Tensor	, UpperCAmelCase       :							bool = False  ):
            for layer in self.stage_layers:
                  A_	     =							layer(UpperCAmelCase	, training=UpperCAmelCase  )
            return hidden_state




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




      """simple docstring"""

      def __init__(      self       :							List[Any]	, UpperCAmelCase       :							ResNetConfig	, **UpperCAmelCase       :							Union[str, Any]  ):
            super().__init__(**UpperCAmelCase  )
            # based on `downsample_in_first_stage` the first layer of the first stage may or may not downsample the input
            A_	     =							[
                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 		__A  (      self       :							Tuple	, UpperCAmelCase       :							tf.Tensor	, UpperCAmelCase       :							bool = False	, UpperCAmelCase       :							bool = True	, UpperCAmelCase       :							bool = False	, ):
            A_	     =							() if output_hidden_states else None

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

                  A_	     =							stage_module(UpperCAmelCase	, training=UpperCAmelCase  )

            if output_hidden_states:
                  A_	     =							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      _a				( snake_case_							):




      """simple docstring"""

      _lowerCamelCase					: Tuple					=					ResNetConfig
      _lowerCamelCase					: Optional[Any]					=					'resnet'
      _lowerCamelCase					: str					=					'pixel_values'





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




__a						:Any            = 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						:List[Any]            = R'\n    Args:\n        pixel_values (`tf.Tensor` of shape `(batch_size, num_channels, height, width)`):\n            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See\n            [`ConvNextImageProcessor.__call__`] for details.\n\n        output_hidden_states (`bool`, *optional*):\n            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for\n            more detail.\n        return_dict (`bool`, *optional*):\n            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.\n'

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




      """simple docstring"""

      _lowerCamelCase					: List[str]					=					ResNetConfig





      def __init__(      self       :							List[Any]	, UpperCAmelCase       :							ResNetConfig	, **UpperCAmelCase       :							int  ):
            super().__init__(**UpperCAmelCase  )
            A_	     =							config
            A_	     =							TFResNetEmbeddings(UpperCAmelCase	, name="embedder"  )
            A_	     =							TFResNetEncoder(UpperCAmelCase	, name="encoder"  )
            A_	     =							tf.keras.layers.GlobalAveragePoolingaD(keepdims=UpperCAmelCase  )







      @unpack_inputs
      def 		__A  (      self       :							int	, UpperCAmelCase       :							tf.Tensor	, UpperCAmelCase       :							Optional[bool] = None	, UpperCAmelCase       :							Optional[bool] = None	, UpperCAmelCase       :							bool = False	, ):
            A_	     =							(
                output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
            )
            A_	     =							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)
            A_	     =							tf.transpose(UpperCAmelCase	, perm=[0, 2, 3, 1]  )
            A_	     =							self.embedder(UpperCAmelCase	, training=UpperCAmelCase  )

            A_	     =							self.encoder(
                UpperCAmelCase	, output_hidden_states=UpperCAmelCase	, return_dict=UpperCAmelCase	, training=UpperCAmelCase  )

            A_	     =							encoder_outputs[0]

            A_	     =							self.pooler(UpperCAmelCase  )

            # Transpose all the outputs to the NCHW format
            # (batch_size, height, width, num_channels) -> (batch_size, num_channels, height, width)
            A_	     =							tf.transpose(UpperCAmelCase	, (0, 3, 1, 2)  )
            A_	     =							tf.transpose(UpperCAmelCase	, (0, 3, 1, 2)  )
            A_	     =							()
            for hidden_state in encoder_outputs[1:]:
                  A_	     =							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

            A_	     =							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.'    ,							snake_case_    ,							)
class      _a				( snake_case_							):




      """simple docstring"""

      def __init__(      self       :							Any	, UpperCAmelCase       :							ResNetConfig	, **UpperCAmelCase       :							Any  ):
            super().__init__(UpperCAmelCase	, **UpperCAmelCase  )
            A_	     =							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 		__A  (      self       :							Tuple	, UpperCAmelCase       :							tf.Tensor	, UpperCAmelCase       :							Optional[bool] = None	, UpperCAmelCase       :							Optional[bool] = None	, UpperCAmelCase       :							bool = False	, ):
            A_	     =							(
                output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
            )
            A_	     =							return_dict if return_dict is not None else self.config.use_return_dict

            A_	     =							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    '    ,							snake_case_    ,							)
class      _a				( snake_case_    ,							snake_case_							):




      """simple docstring"""

      def __init__(      self       :							List[str]	, UpperCAmelCase       :							ResNetConfig	, **UpperCAmelCase       :							str  ):
            super().__init__(UpperCAmelCase	, **UpperCAmelCase  )
            A_	     =							config.num_labels
            A_	     =							TFResNetMainLayer(UpperCAmelCase	, name="resnet"  )
            # classification head
            A_	     =							(
                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 		__A  (      self       :							Optional[int]	, UpperCAmelCase       :							tf.Tensor  ):
            A_	     =							tf.keras.layers.Flatten()(UpperCAmelCase  )
            A_	     =							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 		__A  (      self       :							Optional[int]	, UpperCAmelCase       :							tf.Tensor = None	, UpperCAmelCase       :							tf.Tensor = None	, UpperCAmelCase       :							bool = None	, UpperCAmelCase       :							bool = None	, UpperCAmelCase       :							bool = False	, ):
            A_	     =							return_dict if return_dict is not None else self.config.use_return_dict

            A_	     =							self.resnet(
                UpperCAmelCase	, output_hidden_states=UpperCAmelCase	, return_dict=UpperCAmelCase	, training=UpperCAmelCase  )

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

            A_	     =							self.classifier(UpperCAmelCase  )

            A_	     =							None if labels is None else self.hf_compute_loss(UpperCAmelCase	, UpperCAmelCase  )

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

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


def 			__snake_case	(   __UpperCamelCase  :   str						):



      """simple docstring"""

      A_	     =							len(__UpperCamelCase						)
      A_	     =							[0] * length
      A_	     =							[[False for i in range(__UpperCamelCase						)] for j in range(__UpperCamelCase						)]
      for i, c in enumerate(__UpperCamelCase						):
            A_	     =							i
            for j in range(i + 1						):
                  if c == string[j] and (i - j < 2 or is_palindromic[j + 1][i - 1]):
                        A_	     =							True
                        A_	     =							min(__UpperCamelCase							,0 if j == 0 else (cut[j - 1] + 1)						)
            A_	     =							mincut
      return cut[length - 1]


if __name__ == "__main__":
      __a						:Union[str, Any]            = input('Enter the string: ').strip()
      __a						:Tuple            = find_minimum_partitions(s)
      print(F"Minimum number of partitions required for the '{s}' is {ans}")