
from typing import Optional

import torch
import torch.utils.checkpoint
from torch import Tensor, nn
from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss

from ...activations import ACTaFN
from ...modeling_outputs import (
    BackboneOutput,
    BaseModelOutputWithNoAttention,
    BaseModelOutputWithPoolingAndNoAttention,
    ImageClassifierOutputWithNoAttention,
)
from ...modeling_utils import PreTrainedModel
from ...utils import (
    add_code_sample_docstrings,
    add_start_docstrings,
    add_start_docstrings_to_model_forward,
    logging,
    replace_return_docstrings,
)
from ...utils.backbone_utils import BackboneMixin
from .configuration_resnet import ResNetConfig


__A				=logging.get_logger(__name__)

# General docstring
__A				='''ResNetConfig'''

# Base docstring
__A				='''microsoft/resnet-50'''
__A				=[1, 2_0_4_8, 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     _SCREAMING_SNAKE_CASE     (      nn.Module						):



	def __init__(    self						,  lowercase						,  lowercase						,  lowercase = 3						,  lowercase = 1						,  lowercase = "relu" )				->       List[Any]:
					super().__init__()
					lowerCamelCase_						=			nn.Convad(
					    lowercase						,  lowercase						,  kernel_size=lowercase						,  stride=lowercase						,  padding=kernel_size // 2						,  bias=lowercase )
					lowerCamelCase_						=			nn.BatchNormad(lowercase )
					lowerCamelCase_						=			ACTaFN[activation] if activation is not None else nn.Identity()



	def     SCREAMING_SNAKE_CASE_(    self						,  lowercase )				->       Tensor:
					lowerCamelCase_						=			self.convolution(lowercase )
					lowerCamelCase_						=			self.normalization(lowercase )
					lowerCamelCase_						=			self.activation(lowercase )
					return hidden_state




class     _SCREAMING_SNAKE_CASE     (      nn.Module						):



	def __init__(    self						,  lowercase )				->       List[str]:
					super().__init__()
					lowerCamelCase_						=			ResNetConvLayer(
					    config.num_channels						,  config.embedding_size						,  kernel_size=7						,  stride=2						,  activation=config.hidden_act )
					lowerCamelCase_						=			nn.MaxPoolad(kernel_size=3						,  stride=2						,  padding=1 )
					lowerCamelCase_						=			config.num_channels



	def     SCREAMING_SNAKE_CASE_(    self						,  lowercase )				->       Tensor:
					lowerCamelCase_						=			pixel_values.shape[1]
					if 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." )
					lowerCamelCase_						=			self.embedder(lowercase )
					lowerCamelCase_						=			self.pooler(lowercase )
					return embedding




class     _SCREAMING_SNAKE_CASE     (      nn.Module						):



	def __init__(    self						,  lowercase						,  lowercase						,  lowercase = 2 )				->       Dict:
					super().__init__()
					lowerCamelCase_						=			nn.Convad(lowercase						,  lowercase						,  kernel_size=1						,  stride=lowercase						,  bias=lowercase )
					lowerCamelCase_						=			nn.BatchNormad(lowercase )



	def     SCREAMING_SNAKE_CASE_(    self						,  lowercase )				->       Tensor:
					lowerCamelCase_						=			self.convolution(lowercase )
					lowerCamelCase_						=			self.normalization(lowercase )
					return hidden_state




class     _SCREAMING_SNAKE_CASE     (      nn.Module						):



	def __init__(    self						,  lowercase						,  lowercase						,  lowercase = 1						,  lowercase = "relu" )				->       List[Any]:
					super().__init__()
					lowerCamelCase_						=			in_channels != out_channels or stride != 1
					lowerCamelCase_						=			(
					    ResNetShortCut(lowercase						,  lowercase						,  stride=lowercase ) if should_apply_shortcut else nn.Identity()
					)
					lowerCamelCase_						=			nn.Sequential(
					    ResNetConvLayer(lowercase						,  lowercase						,  stride=lowercase )						,  ResNetConvLayer(lowercase						,  lowercase						,  activation=lowercase )						,  )
					lowerCamelCase_						=			ACTaFN[activation]



	def     SCREAMING_SNAKE_CASE_(    self						,  lowercase )				->       Union[str, Any]:
					lowerCamelCase_						=			hidden_state
					lowerCamelCase_						=			self.layer(lowercase )
					lowerCamelCase_						=			self.shortcut(lowercase )
					hidden_state += residual
					lowerCamelCase_						=			self.activation(lowercase )
					return hidden_state




class     _SCREAMING_SNAKE_CASE     (      nn.Module						):



	def __init__(    self						,  lowercase						,  lowercase						,  lowercase = 1						,  lowercase = "relu"						,  lowercase = 4 )				->       List[Any]:
					super().__init__()
					lowerCamelCase_						=			in_channels != out_channels or stride != 1
					lowerCamelCase_						=			out_channels // reduction
					lowerCamelCase_						=			(
					    ResNetShortCut(lowercase						,  lowercase						,  stride=lowercase ) if should_apply_shortcut else nn.Identity()
					)
					lowerCamelCase_						=			nn.Sequential(
					    ResNetConvLayer(lowercase						,  lowercase						,  kernel_size=1 )						,  ResNetConvLayer(lowercase						,  lowercase						,  stride=lowercase )						,  ResNetConvLayer(lowercase						,  lowercase						,  kernel_size=1						,  activation=lowercase )						,  )
					lowerCamelCase_						=			ACTaFN[activation]



	def     SCREAMING_SNAKE_CASE_(    self						,  lowercase )				->       Optional[Any]:
					lowerCamelCase_						=			hidden_state
					lowerCamelCase_						=			self.layer(lowercase )
					lowerCamelCase_						=			self.shortcut(lowercase )
					hidden_state += residual
					lowerCamelCase_						=			self.activation(lowercase )
					return hidden_state




class     _SCREAMING_SNAKE_CASE     (      nn.Module						):



	def __init__(    self						,  lowercase						,  lowercase						,  lowercase						,  lowercase = 2						,  lowercase = 2						,  )				->       Union[str, Any]:
					super().__init__()

					lowerCamelCase_						=			ResNetBottleNeckLayer if config.layer_type == "bottleneck" else ResNetBasicLayer

					lowerCamelCase_						=			nn.Sequential(
					    # downsampling is done in the first layer with stride of 2
					    layer(lowercase						,  lowercase						,  stride=lowercase						,  activation=config.hidden_act )						,  *[layer(lowercase						,  lowercase						,  activation=config.hidden_act ) for _ in range(depth - 1 )]						,  )



	def     SCREAMING_SNAKE_CASE_(    self						,  lowercase )				->       Tensor:
					lowerCamelCase_						=			input
					for layer in self.layers:
									lowerCamelCase_						=			layer(lowercase )
					return hidden_state




class     _SCREAMING_SNAKE_CASE     (      nn.Module						):



	def __init__(    self						,  lowercase )				->       Union[str, Any]:
					super().__init__()
					lowerCamelCase_						=			nn.ModuleList([] )
					# based on `downsample_in_first_stage` the first layer of the first stage may or may not downsample the input
					self.stages.append(
					    ResNetStage(
					        lowercase						,  config.embedding_size						,  config.hidden_sizes[0]						,  stride=2 if config.downsample_in_first_stage else 1						,  depth=config.depths[0]						,  ) )
					lowerCamelCase_						=			zip(config.hidden_sizes						,  config.hidden_sizes[1:] )
					for (in_channels, out_channels), depth in zip(lowercase						,  config.depths[1:] ):
									self.stages.append(ResNetStage(lowercase						,  lowercase						,  lowercase						,  depth=lowercase ) )



	def     SCREAMING_SNAKE_CASE_(    self						,  lowercase						,  lowercase = False						,  lowercase = True )				->       BaseModelOutputWithNoAttention:
					lowerCamelCase_						=			() if output_hidden_states else None

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

									lowerCamelCase_						=			stage_module(lowercase )

					if output_hidden_states:
									lowerCamelCase_						=			hidden_states + (hidden_state,)

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

					return BaseModelOutputWithNoAttention(
					    last_hidden_state=lowercase						,  hidden_states=lowercase						,  )




class     _SCREAMING_SNAKE_CASE     (      snake_case_						):
	lowerCAmelCase__         = ResNetConfig
	lowerCAmelCase__         = 'resnet'
	lowerCAmelCase__         = 'pixel_values'
	lowerCAmelCase__         = True



	def     SCREAMING_SNAKE_CASE_(    self						,  lowercase )				->       Tuple:
					if isinstance(lowercase						,  nn.Convad ):
									nn.init.kaiming_normal_(module.weight						,  mode="fan_out"						,  nonlinearity="relu" )
					elif isinstance(lowercase						,  (nn.BatchNormad, nn.GroupNorm) ):
									nn.init.constant_(module.weight						,  1 )
									nn.init.constant_(module.bias						,  0 )



	def     SCREAMING_SNAKE_CASE_(    self						,  lowercase						,  lowercase=False )				->       Tuple:
					if isinstance(lowercase						,  lowercase ):
									lowerCamelCase_						=			value



__A				=R'''
    This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass. Use it
    as a regular PyTorch Module and refer to the PyTorch 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 [`~PreTrainedModel.from_pretrained`] method to load the model weights.
'''

__A				=R'''
    Args:
        pixel_values (`torch.FloatTensor` 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.
'''




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



	def __init__(    self						,  lowercase )				->       Union[str, Any]:
					super().__init__(lowercase )
					lowerCamelCase_						=			config
					lowerCamelCase_						=			ResNetEmbeddings(lowercase )
					lowerCamelCase_						=			ResNetEncoder(lowercase )
					lowerCamelCase_						=			nn.AdaptiveAvgPoolad((1, 1) )
					# Initialize weights and apply final processing
					self.post_init()



	@add_start_docstrings_to_model_forward(lowercase )
	@add_code_sample_docstrings(
	    checkpoint=_CHECKPOINT_FOR_DOC						,  output_type=lowercase						,  config_class=_CONFIG_FOR_DOC						,  modality="vision"						,  expected_output=_EXPECTED_OUTPUT_SHAPE						,  )
	def     SCREAMING_SNAKE_CASE_(    self						,  lowercase						,  lowercase = None						,  lowercase = None )				->       BaseModelOutputWithPoolingAndNoAttention:
					lowerCamelCase_						=			(
					    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
					)
					lowerCamelCase_						=			return_dict if return_dict is not None else self.config.use_return_dict

					lowerCamelCase_						=			self.embedder(lowercase )

					lowerCamelCase_						=			self.encoder(
					    lowercase						,  output_hidden_states=lowercase						,  return_dict=lowercase )

					lowerCamelCase_						=			encoder_outputs[0]

					lowerCamelCase_						=			self.pooler(lowercase )

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

					return BaseModelOutputWithPoolingAndNoAttention(
					    last_hidden_state=lowercase						,  pooler_output=lowercase						,  hidden_states=encoder_outputs.hidden_states						,  )




@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     _SCREAMING_SNAKE_CASE     (      snake_case_						):



	def __init__(    self						,  lowercase )				->       str:
					super().__init__(lowercase )
					lowerCamelCase_						=			config.num_labels
					lowerCamelCase_						=			ResNetModel(lowercase )
					# classification head
					lowerCamelCase_						=			nn.Sequential(
					    nn.Flatten()						,  nn.Linear(config.hidden_sizes[-1]						,  config.num_labels ) if config.num_labels > 0 else nn.Identity()						,  )
					# initialize weights and apply final processing
					self.post_init()



	@add_start_docstrings_to_model_forward(lowercase )
	@add_code_sample_docstrings(
	    checkpoint=_IMAGE_CLASS_CHECKPOINT						,  output_type=lowercase						,  config_class=_CONFIG_FOR_DOC						,  expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT						,  )
	def     SCREAMING_SNAKE_CASE_(    self						,  lowercase = None						,  lowercase = None						,  lowercase = None						,  lowercase = None						,  )				->       ImageClassifierOutputWithNoAttention:
					lowerCamelCase_						=			return_dict if return_dict is not None else self.config.use_return_dict

					lowerCamelCase_						=			self.resnet(lowercase						,  output_hidden_states=lowercase						,  return_dict=lowercase )

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

					lowerCamelCase_						=			self.classifier(lowercase )

					lowerCamelCase_						=			None

					if labels is not None:
									if self.config.problem_type is None:
													if self.num_labels == 1:
																	lowerCamelCase_						=			"regression"
													elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
																	lowerCamelCase_						=			"single_label_classification"
													else:
																	lowerCamelCase_						=			"multi_label_classification"
									if self.config.problem_type == "regression":
													lowerCamelCase_						=			MSELoss()
													if self.num_labels == 1:
																	lowerCamelCase_						=			loss_fct(logits.squeeze()						,  labels.squeeze() )
													else:
																	lowerCamelCase_						=			loss_fct(lowercase						,  lowercase )
									elif self.config.problem_type == "single_label_classification":
													lowerCamelCase_						=			CrossEntropyLoss()
													lowerCamelCase_						=			loss_fct(logits.view(-1						,  self.num_labels )						,  labels.view(-1 ) )
									elif self.config.problem_type == "multi_label_classification":
													lowerCamelCase_						=			BCEWithLogitsLoss()
													lowerCamelCase_						=			loss_fct(lowercase						,  lowercase )

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

					return ImageClassifierOutputWithNoAttention(loss=lowercase						,  logits=lowercase						,  hidden_states=outputs.hidden_states )




@add_start_docstrings(
    '\n    ResNet backbone, to be used with frameworks like DETR and MaskFormer.\n    '			,       snake_case_			,       )
class     _SCREAMING_SNAKE_CASE     (      snake_case_			,       snake_case_						):



	def __init__(    self						,  lowercase )				->       Optional[int]:
					super().__init__(lowercase )
					super()._init_backbone(lowercase )

					lowerCamelCase_						=			[config.embedding_size] + config.hidden_sizes
					lowerCamelCase_						=			ResNetEmbeddings(lowercase )
					lowerCamelCase_						=			ResNetEncoder(lowercase )

					# initialize weights and apply final processing
					self.post_init()



	@add_start_docstrings_to_model_forward(lowercase )
	@replace_return_docstrings(output_type=lowercase						,  config_class=_CONFIG_FOR_DOC )
	def     SCREAMING_SNAKE_CASE_(    self						,  lowercase						,  lowercase = None						,  lowercase = None )				->       BackboneOutput:
					lowerCamelCase_						=			return_dict if return_dict is not None else self.config.use_return_dict
					lowerCamelCase_						=			(
					    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
					)

					lowerCamelCase_						=			self.embedder(lowercase )

					lowerCamelCase_						=			self.encoder(lowercase						,  output_hidden_states=lowercase						,  return_dict=lowercase )

					lowerCamelCase_						=			outputs.hidden_states

					lowerCamelCase_						=			()
					for idx, stage in enumerate(self.stage_names ):
									if stage in self.out_features:
													feature_maps += (hidden_states[idx],)

					if not return_dict:
									lowerCamelCase_						=			(feature_maps,)
									if output_hidden_states:
													output += (outputs.hidden_states,)
									return output

					return BackboneOutput(
					    feature_maps=lowercase						,  hidden_states=outputs.hidden_states if output_hidden_states else None						,  attentions=lowercase						,  )




import math





def 			lowerCamelCase_ (				lowerCamelCase__	, lowerCamelCase__    ):
				if 0 not in (x, y):
								# We use the relation x^y = y*log10(x), where 10 is the base.
								return y * math.logaa(lowerCamelCase__    )
				else:
								if x == 0:  # 0 raised to any number is 0
												return 0
								elif y == 0:
												return 1  # any number raised to 0 is 1
				raise AssertionError("This should never happen"    )


if __name__ == "__main__":  # Main function
			# Read two numbers from input and typecast them to int using map function.
			# Here x is the base and y is the power.
			__A				='''Enter the base and the power separated by a comma: '''
			__A,						__A				=map(int, input(prompt).split(''','''))
			__A,						__A				=map(int, input(prompt).split(''','''))

			# We find the log of each number, using the function res(), which takes two
			# arguments.
			__A				=res(xa, ya)
			__A				=res(xa, ya)

			# We check for the largest number
			if resa > resa:
						print('''Largest number is''', xa, '''^''', ya)
			elif resa > resa:
						print('''Largest number is''', xa, '''^''', ya)
			else:
						print('''Both are equal''')


