



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

# General docstring
A_		:  Tuple										=  '''ResNetConfig'''

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

# Image classification docstring
A_		:  Any										=  '''microsoft/resnet-50'''
A_		:  int										=  '''tiger cat'''

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



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

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


    """simple docstring"""






    super().__init__(**_A				)
    a							=		kernel_size // 2
    a							=		tf.keras.layers.ConvaD(
        _A				, kernel_size=_A				, strides=_A				, padding="valid"				, use_bias=_A				, 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      :							Optional[int]				, __lowerCAmelCase      :							tf.Tensor				)							->					tf.Tensor:


    """simple docstring"""






    a							=		(self.pad_value, self.pad_value)
    a							=		tf.pad(_A				, [(0, 0), height_pad, width_pad, (0, 0)]				)
    a							=		self.conv(_A				)
    return hidden_state




   def 		A				(   self      :							List[Any]				, __lowerCAmelCase      :							tf.Tensor				, __lowerCAmelCase      :							bool = False				)							->					tf.Tensor:


    """simple docstring"""






    a							=		self.convolution(_A				)
    a							=		self.normalization(_A				, training=_A				)
    a							=		self.activation(_A				)
    return hidden_state



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

   def __init__(   self      :							List[Any]				, __lowerCAmelCase      :							ResNetConfig				, **__lowerCAmelCase      :							Dict				)							->					None:


    """simple docstring"""






    super().__init__(**_A				)
    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      :							Tuple				, __lowerCAmelCase      :							tf.Tensor				, __lowerCAmelCase      :							bool = False				)							->					tf.Tensor:


    """simple docstring"""






    a							=		shape_list(_A				)
    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(_A				)
    a							=		tf.pad(_A				, [[0, 0], [1, 1], [1, 1], [0, 0]]				)
    a							=		self.pooler(_A				)
    return hidden_state



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

   def __init__(   self      :							Optional[int]				, __lowerCAmelCase      :							int				, __lowerCAmelCase      :							int = 2				, **__lowerCAmelCase      :							Tuple				)							->					None:


    """simple docstring"""






    super().__init__(**_A				)
    a							=		tf.keras.layers.ConvaD(
        _A				, kernel_size=1				, strides=_A				, use_bias=_A				, 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      :							int				, __lowerCAmelCase      :							tf.Tensor				, __lowerCAmelCase      :							bool = False				)							->					tf.Tensor:


    """simple docstring"""






    a							=		x
    a							=		self.convolution(_A				)
    a							=		self.normalization(_A				, training=_A				)
    return hidden_state



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

   def __init__(   self      :							Tuple				, __lowerCAmelCase      :							int				, __lowerCAmelCase      :							int				, __lowerCAmelCase      :							int = 1				, __lowerCAmelCase      :							str = "relu"				, **__lowerCAmelCase      :							Any				)							->					None:


    """simple docstring"""






    super().__init__(**_A				)
    a							=		in_channels != out_channels or stride != 1
    a							=		TFResNetConvLayer(_A				, stride=_A				, name="layer.0"				)
    a							=		TFResNetConvLayer(_A				, activation=_A				, name="layer.1"				)
    a							=		(
        TFResNetShortCut(_A				, stride=_A				, name="shortcut"				)
        if should_apply_shortcut
        else tf.keras.layers.Activation("linear"				, name="shortcut"				)
    )
    a							=		ACTaFN[activation]




   def 		A				(   self      :							List[str]				, __lowerCAmelCase      :							tf.Tensor				, __lowerCAmelCase      :							bool = False				)							->					tf.Tensor:


    """simple docstring"""






    a							=		hidden_state
    a							=		self.conva(_A				, training=_A				)
    a							=		self.conva(_A				, training=_A				)
    a							=		self.shortcut(_A				, training=_A				)
    hidden_state += residual
    a							=		self.activation(_A				)
    return hidden_state



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

   def __init__(   self      :							Union[str, Any]				, __lowerCAmelCase      :							int				, __lowerCAmelCase      :							int				, __lowerCAmelCase      :							int = 1				, __lowerCAmelCase      :							str = "relu"				, __lowerCAmelCase      :							int = 4				, **__lowerCAmelCase      :							int				, )							->					None:


    """simple docstring"""






    super().__init__(**_A				)
    a							=		in_channels != out_channels or stride != 1
    a							=		out_channels // reduction
    a							=		TFResNetConvLayer(_A				, kernel_size=1				, name="layer.0"				)
    a							=		TFResNetConvLayer(_A				, stride=_A				, name="layer.1"				)
    a							=		TFResNetConvLayer(_A				, kernel_size=1				, activation=_A				, name="layer.2"				)
    a							=		(
        TFResNetShortCut(_A				, stride=_A				, name="shortcut"				)
        if should_apply_shortcut
        else tf.keras.layers.Activation("linear"				, name="shortcut"				)
    )
    a							=		ACTaFN[activation]




   def 		A				(   self      :							str				, __lowerCAmelCase      :							tf.Tensor				, __lowerCAmelCase      :							bool = False				)							->					tf.Tensor:


    """simple docstring"""






    a							=		hidden_state
    a							=		self.conva(_A				, training=_A				)
    a							=		self.conva(_A				, training=_A				)
    a							=		self.conva(_A				, training=_A				)
    a							=		self.shortcut(_A				, training=_A				)
    hidden_state += residual
    a							=		self.activation(_A				)
    return hidden_state



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

   def __init__(   self      :							Any				, __lowerCAmelCase      :							ResNetConfig				, __lowerCAmelCase      :							int				, __lowerCAmelCase      :							int				, __lowerCAmelCase      :							int = 2				, __lowerCAmelCase      :							int = 2				, **__lowerCAmelCase      :							List[Any]				)							->					None:


    """simple docstring"""






    super().__init__(**_A				)

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

    a							=		[layer(_A				, _A				, stride=_A				, activation=config.hidden_act				, name="layers.0"				)]
    layers += [
        layer(_A				, _A				, activation=config.hidden_act				, name=f"""layers.{i + 1}"""				)
        for i in range(depth - 1				)
    ]
    a							=		layers




   def 		A				(   self      :							List[str]				, __lowerCAmelCase      :							tf.Tensor				, __lowerCAmelCase      :							bool = False				)							->					tf.Tensor:


    """simple docstring"""






    for layer in self.stage_layers:
     a							=		layer(_A				, training=_A				)
    return hidden_state



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

   def __init__(   self      :							Tuple				, __lowerCAmelCase      :							ResNetConfig				, **__lowerCAmelCase      :							Optional[int]				)							->					None:


    """simple docstring"""






    super().__init__(**_A				)
    # based on `downsample_in_first_stage` the first layer of the first stage may or may not downsample the input
    a							=		[
        TFResNetStage(
            _A				, 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(_A				, _A				, _A				, depth=_A				, name=f"""stages.{i + 1}"""				)				)




   def 		A				(   self      :							Any				, __lowerCAmelCase      :							tf.Tensor				, __lowerCAmelCase      :							bool = False				, __lowerCAmelCase      :							bool = True				, __lowerCAmelCase      :							bool = False				, )							->					TFBaseModelOutputWithNoAttention:


    """simple docstring"""






    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(_A				, training=_A				)

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



class 		_lowercase		(							snake_case_						):
   _UpperCAmelCase  						=      ResNetConfig
   _UpperCAmelCase  						=      "resnet"
   _UpperCAmelCase  						=      "pixel_values"

   @property
   def 		A				(   self      :							List[str]				)							->					Optional[int]:


    """simple docstring"""






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

A_		:  List[Any]										=  r'''
    This model is a TensorFlow
    [tf.keras.layers.Layer](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Layer) sub-class. Use it as a
    regular TensorFlow Module and refer to the TensorFlow documentation for all matter related to general usage and
    behavior.

    Parameters:
        config ([`ResNetConfig`]): Model configuration class with all the parameters of the model.
            Initializing with a config file does not load the weights associated with the model, only the
            configuration. Check out the [`~TFPreTrainedModel.from_pretrained`] method to load the model weights.
'''


A_		:  List[Any]										=  r'''
    Args:
        pixel_values (`tf.Tensor` of shape `(batch_size, num_channels, height, width)`):
            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See
            [`ConvNextImageProcessor.__call__`] for details.

        output_hidden_states (`bool`, *optional*):
            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
            more detail.
        return_dict (`bool`, *optional*):
            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
'''



@keras_serializable
class 		_lowercase		(							tf.keras.layers.Layer						):
   _UpperCAmelCase  						=      ResNetConfig

   def __init__(   self      :							int				, __lowerCAmelCase      :							ResNetConfig				, **__lowerCAmelCase      :							int				)							->					None:


    """simple docstring"""






    super().__init__(**_A				)
    a							=		config
    a							=		TFResNetEmbeddings(_A				, name="embedder"				)
    a							=		TFResNetEncoder(_A				, name="encoder"				)
    a							=		tf.keras.layers.GlobalAveragePoolingaD(keepdims=_A				)




   @unpack_inputs
   def 		A				(   self      :							List[Any]				, __lowerCAmelCase      :							tf.Tensor				, __lowerCAmelCase      :							Optional[bool] = None				, __lowerCAmelCase      :							Optional[bool] = None				, __lowerCAmelCase      :							bool = False				, )							->					Union[Tuple[tf.Tensor], TFBaseModelOutputWithPoolingAndNoAttention]:


    """simple docstring"""






    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(_A				, perm=[0, 2, 3, 1]				)
    a							=		self.embedder(_A				, training=_A				)

    a							=		self.encoder(
        _A				, output_hidden_states=_A				, return_dict=_A				, training=_A				)

    a							=		encoder_outputs[0]

    a							=		self.pooler(_A				)

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



@add_start_docstrings(
    '''The bare ResNet model outputting raw features without any specific head on top.''', snake_case_, )
class 		_lowercase		(							snake_case_						):

   def __init__(   self      :							List[str]				, __lowerCAmelCase      :							ResNetConfig				, **__lowerCAmelCase      :							Optional[int]				)							->					None:


    """simple docstring"""






    super().__init__(_A				, **_A				)
    a							=		TFResNetMainLayer(config=_A				, name="resnet"				)




   @add_start_docstrings_to_model_forward(_A				)
   @add_code_sample_docstrings(
       checkpoint=_CHECKPOINT_FOR_DOC				, output_type=_A				, config_class=_CONFIG_FOR_DOC				, modality="vision"				, expected_output=_EXPECTED_OUTPUT_SHAPE				, )
   @unpack_inputs
   def 		A				(   self      :							List[Any]				, __lowerCAmelCase      :							tf.Tensor				, __lowerCAmelCase      :							Optional[bool] = None				, __lowerCAmelCase      :							Optional[bool] = None				, __lowerCAmelCase      :							bool = False				, )							->					Union[Tuple[tf.Tensor], TFBaseModelOutputWithPoolingAndNoAttention]:


    """simple docstring"""






    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=_A				, output_hidden_states=_A				, return_dict=_A				, training=_A				, )
    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 		_lowercase		(							snake_case_, snake_case_						):

   def __init__(   self      :							Optional[int]				, __lowerCAmelCase      :							ResNetConfig				, **__lowerCAmelCase      :							List[str]				)							->					None:


    """simple docstring"""






    super().__init__(_A				, **_A				)
    a							=		config.num_labels
    a							=		TFResNetMainLayer(_A				, 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      :							Tuple				, __lowerCAmelCase      :							tf.Tensor				)							->					tf.Tensor:


    """simple docstring"""






    a							=		tf.keras.layers.Flatten()(_A				)
    a							=		self.classifier_layer(_A				)
    return logits




   @add_start_docstrings_to_model_forward(_A				)
   @add_code_sample_docstrings(
       checkpoint=_IMAGE_CLASS_CHECKPOINT				, output_type=_A				, config_class=_CONFIG_FOR_DOC				, expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT				, )
   @unpack_inputs
   def 		A				(   self      :							Any				, __lowerCAmelCase      :							tf.Tensor = None				, __lowerCAmelCase      :							tf.Tensor = None				, __lowerCAmelCase      :							bool = None				, __lowerCAmelCase      :							bool = None				, __lowerCAmelCase      :							bool = False				, )							->					Union[Tuple[tf.Tensor], TFImageClassifierOutputWithNoAttention]:


    """simple docstring"""






    a							=		return_dict if return_dict is not None else self.config.use_return_dict

    a							=		self.resnet(
        _A				, output_hidden_states=_A				, return_dict=_A				, training=_A				)

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

    a							=		self.classifier(_A				)

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

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

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








