






"""simple docstring"""






def 						_UpperCamelCase			(  A			):
   UpperCamelCase_     =word.upper()
   UpperCamelCase_     =0
   UpperCamelCase_     ={}
   UpperCamelCase_     =[]

   for letter in word:
      if letter not in letter_nums:
         UpperCamelCase_     =str(A			)
         next_num += 1
      word_pattern.append(letter_nums[letter]			)
   return ".".join(A			)


if __name__ == "__main__":
    import pprint
    import time

    A_			  =    time.time()
    with open("dictionary.txt") as in_file:
        A_			  =    in_file.read().splitlines()

    A_			  =    {}
    for word in word_list:
        A_			  =    get_word_pattern(word)
        if pattern in all_patterns:
            all_patterns[pattern].append(word)
        else:
            A_			  =    [word]

    with open("word_patterns.txt", "w") as out_file:
        out_file.write(pprint.pformat(all_patterns))

    A_			  =    round(time.time() - start_time, 2)
    print(f'''Done!  {len(all_patterns):,} word patterns found in {total_time} seconds.''')
    # Done!  9,581 word patterns found in 0.58 seconds.








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


A_			  =    logging.get_logger(__name__)

# General docstring
A_			  =    "ResNetConfig"

# Base docstring
A_			  =    "microsoft/resnet-50"
A_			  =    [1, 2048, 7, 7]

# Image classification docstring
A_			  =    "microsoft/resnet-50"
A_			  =    "tiger cat"

A_			  =    [
    "microsoft/resnet-50",
    # See all resnet models at https://huggingface.co/models?filter=resnet
]
class 						__lowerCAmelCase   (			tf.keras.layers.Layer       ):







  '''simple docstring'''


  def __init__(      self:		Dict				,			UpperCamelCase_:		int				,			UpperCamelCase_:		int = 3				,			UpperCamelCase_:		int = 1				,			UpperCamelCase_:		str = "relu"				,			**UpperCamelCase_:		List[Any]					):
     super().__init__(**UpperCamelCase_					)
     UpperCamelCase_     =kernel_size // 2
     UpperCamelCase_     =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
     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 					UpperCamelCase__   (      self:		List[str]				,			UpperCamelCase_:		tf.Tensor					):
     # Pad to match that done in the PyTorch Conv2D model
     UpperCamelCase_     =UpperCamelCase_     =(self.pad_value, self.pad_value)
     UpperCamelCase_     =tf.pad(UpperCamelCase_				,			[(0, 0), height_pad, width_pad, (0, 0)]					)
     UpperCamelCase_     =self.conv(UpperCamelCase_					)
     return hidden_state





  def 					UpperCamelCase__   (      self:		Optional[int]				,			UpperCamelCase_:		tf.Tensor				,			UpperCamelCase_:		bool = False					):
     UpperCamelCase_     =self.convolution(UpperCamelCase_					)
     UpperCamelCase_     =self.normalization(UpperCamelCase_				,			training=UpperCamelCase_					)
     UpperCamelCase_     =self.activation(UpperCamelCase_					)
     return hidden_state




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







  '''simple docstring'''


  def __init__(      self:		Optional[int]				,			UpperCamelCase_:		ResNetConfig				,			**UpperCamelCase_:		Dict					):
     super().__init__(**UpperCamelCase_					)
     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 					UpperCamelCase__   (      self:		Dict				,			UpperCamelCase_:		tf.Tensor				,			UpperCamelCase_:		bool = False					):
     UpperCamelCase_    ,							UpperCamelCase_    ,							UpperCamelCase_    ,							UpperCamelCase_     =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."					)
     UpperCamelCase_     =pixel_values
     UpperCamelCase_     =self.embedder(UpperCamelCase_					)
     UpperCamelCase_     =tf.pad(UpperCamelCase_				,			[[0, 0], [1, 1], [1, 1], [0, 0]]					)
     UpperCamelCase_     =self.pooler(UpperCamelCase_					)
     return hidden_state




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







  '''simple docstring'''


  def __init__(      self:		Optional[int]				,			UpperCamelCase_:		int				,			UpperCamelCase_:		int = 2				,			**UpperCamelCase_:		Tuple					):
     super().__init__(**UpperCamelCase_					)
     UpperCamelCase_     =tf.keras.layers.ConvaD(
         UpperCamelCase_				,			kernel_size=1				,			strides=UpperCamelCase_				,			use_bias=UpperCamelCase_				,			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 					UpperCamelCase__   (      self:		Optional[int]				,			UpperCamelCase_:		tf.Tensor				,			UpperCamelCase_:		bool = False					):
     UpperCamelCase_     =x
     UpperCamelCase_     =self.convolution(UpperCamelCase_					)
     UpperCamelCase_     =self.normalization(UpperCamelCase_				,			training=UpperCamelCase_					)
     return hidden_state




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







  '''simple docstring'''


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





  def 					UpperCamelCase__   (      self:		Optional[Any]				,			UpperCamelCase_:		tf.Tensor				,			UpperCamelCase_:		bool = False					):
     UpperCamelCase_     =hidden_state
     UpperCamelCase_     =self.conva(UpperCamelCase_				,			training=UpperCamelCase_					)
     UpperCamelCase_     =self.conva(UpperCamelCase_				,			training=UpperCamelCase_					)
     UpperCamelCase_     =self.shortcut(UpperCamelCase_				,			training=UpperCamelCase_					)
     hidden_state += residual
     UpperCamelCase_     =self.activation(UpperCamelCase_					)
     return hidden_state




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







  '''simple docstring'''


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





  def 					UpperCamelCase__   (      self:		Optional[Any]				,			UpperCamelCase_:		tf.Tensor				,			UpperCamelCase_:		bool = False					):
     UpperCamelCase_     =hidden_state
     UpperCamelCase_     =self.conva(UpperCamelCase_				,			training=UpperCamelCase_					)
     UpperCamelCase_     =self.conva(UpperCamelCase_				,			training=UpperCamelCase_					)
     UpperCamelCase_     =self.conva(UpperCamelCase_				,			training=UpperCamelCase_					)
     UpperCamelCase_     =self.shortcut(UpperCamelCase_				,			training=UpperCamelCase_					)
     hidden_state += residual
     UpperCamelCase_     =self.activation(UpperCamelCase_					)
     return hidden_state




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







  '''simple docstring'''


  def __init__(      self:		Optional[int]				,			UpperCamelCase_:		ResNetConfig				,			UpperCamelCase_:		int				,			UpperCamelCase_:		int				,			UpperCamelCase_:		int = 2				,			UpperCamelCase_:		int = 2				,			**UpperCamelCase_:		Optional[Any]					):
     super().__init__(**UpperCamelCase_					)

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

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





  def 					UpperCamelCase__   (      self:		str				,			UpperCamelCase_:		tf.Tensor				,			UpperCamelCase_:		bool = False					):
     for layer in self.stage_layers:
        UpperCamelCase_     =layer(UpperCamelCase_				,			training=UpperCamelCase_					)
     return hidden_state




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







  '''simple docstring'''


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

     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=UpperCamelCase_				,			hidden_states=UpperCamelCase_					)




