





"""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


lowerCamelCase_	:		str         =   logging.get_logger(__name__)

# General docstring
lowerCamelCase_	:		str         =   'ResNetConfig'

# Base docstring
lowerCamelCase_	:		Optional[Any]         =   'microsoft/resnet-50'
lowerCamelCase_	:		Dict         =   [1, 20_48, 7, 7]

# Image classification docstring
lowerCamelCase_	:		List[str]         =   'microsoft/resnet-50'
lowerCamelCase_	:		Union[str, Any]         =   'tiger cat'

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

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



      '''simple docstring'''

      def __init__(	self   , snake_case_   , snake_case_ = 3   , snake_case_ = 1   , snake_case_ = "relu"   , **snake_case_    ):

        """simple docstring"""

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

      def    lowerCamelCase_     (	self   , snake_case_    ):

        """simple docstring"""

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

      def    lowerCamelCase_     (	self   , snake_case_   , snake_case_ = False    ):

        """simple docstring"""

        A_    :			List[str]									=    self.convolution(snake_case_    )
        A_    :			Optional[Any]									=    self.normalization(snake_case_   , training=snake_case_    )
        A_    :			Dict									=    self.activation(snake_case_    )
        return hidden_state


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



      '''simple docstring'''

      def __init__(	self   , snake_case_   , **snake_case_    ):

        """simple docstring"""

        super().__init__(**snake_case_    )
        A_    :			Optional[int]									=    TFResNetConvLayer(
            config.embedding_size   , kernel_size=7   , stride=2   , activation=config.hidden_act   , name='embedder'   , )
        A_    :			Optional[int]									=    tf.keras.layers.MaxPoolaD(pool_size=3   , strides=2   , padding='valid'   , name='pooler'    )
        A_    :			Tuple									=    config.num_channels

      def    lowerCamelCase_     (	self   , snake_case_   , snake_case_ = False    ):

        """simple docstring"""

        A_		,			A_		,			A_		,			A_    :			Dict									=    shape_list(snake_case_    )
        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_    :			str									=    pixel_values
        A_    :			Union[str, Any]									=    self.embedder(snake_case_    )
        A_    :			int									=    tf.pad(snake_case_   , [[0, 0], [1, 1], [1, 1], [0, 0]]    )
        A_    :			str									=    self.pooler(snake_case_    )
        return hidden_state


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



      '''simple docstring'''

      def __init__(	self   , snake_case_   , snake_case_ = 2   , **snake_case_    ):

        """simple docstring"""

        super().__init__(**snake_case_    )
        A_    :			Optional[Any]									=    tf.keras.layers.ConvaD(
            snake_case_   , kernel_size=1   , strides=snake_case_   , use_bias=snake_case_   , name='convolution'    )
        # Use same default momentum and epsilon as PyTorch equivalent
        A_    :			Optional[Any]									=    tf.keras.layers.BatchNormalization(epsilon=1E-5   , momentum=0.9   , name='normalization'    )

      def    lowerCamelCase_     (	self   , snake_case_   , snake_case_ = False    ):

        """simple docstring"""

        A_    :			List[Any]									=    x
        A_    :			Any									=    self.convolution(snake_case_    )
        A_    :			Dict									=    self.normalization(snake_case_   , training=snake_case_    )
        return hidden_state


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



      '''simple docstring'''

      def __init__(	self   , snake_case_   , snake_case_   , snake_case_ = 1   , snake_case_ = "relu"   , **snake_case_    ):

        """simple docstring"""

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

      def    lowerCamelCase_     (	self   , snake_case_   , snake_case_ = False    ):

        """simple docstring"""

        A_    :			Optional[int]									=    hidden_state
        A_    :			str									=    self.conva(snake_case_   , training=snake_case_    )
        A_    :			List[str]									=    self.conva(snake_case_   , training=snake_case_    )
        A_    :			List[Any]									=    self.shortcut(snake_case_   , training=snake_case_    )
        hidden_state += residual
        A_    :			str									=    self.activation(snake_case_    )
        return hidden_state


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



      '''simple docstring'''

      def __init__(	self   , snake_case_   , snake_case_   , snake_case_ = 1   , snake_case_ = "relu"   , snake_case_ = 4   , **snake_case_   , ):

        """simple docstring"""

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

      def    lowerCamelCase_     (	self   , snake_case_   , snake_case_ = False    ):

        """simple docstring"""

        A_    :			List[str]									=    hidden_state
        A_    :			int									=    self.conva(snake_case_   , training=snake_case_    )
        A_    :			Dict									=    self.conva(snake_case_   , training=snake_case_    )
        A_    :			Optional[int]									=    self.conva(snake_case_   , training=snake_case_    )
        A_    :			str									=    self.shortcut(snake_case_   , training=snake_case_    )
        hidden_state += residual
        A_    :			Union[str, Any]									=    self.activation(snake_case_    )
        return hidden_state


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



      '''simple docstring'''

      def __init__(	self   , snake_case_   , snake_case_   , snake_case_   , snake_case_ = 2   , snake_case_ = 2   , **snake_case_    ):

        """simple docstring"""

        super().__init__(**snake_case_    )

        A_    :			str									=    TFResNetBottleNeckLayer if config.layer_type == 'bottleneck' else TFResNetBasicLayer

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

      def    lowerCamelCase_     (	self   , snake_case_   , snake_case_ = False    ):

        """simple docstring"""

        for layer in self.stage_layers:
          A_    :			List[Any]									=    layer(snake_case_   , training=snake_case_    )
        return hidden_state


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



      '''simple docstring'''

      def __init__(	self   , snake_case_   , **snake_case_    ):

        """simple docstring"""

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

      def    lowerCamelCase_     (	self   , snake_case_   , snake_case_ = False   , snake_case_ = True   , snake_case_ = False   , ):

        """simple docstring"""

        A_    :			Any									=    () if output_hidden_states else None

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

          A_    :			Any									=    stage_module(snake_case_   , training=snake_case_    )

        if output_hidden_states:
          A_    :			List[str]									=    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=snake_case_   , hidden_states=snake_case_    )


class 					_UpperCAmelCase    (  UpperCAmelCase__						):



      '''simple docstring'''
      lowercase_ :					Dict             =  ResNetConfig
      lowercase_ :					Dict             =  """resnet"""
      lowercase_ :					Union[str, Any]             =  """pixel_values"""

      @property
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

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


lowerCamelCase_	:		Tuple         =   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'


lowerCamelCase_	:		Tuple         =   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 					_UpperCAmelCase    (  tf.keras.layers.Layer						):



      '''simple docstring'''
      lowercase_ :					Dict             =  ResNetConfig

      def __init__(	self   , snake_case_   , **snake_case_    ):

        """simple docstring"""

        super().__init__(**snake_case_    )
        A_    :			Union[str, Any]									=    config
        A_    :			Optional[Any]									=    TFResNetEmbeddings(snake_case_   , name='embedder'    )
        A_    :			Any									=    TFResNetEncoder(snake_case_   , name='encoder'    )
        A_    :			List[str]									=    tf.keras.layers.GlobalAveragePoolingaD(keepdims=snake_case_    )

      @unpack_inputs
      def    lowerCamelCase_     (	self   , snake_case_   , snake_case_ = None   , snake_case_ = None   , snake_case_ = False   , ):

        """simple docstring"""

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

        A_    :			List[Any]									=    self.encoder(
            snake_case_   , output_hidden_states=snake_case_   , return_dict=snake_case_   , training=snake_case_    )

        A_    :			Optional[int]									=    encoder_outputs[0]

        A_    :			int									=    self.pooler(snake_case_    )

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

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

        A_    :			Dict									=    hidden_states if output_hidden_states else None

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


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



      '''simple docstring'''

      def __init__(	self   , snake_case_   , **snake_case_    ):

        """simple docstring"""

        super().__init__(snake_case_   , **snake_case_    )
        A_    :			Dict									=    TFResNetMainLayer(config=snake_case_   , name='resnet'    )

      @add_start_docstrings_to_model_forward(snake_case_    )
      @add_code_sample_docstrings(
          checkpoint=_CHECKPOINT_FOR_DOC   , output_type=snake_case_   , config_class=_CONFIG_FOR_DOC   , modality='vision'   , expected_output=_EXPECTED_OUTPUT_SHAPE   , )
      @unpack_inputs
      def    lowerCamelCase_     (	self   , snake_case_   , snake_case_ = None   , snake_case_ = None   , snake_case_ = False   , ):

        """simple docstring"""

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

        A_    :			Tuple									=    self.resnet(
            pixel_values=snake_case_   , output_hidden_states=snake_case_   , return_dict=snake_case_   , training=snake_case_   , )
        return resnet_outputs


@add_start_docstrings(
    """
    ResNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for
    ImageNet.
    """     ,  UpperCAmelCase__     ,  )
class 					_UpperCAmelCase    (  UpperCAmelCase__     ,  UpperCAmelCase__						):



      '''simple docstring'''

      def __init__(	self   , snake_case_   , **snake_case_    ):

        """simple docstring"""

        super().__init__(snake_case_   , **snake_case_    )
        A_    :			Any									=    config.num_labels
        A_    :			Tuple									=    TFResNetMainLayer(snake_case_   , name='resnet'    )
        # classification head
        A_    :			List[str]									=    (
            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    lowerCamelCase_     (	self   , snake_case_    ):

        """simple docstring"""

        A_    :			Tuple									=    tf.keras.layers.Flatten()(snake_case_    )
        A_    :			List[str]									=    self.classifier_layer(snake_case_    )
        return logits

      @add_start_docstrings_to_model_forward(snake_case_    )
      @add_code_sample_docstrings(
          checkpoint=_IMAGE_CLASS_CHECKPOINT   , output_type=snake_case_   , config_class=_CONFIG_FOR_DOC   , expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT   , )
      @unpack_inputs
      def    lowerCamelCase_     (	self   , snake_case_ = None   , snake_case_ = None   , snake_case_ = None   , snake_case_ = None   , snake_case_ = False   , ):

        """simple docstring"""

        A_    :			Optional[int]									=    return_dict if return_dict is not None else self.config.use_return_dict

        A_    :			Tuple									=    self.resnet(
            snake_case_   , output_hidden_states=snake_case_   , return_dict=snake_case_   , training=snake_case_    )

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

        A_    :			str									=    self.classifier(snake_case_    )

        A_    :			Tuple									=    None if labels is None else self.hf_compute_loss(snake_case_   , snake_case_    )

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

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

from math import sqrt


def  A__ (       __lowerCamelCase						):
   SCREAMING_SNAKE_CASE_	=      [1]
   for i in range(2,  int(sqrt(__lowerCamelCase						)						) + 1,  1						):
      if number % i == 0:
         values.append(__lowerCamelCase						)
         if int(number // i						) != i:
            values.append(int(number // i						)						)
   return sorted(__lowerCamelCase						)


def  A__ (       __lowerCamelCase						):
   return sum(factors(__lowerCamelCase						)						) > n


def  A__ (       __lowerCamelCase						):
   SCREAMING_SNAKE_CASE_	=      factors(__lowerCamelCase						)
   SCREAMING_SNAKE_CASE_	=      len(__lowerCamelCase						)
   SCREAMING_SNAKE_CASE_	=      [[0 for i in range(number + 1						)] for j in range(r + 1						)]
   for i in range(r + 1						):
      SCREAMING_SNAKE_CASE_	=      True

   for i in range(1,  number + 1						):
      SCREAMING_SNAKE_CASE_	=      False

   for i in range(1,  r + 1						):
      for j in range(1,  number + 1						):
         if j < values[i - 1]:
            SCREAMING_SNAKE_CASE_	=      subset[i - 1][j]
         else:
            SCREAMING_SNAKE_CASE_	=      subset[i - 1][j] or subset[i - 1][j - values[i - 1]]

   return subset[r][number] != 0


def  A__ (       __lowerCamelCase						):
   return abundant(__lowerCamelCase						) and not semi_perfect(__lowerCamelCase						)


if __name__ == "__main__":
   import doctest

   doctest.testmod(verbose=True)
   for number in (69, 70, 71):
      print(F"""{number} is {'' if weird(number) else 'not '}weird.""")