def 				SCREAMING_SNAKE_CASE__    (     __a ,			__a ):
	if not root or root not in binary_tree_mirror_dictionary:
		return
	snake_case_    ,snake_case_		:      Tuple           =						binary_tree_mirror_dictionary[root][:2]
	snake_case_		:      List[str]           =						[right_child, left_child]
	binary_tree_mirror_dict(__a ,			__a )
	binary_tree_mirror_dict(__a ,			__a )


def 				SCREAMING_SNAKE_CASE__    (     __a ,			__a = 1 ):
	if not binary_tree:
		raise ValueError('binary tree cannot be empty' )
	if root not in binary_tree:
		snake_case_		:      Dict           =						f"""root {root} is not present in the binary_tree"""
		raise ValueError(__a )
	snake_case_		:      Any           =						dict(__a )
	binary_tree_mirror_dict(__a ,			__a )
	return binary_tree_mirror_dictionary


if __name__ == "__main__":
						_SCREAMING_SNAKE_CASE   						=		{1: [2, 3], 2: [4, 5], 3: [6, 7], 7: [8, 9]}
						print(F'''Binary tree: {binary_tree}''')
						_SCREAMING_SNAKE_CASE   						=		binary_tree_mirror(binary_tree, 5)
						print(F'''Binary tree mirror: {binary_tree_mirror_dictionary}''')