class 						__lowerCAmelCase   (			UpperCAmelCase       ):







  '''simple docstring'''


  __lowerCamelCase       :    Any     	=			ResNetConfig
  __lowerCamelCase       :    Dict     	=			"resnet"
  __lowerCamelCase       :    str     	=			"pixel_values"
  @property
  def 					UpperCamelCase__   (      self:		List[str]					):
     return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 224, 224)				,			dtype=tf.floataa					)}




A_			  =    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_			  =    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 						__lowerCAmelCase   (			tf.keras.layers.Layer       ):







  '''simple docstring'''


  __lowerCamelCase       :    str     	=			ResNetConfig
  def __init__(      self:		str				,			UpperCamelCase_:		ResNetConfig				,			**UpperCamelCase_:		Any					):
     super().__init__(**UpperCamelCase_					)
     UpperCamelCase_     =config
     UpperCamelCase_     =TFResNetEmbeddings(UpperCamelCase_				,			name="embedder"					)
     UpperCamelCase_     =TFResNetEncoder(UpperCamelCase_				,			name="encoder"					)
     UpperCamelCase_     =tf.keras.layers.GlobalAveragePoolingaD(keepdims=UpperCamelCase_					)





  @unpack_inputs
  def 					UpperCamelCase__   (      self:		Any				,			UpperCamelCase_:		tf.Tensor				,			UpperCamelCase_:		Optional[bool] = None				,			UpperCamelCase_:		Optional[bool] = None				,			UpperCamelCase_:		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(UpperCamelCase_				,			perm=[0, 2, 3, 1]					)
     UpperCamelCase_     =self.embedder(UpperCamelCase_				,			training=UpperCamelCase_					)

     UpperCamelCase_     =self.encoder(
         UpperCamelCase_				,			output_hidden_states=UpperCamelCase_				,			return_dict=UpperCamelCase_				,			training=UpperCamelCase_					)

     UpperCamelCase_     =encoder_outputs[0]

     UpperCamelCase_     =self.pooler(UpperCamelCase_					)

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

     UpperCamelCase_     =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."       ,   UpperCAmelCase       ,   )
class 						__lowerCAmelCase   (			UpperCAmelCase       ):







  '''simple docstring'''


  def __init__(      self:		Tuple				,			UpperCamelCase_:		ResNetConfig				,			**UpperCamelCase_:		int					):
     super().__init__(UpperCamelCase_				,			**UpperCamelCase_					)
     UpperCamelCase_     =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 					UpperCamelCase__   (      self:		List[str]				,			UpperCamelCase_:		tf.Tensor				,			UpperCamelCase_:		Optional[bool] = None				,			UpperCamelCase_:		Optional[bool] = None				,			UpperCamelCase_:		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=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    "       ,   UpperCAmelCase       ,   )
class 						__lowerCAmelCase   (			UpperCAmelCase       ,   UpperCAmelCase       ):







  '''simple docstring'''


  def __init__(      self:		List[Any]				,			UpperCamelCase_:		ResNetConfig				,			**UpperCamelCase_:		List[str]					):
     super().__init__(UpperCamelCase_				,			**UpperCamelCase_					)
     UpperCamelCase_     =config.num_labels
     UpperCamelCase_     =TFResNetMainLayer(UpperCamelCase_				,			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 					UpperCamelCase__   (      self:		List[str]				,			UpperCamelCase_:		tf.Tensor					):
     UpperCamelCase_     =tf.keras.layers.Flatten()(UpperCamelCase_					)
     UpperCamelCase_     =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 					UpperCamelCase__   (      self:		Any				,			UpperCamelCase_:		tf.Tensor = None				,			UpperCamelCase_:		tf.Tensor = None				,			UpperCamelCase_:		bool = None				,			UpperCamelCase_:		bool = None				,			UpperCamelCase_:		bool = False				,			):
     UpperCamelCase_     =return_dict if return_dict is not None else self.config.use_return_dict

     UpperCamelCase_     =self.resnet(
         UpperCamelCase_				,			output_hidden_states=UpperCamelCase_				,			return_dict=UpperCamelCase_				,			training=UpperCamelCase_					)

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

     UpperCamelCase_     =self.classifier(UpperCamelCase_					)

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

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

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