




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    				=		logging.get_logger(__name__)

# General docstring
_lowerCamelCase    				=		'ResNetConfig'

# Base docstring
_lowerCamelCase    				=		'microsoft/resnet-50'
_lowerCamelCase    				=		[1, 20_48, 7, 7]

# Image classification docstring
_lowerCamelCase    				=		'microsoft/resnet-50'
_lowerCamelCase    				=		'tiger cat'

_lowerCamelCase    				=		[
    '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     :    Tuple      ,					__snake_case     :    int      ,					__snake_case     :    int = 3      ,					__snake_case     :    int = 1      ,					__snake_case     :    str = "relu"      ,					**__snake_case     :    Any       ):
         super().__init__(**__snake_case       )
         UpperCAmelCase_											=  kernel_size // 2
         UpperCAmelCase_											=  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
         UpperCAmelCase_											=  tf.keras.layers.BatchNormalization(epsilon=1E-5      ,					momentum=0.9      ,					name='''normalization'''       )
         UpperCAmelCase_											=  ACTaFN[activation] if activation is not None else tf.keras.layers.Activation('''linear'''       )
     def 						lowerCamelCase_     (			self     :    Optional[Any]      ,					__snake_case     :    tf.Tensor       ):
         # Pad to match that done in the PyTorch Conv2D model
         UpperCAmelCase_											=  UpperCAmelCase_											=  (self.pad_value, self.pad_value)
         UpperCAmelCase_											=  tf.pad(__snake_case      ,					[(0, 0), height_pad, width_pad, (0, 0)]       )
         UpperCAmelCase_											=  self.conv(__snake_case       )
         return hidden_state




     def 						lowerCamelCase_     (			self     :    Any      ,					__snake_case     :    tf.Tensor      ,					__snake_case     :    bool = False       ):
         UpperCAmelCase_											=  self.convolution(__snake_case       )
         UpperCAmelCase_											=  self.normalization(__snake_case      ,					training=__snake_case       )
         UpperCAmelCase_											=  self.activation(__snake_case       )
         return hidden_state



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

     '''simple docstring'''





     def __init__(			self     :    Dict      ,					__snake_case     :    ResNetConfig      ,					**__snake_case     :    Optional[Any]       ):
         super().__init__(**__snake_case       )
         UpperCAmelCase_											=  TFResNetConvLayer(
             config.embedding_size      ,					kernel_size=7      ,					stride=2      ,					activation=config.hidden_act      ,					name='''embedder'''      ,					)
         UpperCAmelCase_											=  tf.keras.layers.MaxPoolaD(pool_size=3      ,					strides=2      ,					padding='''valid'''      ,					name='''pooler'''       )
         UpperCAmelCase_											=  config.num_channels




     def 						lowerCamelCase_     (			self     :    List[Any]      ,					__snake_case     :    tf.Tensor      ,					__snake_case     :    bool = False       ):
         UpperCAmelCase_				,							UpperCAmelCase_				,							UpperCAmelCase_				,							UpperCAmelCase_											=  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.'''       )
         UpperCAmelCase_											=  pixel_values
         UpperCAmelCase_											=  self.embedder(__snake_case       )
         UpperCAmelCase_											=  tf.pad(__snake_case      ,					[[0, 0], [1, 1], [1, 1], [0, 0]]       )
         UpperCAmelCase_											=  self.pooler(__snake_case       )
         return hidden_state



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

     '''simple docstring'''





     def __init__(			self     :    Union[str, Any]      ,					__snake_case     :    int      ,					__snake_case     :    int = 2      ,					**__snake_case     :    List[str]       ):
         super().__init__(**__snake_case       )
         UpperCAmelCase_											=  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
         UpperCAmelCase_											=  tf.keras.layers.BatchNormalization(epsilon=1E-5      ,					momentum=0.9      ,					name='''normalization'''       )




     def 						lowerCamelCase_     (			self     :    Optional[Any]      ,					__snake_case     :    tf.Tensor      ,					__snake_case     :    bool = False       ):
         UpperCAmelCase_											=  x
         UpperCAmelCase_											=  self.convolution(__snake_case       )
         UpperCAmelCase_											=  self.normalization(__snake_case      ,					training=__snake_case       )
         return hidden_state



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

     '''simple docstring'''





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




     def 						lowerCamelCase_     (			self     :    List[Any]      ,					__snake_case     :    tf.Tensor      ,					__snake_case     :    bool = False       ):
         UpperCAmelCase_											=  hidden_state
         UpperCAmelCase_											=  self.conva(__snake_case      ,					training=__snake_case       )
         UpperCAmelCase_											=  self.conva(__snake_case      ,					training=__snake_case       )
         UpperCAmelCase_											=  self.shortcut(__snake_case      ,					training=__snake_case       )
         hidden_state += residual
         UpperCAmelCase_											=  self.activation(__snake_case       )
         return hidden_state



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

     '''simple docstring'''





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




     def 						lowerCamelCase_     (			self     :    str      ,					__snake_case     :    tf.Tensor      ,					__snake_case     :    bool = False       ):
         UpperCAmelCase_											=  hidden_state
         UpperCAmelCase_											=  self.conva(__snake_case      ,					training=__snake_case       )
         UpperCAmelCase_											=  self.conva(__snake_case      ,					training=__snake_case       )
         UpperCAmelCase_											=  self.conva(__snake_case      ,					training=__snake_case       )
         UpperCAmelCase_											=  self.shortcut(__snake_case      ,					training=__snake_case       )
         hidden_state += residual
         UpperCAmelCase_											=  self.activation(__snake_case       )
         return hidden_state



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

     '''simple docstring'''





     def __init__(			self     :    Union[str, Any]      ,					__snake_case     :    ResNetConfig      ,					__snake_case     :    int      ,					__snake_case     :    int      ,					__snake_case     :    int = 2      ,					__snake_case     :    int = 2      ,					**__snake_case     :    Any       ):
         super().__init__(**__snake_case       )

         UpperCAmelCase_											=  TFResNetBottleNeckLayer if config.layer_type == '''bottleneck''' else TFResNetBasicLayer

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




     def 						lowerCamelCase_     (			self     :    List[str]      ,					__snake_case     :    tf.Tensor      ,					__snake_case     :    bool = False       ):
         for layer in self.stage_layers:
             UpperCAmelCase_											=  layer(__snake_case      ,					training=__snake_case       )
         return hidden_state



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

     '''simple docstring'''





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

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

             UpperCAmelCase_											=  stage_module(__snake_case      ,					training=__snake_case       )

         if output_hidden_states:
             UpperCAmelCase_											=  hidden_states + (hidden_state,)

         if not return_dict:
             return tuple(v for v in [hidden_state, hidden_states] if v is not None       )

         return TFBaseModelOutputWithNoAttention(last_hidden_state=__snake_case      ,					hidden_states=__snake_case       )



class     a  (     _A    ):

     '''simple docstring'''





     lowerCAmelCase       : Union[str, Any]     	=						ResNetConfig
     lowerCAmelCase       : Tuple     	=						'resnet'
     lowerCAmelCase       : Tuple     	=						'pixel_values'
     @property
     def 						lowerCamelCase_     (			self     :    Optional[int]       ):
         return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 2_24, 2_24)      ,					dtype=tf.floataa       )}


_lowerCamelCase    				=		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    				=		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[Any]     	=						ResNetConfig
     def __init__(			self     :    int      ,					__snake_case     :    ResNetConfig      ,					**__snake_case     :    Union[str, Any]       ):
         super().__init__(**__snake_case       )
         UpperCAmelCase_											=  config
         UpperCAmelCase_											=  TFResNetEmbeddings(__snake_case      ,					name='''embedder'''       )
         UpperCAmelCase_											=  TFResNetEncoder(__snake_case      ,					name='''encoder'''       )
         UpperCAmelCase_											=  tf.keras.layers.GlobalAveragePoolingaD(keepdims=__snake_case       )




     @unpack_inputs
     def 						lowerCamelCase_     (			self     :    List[str]      ,					__snake_case     :    tf.Tensor      ,					__snake_case     :    Optional[bool] = None      ,					__snake_case     :    Optional[bool] = None      ,					__snake_case     :    bool = False      ,					):
         UpperCAmelCase_											=  (
             output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
         )
         UpperCAmelCase_											=  return_dict if return_dict is not None else self.config.use_return_dict

         # TF 2.0 image layers can't use NCHW format when running on CPU.
         # We transpose to NHWC format and then transpose back after the full forward pass.
         # (batch_size, num_channels, height, width) -> (batch_size, height, width, num_channels)
         UpperCAmelCase_											=  tf.transpose(__snake_case      ,					perm=[0, 2, 3, 1]       )
         UpperCAmelCase_											=  self.embedder(__snake_case      ,					training=__snake_case       )

         UpperCAmelCase_											=  self.encoder(
             __snake_case      ,					output_hidden_states=__snake_case      ,					return_dict=__snake_case      ,					training=__snake_case       )

         UpperCAmelCase_											=  encoder_outputs[0]

         UpperCAmelCase_											=  self.pooler(__snake_case       )

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

         UpperCAmelCase_											=  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.'			,     _A			,     )
class     a  (     _A    ):

     '''simple docstring'''





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

         UpperCAmelCase_											=  self.resnet(
             pixel_values=__snake_case      ,					output_hidden_states=__snake_case      ,					return_dict=__snake_case      ,					training=__snake_case      ,					)
         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    '			,     _A			,     )
class     a  (     _A			,     _A    ):

     '''simple docstring'''





     def __init__(			self     :    List[Any]      ,					__snake_case     :    ResNetConfig      ,					**__snake_case     :    List[Any]       ):
         super().__init__(__snake_case      ,					**__snake_case       )
         UpperCAmelCase_											=  config.num_labels
         UpperCAmelCase_											=  TFResNetMainLayer(__snake_case      ,					name='''resnet'''       )
         # classification head
         UpperCAmelCase_											=  (
             tf.keras.layers.Dense(config.num_labels      ,					name='''classifier.1'''       )
             if config.num_labels > 0
             else tf.keras.layers.Activation('''linear'''      ,					name='''classifier.1'''       )
         )
     def 						lowerCamelCase_     (			self     :    Optional[int]      ,					__snake_case     :    tf.Tensor       ):
         UpperCAmelCase_											=  tf.keras.layers.Flatten()(__snake_case       )
         UpperCAmelCase_											=  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     :    str      ,					__snake_case     :    tf.Tensor = None      ,					__snake_case     :    tf.Tensor = None      ,					__snake_case     :    bool = None      ,					__snake_case     :    bool = None      ,					__snake_case     :    bool = False      ,					):
         UpperCAmelCase_											=  return_dict if return_dict is not None else self.config.use_return_dict

         UpperCAmelCase_											=  self.resnet(
             __snake_case      ,					output_hidden_states=__snake_case      ,					return_dict=__snake_case      ,					training=__snake_case       )

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

         UpperCAmelCase_											=  self.classifier(__snake_case       )

         UpperCAmelCase_											=  None if labels is None else self.hf_compute_loss(__snake_case      ,					__snake_case       )

         if not return_dict:
             UpperCAmelCase_											=  (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       )











import itertools




def       SCREAMING_SNAKE_CASE			( __UpperCamelCase    :		Tuple   )						->							List[Any]:
    return (
        int(''''''.join(combination[0:2]   )   ) * int(''''''.join(combination[2:5]   )   )
        == int(''''''.join(combination[5:9]   )   )
    ) or (
        int(''''''.join(combination[0]   )   ) * int(''''''.join(combination[1:5]   )   )
        == int(''''''.join(combination[5:9]   )   )
    )




def       SCREAMING_SNAKE_CASE			( )						->							Optional[Any]:
    return sum(
        {
            int(''''''.join(pandigital[5:9]   )   )
            for pandigital in itertools.permutations('''123456789'''   )
            if is_combination_valid(__UpperCamelCase   )
        }   )


if __name__ == "__main__":
 print(solution())





