

from typing import Optional, Tuple, Union

import tensorflow as tf

from ...activations_tf import ACTaFN
from ...file_utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward
from ...modeling_tf_outputs import (
    TFBaseModelOutputWithNoAttention,
    TFBaseModelOutputWithPoolingAndNoAttention,
    TFSequenceClassifierOutput,
)
from ...modeling_tf_utils import TFPreTrainedModel, TFSequenceClassificationLoss, keras_serializable, unpack_inputs
from ...tf_utils import shape_list
from ...utils import logging
from .configuration_regnet import RegNetConfig


A											=     logging.get_logger(__name__)

# General docstring
A											=     'RegNetConfig'

# Base docstring
A											=     'facebook/regnet-y-040'
A											=     [1, 1088, 7, 7]

# Image classification docstring
A											=     'facebook/regnet-y-040'
A											=     'tabby, tabby cat'

A											=     [
    'facebook/regnet-y-040',
    # See all regnet models at https://huggingface.co/models?filter=regnet
]


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






			"""simple docstring"""




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

				"""simple docstring"""


				super().__init__(**__A							)
				# The padding and conv has been verified in
				# https://colab.research.google.com/gist/sayakpaul/854bc10eeaf21c9ee2119e0b9f3841a7/scratchpad.ipynb
				snake_case_      		= tf.keras.layers.ZeroPaddingaD(padding=kernel_size // 2							)
				snake_case_      		= tf.keras.layers.ConvaD(
				    filters=__A ,				kernel_size=__A ,				strides=__A ,				padding='VALID' ,				groups=__A ,				use_bias=__A ,				name='convolution' ,				)
				snake_case_      		= tf.keras.layers.BatchNormalization(epsilon=1E-5 ,				momentum=0.9 ,				name='normalization'							)
				snake_case_      		= ACTaFN[activation] if activation is not None else tf.identity







			def 			__lowerCAmelCase (    self ,				__UpperCamelCase							):

				"""simple docstring"""


				snake_case_      		= self.convolution(self.padding(__A							)							)
				snake_case_      		= self.normalization(__A							)
				snake_case_      		= self.activation(__A							)
				return hidden_state







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






			"""simple docstring"""




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

				"""simple docstring"""


				super().__init__(**__A							)
				snake_case_      		= config.num_channels
				snake_case_      		= TFRegNetConvLayer(
				    out_channels=config.embedding_size ,				kernel_size=3 ,				stride=2 ,				activation=config.hidden_act ,				name='embedder' ,				)







			def 			__lowerCAmelCase (    self ,				__UpperCamelCase							):

				"""simple docstring"""


				snake_case_      		= shape_list(__A							)[1]
				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.'							)

				# When running on CPU, `tf.keras.layers.Conv2D` doesn't support `NCHW` format.
				# So change the input format from `NCHW` to `NHWC`.
				# shape = (batch_size, in_height, in_width, in_channels=num_channels)
				snake_case_      		= tf.transpose(__A ,				perm=(0, 2, 3, 1)							)
				snake_case_      		= self.embedder(__A							)
				return hidden_state







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






			"""simple docstring"""




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

				"""simple docstring"""


				super().__init__(**__A							)
				snake_case_      		= tf.keras.layers.ConvaD(
				    filters=__A ,				kernel_size=1 ,				strides=__A ,				use_bias=__A ,				name='convolution'							)
				snake_case_      		= tf.keras.layers.BatchNormalization(epsilon=1E-5 ,				momentum=0.9 ,				name='normalization'							)







			def 			__lowerCAmelCase (    self ,				__UpperCamelCase ,				__UpperCamelCase = False							):

				"""simple docstring"""


				return self.normalization(self.convolution(__A							) ,				training=__A							)







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






			"""simple docstring"""




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

				"""simple docstring"""


				super().__init__(**__A							)
				snake_case_      		= tf.keras.layers.GlobalAveragePoolingaD(keepdims=__A ,				name='pooler'							)
				snake_case_      		= [
				    tf.keras.layers.ConvaD(filters=__A ,				kernel_size=1 ,				activation='relu' ,				name='attention.0'							),
				    tf.keras.layers.ConvaD(filters=__A ,				kernel_size=1 ,				activation='sigmoid' ,				name='attention.2'							),
				]







			def 			__lowerCAmelCase (    self ,				__UpperCamelCase							):

				"""simple docstring"""


				snake_case_      		= self.pooler(__A							)
				for layer_module in self.attention:
					snake_case_      		= layer_module(__A							)
				snake_case_      		= hidden_state * pooled
				return hidden_state







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






			"""simple docstring"""




			def __init__(    self ,				__UpperCamelCase ,				__UpperCamelCase ,				__UpperCamelCase ,				__UpperCamelCase = 1 ,				**__UpperCamelCase							):

				"""simple docstring"""


				super().__init__(**__A							)
				snake_case_      		= in_channels != out_channels or stride != 1
				snake_case_      		= max(1 ,				out_channels // config.groups_width							)
				snake_case_      		= (
				    TFRegNetShortCut(__A ,				stride=__A ,				name='shortcut'							)
				    if should_apply_shortcut
				    else tf.keras.layers.Activation('linear' ,				name='shortcut'							)
				)
				# `self.layers` instead of `self.layer` because that is a reserved argument.
				snake_case_      		= [
				    TFRegNetConvLayer(__A ,				kernel_size=1 ,				activation=config.hidden_act ,				name='layer.0'							),
				    TFRegNetConvLayer(
				        __A ,				stride=__A ,				groups=__A ,				activation=config.hidden_act ,				name='layer.1'							),
				    TFRegNetConvLayer(__A ,				kernel_size=1 ,				activation=__A ,				name='layer.2'							),
				]
				snake_case_      		= ACTaFN[config.hidden_act]







			def 			__lowerCAmelCase (    self ,				__UpperCamelCase							):

				"""simple docstring"""


				snake_case_      		= hidden_state
				for layer_module in self.layers:
					snake_case_      		= layer_module(__A							)
				snake_case_      		= self.shortcut(__A							)
				hidden_state += residual
				snake_case_      		= self.activation(__A							)
				return hidden_state







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






			"""simple docstring"""




			def __init__(    self ,				__UpperCamelCase ,				__UpperCamelCase ,				__UpperCamelCase ,				__UpperCamelCase = 1 ,				**__UpperCamelCase							):

				"""simple docstring"""


				super().__init__(**__A							)
				snake_case_      		= in_channels != out_channels or stride != 1
				snake_case_      		= max(1 ,				out_channels // config.groups_width							)
				snake_case_      		= (
				    TFRegNetShortCut(__A ,				stride=__A ,				name='shortcut'							)
				    if should_apply_shortcut
				    else tf.keras.layers.Activation('linear' ,				name='shortcut'							)
				)
				snake_case_      		= [
				    TFRegNetConvLayer(__A ,				kernel_size=1 ,				activation=config.hidden_act ,				name='layer.0'							),
				    TFRegNetConvLayer(
				        __A ,				stride=__A ,				groups=__A ,				activation=config.hidden_act ,				name='layer.1'							),
				    TFRegNetSELayer(__A ,				reduced_channels=int(round(in_channels / 4							)							) ,				name='layer.2'							),
				    TFRegNetConvLayer(__A ,				kernel_size=1 ,				activation=__A ,				name='layer.3'							),
				]
				snake_case_      		= ACTaFN[config.hidden_act]







			def 			__lowerCAmelCase (    self ,				__UpperCamelCase							):

				"""simple docstring"""


				snake_case_      		= hidden_state
				for layer_module in self.layers:
					snake_case_      		= layer_module(__A							)
				snake_case_      		= self.shortcut(__A							)
				hidden_state += residual
				snake_case_      		= self.activation(__A							)
				return hidden_state







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






			"""simple docstring"""




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

				"""simple docstring"""


				super().__init__(**__A							)

				snake_case_      		= TFRegNetXLayer if config.layer_type == "x" else TFRegNetYLayer
				snake_case_      		= [
				    # downsampling is done in the first layer with stride of 2
				    layer(__A ,				__A ,				__A ,				stride=__A ,				name='layers.0'							),
				    *[layer(__A ,				__A ,				__A ,				name=f"""layers.{i+1}"""							) for i in range(depth - 1							)],
				]







			def 			__lowerCAmelCase (    self ,				__UpperCamelCase							):

				"""simple docstring"""


				for layer_module in self.layers:
					snake_case_      		= layer_module(__A							)
				return hidden_state







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






			"""simple docstring"""




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

				"""simple docstring"""


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







			def 			__lowerCAmelCase (    self ,				__UpperCamelCase ,				__UpperCamelCase = False ,				__UpperCamelCase = True							):

				"""simple docstring"""


				snake_case_      		= () if output_hidden_states else None

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

					snake_case_      		= stage_module(__A							)

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







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






			"""simple docstring"""




			__A						  =  RegNetConfig


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

				"""simple docstring"""


				super().__init__(**__A							)
				snake_case_      		= config
				snake_case_      		= TFRegNetEmbeddings(__A ,				name='embedder'							)
				snake_case_      		= TFRegNetEncoder(__A ,				name='encoder'							)
				snake_case_      		= tf.keras.layers.GlobalAveragePoolingaD(keepdims=__A ,				name='pooler'							)







			@unpack_inputs
			def 			__lowerCAmelCase (    self ,				__UpperCamelCase ,				__UpperCamelCase = None ,				__UpperCamelCase = None ,				__UpperCamelCase = False ,				):

				"""simple docstring"""


				snake_case_      		= (
				    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
				)
				snake_case_      		= return_dict if return_dict is not None else self.config.use_return_dict

				snake_case_      		= self.embedder(__A ,				training=__A							)

				snake_case_      		= self.encoder(
				    __A ,				output_hidden_states=__A ,				return_dict=__A ,				training=__A							)

				snake_case_      		= encoder_outputs[0]
				snake_case_      		= self.pooler(__A							)

				# Change to NCHW output format have uniformity in the modules
				snake_case_      		= tf.transpose(__A ,				perm=(0, 3, 1, 2)							)
				snake_case_      		= tf.transpose(__A ,				perm=(0, 3, 1, 2)							)

				# Change the other hidden state outputs to NCHW as well
				if output_hidden_states:
					snake_case_      		= tuple([tf.transpose(__A ,				perm=(0, 3, 1, 2)							) for h in encoder_outputs[1]]							)

				if not return_dict:
					return (last_hidden_state, pooled_output) + encoder_outputs[1:]

				return TFBaseModelOutputWithPoolingAndNoAttention(
				    last_hidden_state=__A ,				pooler_output=__A ,				hidden_states=hidden_states if output_hidden_states else encoder_outputs.hidden_states ,				)







class SCREAMING_SNAKE_CASE  (		__snake_case							):






			"""simple docstring"""




			__A						  =  RegNetConfig
			__A						  =  """regnet"""
			__A						  =  """pixel_values"""


			@property
			def 			__lowerCAmelCase (    self							):

				"""simple docstring"""


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







A											=     R'\n    Parameters:\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        config ([`RegNetConfig`]): 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            [`ConveNextImageProcessor.__call__`] for details.\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'


@add_start_docstrings(
    """The bare RegNet model outputting raw features without any specific head on top."""							,						__snake_case							,						)
class SCREAMING_SNAKE_CASE  (		__snake_case							):






			"""simple docstring"""




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

				"""simple docstring"""


				super().__init__(__A ,				*__A ,				**__A							)
				snake_case_      		= TFRegNetMainLayer(__A ,				name='regnet'							)







			@unpack_inputs
			@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 ,				)
			def 			__lowerCAmelCase (    self ,				__UpperCamelCase ,				__UpperCamelCase = None ,				__UpperCamelCase = None ,				__UpperCamelCase=False ,				):

				"""simple docstring"""


				snake_case_      		= (
				    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
				)
				snake_case_      		= return_dict if return_dict is not None else self.config.use_return_dict

				snake_case_      		= self.regnet(
				    pixel_values=__A ,				output_hidden_states=__A ,				return_dict=__A ,				training=__A ,				)
				if not return_dict:
					return (outputs[0],) + outputs[1:]

				return TFBaseModelOutputWithPoolingAndNoAttention(
				    last_hidden_state=outputs.last_hidden_state ,				pooler_output=outputs.pooler_output ,				hidden_states=outputs.hidden_states ,				)







@add_start_docstrings(
    """\n    RegNet 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 SCREAMING_SNAKE_CASE  (		__snake_case							,						__snake_case							):






			"""simple docstring"""




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

				"""simple docstring"""


				super().__init__(__A ,				*__A ,				**__A							)
				snake_case_      		= config.num_labels
				snake_case_      		= TFRegNetMainLayer(__A ,				name='regnet'							)
				# classification head
				snake_case_      		= [
				    tf.keras.layers.Flatten(),
				    tf.keras.layers.Dense(config.num_labels ,				name='classifier.1'							) if config.num_labels > 0 else tf.identity,
				]







			@unpack_inputs
			@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 ,				)
			def 			__lowerCAmelCase (    self ,				__UpperCamelCase = None ,				__UpperCamelCase = None ,				__UpperCamelCase = None ,				__UpperCamelCase = None ,				__UpperCamelCase=False ,				):

				"""simple docstring"""


				snake_case_      		= (
				    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
				)
				snake_case_      		= return_dict if return_dict is not None else self.config.use_return_dict

				snake_case_      		= self.regnet(
				    __A ,				output_hidden_states=__A ,				return_dict=__A ,				training=__A							)

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

				snake_case_      		= self.classifier[0](__A							)
				snake_case_      		= self.classifier[1](__A							)

				snake_case_      		= None if labels is None else self.hf_compute_loss(labels=__A ,				logits=__A							)

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

				return TFSequenceClassifierOutput(loss=__A ,				logits=__A ,				hidden_states=outputs.hidden_states							)



import operator as op





def a(lowercase__	):





	'''simple docstring'''
	snake_case_      		= []
	snake_case_      		= lambda lowercase__			, lowercase__	: int(x / y	)  # noqa: E731 integer division operation
	snake_case_      		= {
	    '^': op.pow,
	    '*': op.mul,
	    '/': div,
	    '+': op.add,
	    '-': op.sub,
	}  # operators & their respective operation

	# print table header
	print('Symbol'.center(8	)			, 'Action'.center(12	)			, 'Stack'			, sep=' | '	)
	print('-' * (30 + len(lowercase__	))	)

	for x in post_fix:
		if x.isdigit():  # if x in digit
			stack.append(lowercase__	)  # append x to stack
			# output in tabular format
			print(x.rjust(8	)			, ('push(' + x + ')').ljust(12	)			, ','.join(lowercase__	)			, sep=' | '	)
		else:
			snake_case_      		= stack.pop()  # pop stack
			# output in tabular format
			print(''.rjust(8	)			, ('pop(' + b + ')').ljust(12	)			, ','.join(lowercase__	)			, sep=' | '	)

			snake_case_      		= stack.pop()  # pop stack
			# output in tabular format
			print(''.rjust(8	)			, ('pop(' + a + ')').ljust(12	)			, ','.join(lowercase__	)			, sep=' | '	)

			stack.append(
			    str(opr[x](int(lowercase__	)			, int(lowercase__	)	)	)	)  # evaluate the 2 values popped from stack & push result to stack
			# output in tabular format
			print(
			    x.rjust(8	)			, ('push(' + a + x + b + ')').ljust(12	)			, ','.join(lowercase__	)			, sep=' | '			, )

	return int(stack[0]	)


if __name__ == "__main__":
		A											=     input('\n\nEnter a Postfix Equation (space separated) = ').split(' ')
		print('\n\tResult = ', solve(Postfix))
