




"""simple docstring"""
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_				:    Optional[int]										=     logging.get_logger(__name__)

# General docstring
a_				:    Optional[int]										=     '''ResNetConfig'''

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

# Image classification docstring
a_				:    Optional[int]										=     '''microsoft/resnet-50'''
a_				:    Optional[int]										=     '''tiger cat'''

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

class __lowercase(      nn.Module				):




					'''simple docstring'''


					def __init__(    self						,	__a						,	__a						,	__a = 3						,	__a = 1						,	__a = "relu"     ):
								super().__init__()
								__lowerCamelCase					:	Optional[int]	       =				nn.Convad(
								    __a						,	__a						,	kernel_size=__a						,	stride=__a						,	padding=kernel_size // 2						,	bias=__a     )
								__lowerCamelCase					:	Dict	       =				nn.BatchNormad(__a     )
								__lowerCamelCase					:	List[Any]	       =				ACTaFN[activation] if activation is not None else nn.Identity()





					def     snake_case_				(    self						,	__a     ):
								__lowerCamelCase					:	List[Any]	       =				self.convolution(__a     )
								__lowerCamelCase					:	Any	       =				self.normalization(__a     )
								__lowerCamelCase					:	Dict	       =				self.activation(__a     )
								return hidden_state



class __lowercase(      nn.Module				):




					'''simple docstring'''


					def __init__(    self						,	__a     ):
								super().__init__()
								__lowerCamelCase					:	List[str]	       =				ResNetConvLayer(
								    config.num_channels						,	config.embedding_size						,	kernel_size=7						,	stride=2						,	activation=config.hidden_act     )
								__lowerCamelCase					:	Optional[Any]	       =				nn.MaxPoolad(kernel_size=3						,	stride=2						,	padding=1     )
								__lowerCamelCase					:	List[Any]	       =				config.num_channels





					def     snake_case_				(    self						,	__a     ):
								__lowerCamelCase					:	Tuple	       =				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					:	List[Any]	       =				self.embedder(__a     )
								__lowerCamelCase					:	Any	       =				self.pooler(__a     )
								return embedding



class __lowercase(      nn.Module				):




					'''simple docstring'''


					def __init__(    self						,	__a						,	__a						,	__a = 2     ):
								super().__init__()
								__lowerCamelCase					:	Dict	       =				nn.Convad(__a						,	__a						,	kernel_size=1						,	stride=__a						,	bias=__a     )
								__lowerCamelCase					:	str	       =				nn.BatchNormad(__a     )





					def     snake_case_				(    self						,	__a     ):
								__lowerCamelCase					:	Dict	       =				self.convolution(__a     )
								__lowerCamelCase					:	str	       =				self.normalization(__a     )
								return hidden_state



class __lowercase(      nn.Module				):




					'''simple docstring'''


					def __init__(    self						,	__a						,	__a						,	__a = 1						,	__a = "relu"     ):
								super().__init__()
								__lowerCamelCase					:	List[str]	       =				in_channels != out_channels or stride != 1
								__lowerCamelCase					:	List[Any]	       =				(
								    ResNetShortCut(__a						,	__a						,	stride=__a     ) if should_apply_shortcut else nn.Identity()
								)
								__lowerCamelCase					:	Optional[int]	       =				nn.Sequential(
								    ResNetConvLayer(__a						,	__a						,	stride=__a     )						,	ResNetConvLayer(__a						,	__a						,	activation=__a     )						,	)
								__lowerCamelCase					:	str	       =				ACTaFN[activation]





					def     snake_case_				(    self						,	__a     ):
								__lowerCamelCase					:	Dict	       =				hidden_state
								__lowerCamelCase					:	Union[str, Any]	       =				self.layer(__a     )
								__lowerCamelCase					:	str	       =				self.shortcut(__a     )
								hidden_state += residual
								__lowerCamelCase					:	Optional[int]	       =				self.activation(__a     )
								return hidden_state



class __lowercase(      nn.Module				):




					'''simple docstring'''


					def __init__(    self						,	__a						,	__a						,	__a = 1						,	__a = "relu"						,	__a = 4     ):
								super().__init__()
								__lowerCamelCase					:	Union[str, Any]	       =				in_channels != out_channels or stride != 1
								__lowerCamelCase					:	Union[str, Any]	       =				out_channels // reduction
								__lowerCamelCase					:	Optional[int]	       =				(
								    ResNetShortCut(__a						,	__a						,	stride=__a     ) if should_apply_shortcut else nn.Identity()
								)
								__lowerCamelCase					:	str	       =				nn.Sequential(
								    ResNetConvLayer(__a						,	__a						,	kernel_size=1     )						,	ResNetConvLayer(__a						,	__a						,	stride=__a     )						,	ResNetConvLayer(__a						,	__a						,	kernel_size=1						,	activation=__a     )						,	)
								__lowerCamelCase					:	Optional[int]	       =				ACTaFN[activation]





					def     snake_case_				(    self						,	__a     ):
								__lowerCamelCase					:	Optional[Any]	       =				hidden_state
								__lowerCamelCase					:	Optional[int]	       =				self.layer(__a     )
								__lowerCamelCase					:	str	       =				self.shortcut(__a     )
								hidden_state += residual
								__lowerCamelCase					:	Tuple	       =				self.activation(__a     )
								return hidden_state



class __lowercase(      nn.Module				):




					'''simple docstring'''


					def __init__(    self						,	__a						,	__a						,	__a						,	__a = 2						,	__a = 2						,	):
								super().__init__()

								__lowerCamelCase					:	str	       =				ResNetBottleNeckLayer if config.layer_type == 'bottleneck' else ResNetBasicLayer

								__lowerCamelCase					:	Union[str, Any]	       =				nn.Sequential(
								    # downsampling is done in the first layer with stride of 2
								    layer(__a						,	__a						,	stride=__a						,	activation=config.hidden_act     )						,	*[layer(__a						,	__a						,	activation=config.hidden_act     ) for _ in range(depth - 1     )]						,	)





					def     snake_case_				(    self						,	__a     ):
								__lowerCamelCase					:	int	       =				input
								for layer in self.layers:
											__lowerCamelCase					:	int	       =				layer(__a     )
								return hidden_state



class __lowercase(      nn.Module				):




					'''simple docstring'''


					def __init__(    self						,	__a     ):
								super().__init__()
								__lowerCamelCase					:	str	       =				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(
								        __a						,	config.embedding_size						,	config.hidden_sizes[0]						,	stride=2 if config.downsample_in_first_stage else 1						,	depth=config.depths[0]						,	)     )
								__lowerCamelCase					:	List[Any]	       =				zip(config.hidden_sizes						,	config.hidden_sizes[1:]     )
								for (in_channels, out_channels), depth in zip(__a						,	config.depths[1:]     ):
											self.stages.append(ResNetStage(__a						,	__a						,	__a						,	depth=__a     )     )





					def     snake_case_				(    self						,	__a						,	__a = False						,	__a = True     ):
								__lowerCamelCase					:	Union[str, Any]	       =				() if output_hidden_states else None

								for stage_module in self.stages:
											if output_hidden_states:
														__lowerCamelCase					:	Optional[Any]	       =				hidden_states + (hidden_state,)

											__lowerCamelCase					:	Any	       =				stage_module(__a     )

								if output_hidden_states:
											__lowerCamelCase					:	Dict	       =				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=__a						,	hidden_states=__a						,	)



class __lowercase(      lowercase__				):




					'''simple docstring'''


					__a						:						List[str]     		= ResNetConfig
					__a						:						str     		= 'resnet'
					__a						:						str     		= 'pixel_values'
					__a						:						List[str]     		= True
					def     snake_case_				(    self						,	__a     ):
								if isinstance(__a						,	nn.Convad     ):
											nn.init.kaiming_normal_(module.weight						,	mode='fan_out'						,	nonlinearity='relu'     )
								elif isinstance(__a						,	(nn.BatchNormad, nn.GroupNorm)     ):
											nn.init.constant_(module.weight						,	1     )
											nn.init.constant_(module.bias						,	0     )





					def     snake_case_				(    self						,	__a						,	__a=False     ):
								if isinstance(__a						,	__a     ):
											__lowerCamelCase					:	Union[str, Any]	       =				value



a_				:    Tuple										=     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_				:    Optional[Any]										=     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.'	,	lowercase__	,	)
class __lowercase(      lowercase__				):




					'''simple docstring'''


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





					@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     snake_case_				(    self						,	__a						,	__a = None						,	__a = None     ):
								__lowerCamelCase					:	List[Any]	       =				(
								    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
								)
								__lowerCamelCase					:	int	       =				return_dict if return_dict is not None else self.config.use_return_dict

								__lowerCamelCase					:	Optional[Any]	       =				self.embedder(__a     )

								__lowerCamelCase					:	Optional[Any]	       =				self.encoder(
								    __a						,	output_hidden_states=__a						,	return_dict=__a     )

								__lowerCamelCase					:	int	       =				encoder_outputs[0]

								__lowerCamelCase					:	Optional[Any]	       =				self.pooler(__a     )

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

								return BaseModelOutputWithPoolingAndNoAttention(
								    last_hidden_state=__a						,	pooler_output=__a						,	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    '	,	lowercase__	,	)
class __lowercase(      lowercase__				):




					'''simple docstring'''


					def __init__(    self						,	__a     ):
								super().__init__(__a     )
								__lowerCamelCase					:	Optional[int]	       =				config.num_labels
								__lowerCamelCase					:	List[str]	       =				ResNetModel(__a     )
								# classification head
								__lowerCamelCase					:	Tuple	       =				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(__a     )
					@add_code_sample_docstrings(
					    checkpoint=_IMAGE_CLASS_CHECKPOINT						,	output_type=__a						,	config_class=_CONFIG_FOR_DOC						,	expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT						,	)
					def     snake_case_				(    self						,	__a = None						,	__a = None						,	__a = None						,	__a = None						,	):
								__lowerCamelCase					:	List[str]	       =				return_dict if return_dict is not None else self.config.use_return_dict

								__lowerCamelCase					:	int	       =				self.resnet(__a						,	output_hidden_states=__a						,	return_dict=__a     )

								__lowerCamelCase					:	List[Any]	       =				outputs.pooler_output if return_dict else outputs[1]

								__lowerCamelCase					:	str	       =				self.classifier(__a     )

								__lowerCamelCase					:	Dict	       =				None

								if labels is not None:
											if self.config.problem_type is None:
														if self.num_labels == 1:
																	__lowerCamelCase					:	str	       =				'regression'
														elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
																	__lowerCamelCase					:	Any	       =				'single_label_classification'
														else:
																	__lowerCamelCase					:	List[str]	       =				'multi_label_classification'
											if self.config.problem_type == "regression":
														__lowerCamelCase					:	Dict	       =				MSELoss()
														if self.num_labels == 1:
																	__lowerCamelCase					:	Optional[Any]	       =				loss_fct(logits.squeeze()						,	labels.squeeze()     )
														else:
																	__lowerCamelCase					:	Any	       =				loss_fct(__a						,	__a     )
											elif self.config.problem_type == "single_label_classification":
														__lowerCamelCase					:	List[str]	       =				CrossEntropyLoss()
														__lowerCamelCase					:	Optional[Any]	       =				loss_fct(logits.view(-1						,	self.num_labels     )						,	labels.view(-1     )     )
											elif self.config.problem_type == "multi_label_classification":
														__lowerCamelCase					:	Optional[int]	       =				BCEWithLogitsLoss()
														__lowerCamelCase					:	str	       =				loss_fct(__a						,	__a     )

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

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



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




					'''simple docstring'''


					def __init__(    self						,	__a     ):
								super().__init__(__a     )
								super()._init_backbone(__a     )

								__lowerCamelCase					:	Optional[int]	       =				[config.embedding_size] + config.hidden_sizes
								__lowerCamelCase					:	int	       =				ResNetEmbeddings(__a     )
								__lowerCamelCase					:	List[Any]	       =				ResNetEncoder(__a     )

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





					@add_start_docstrings_to_model_forward(__a     )
					@replace_return_docstrings(output_type=__a						,	config_class=_CONFIG_FOR_DOC     )
					def     snake_case_				(    self						,	__a						,	__a = None						,	__a = None     ):
								__lowerCamelCase					:	Any	       =				return_dict if return_dict is not None else self.config.use_return_dict
								__lowerCamelCase					:	Optional[Any]	       =				(
								    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
								)

								__lowerCamelCase					:	Dict	       =				self.embedder(__a     )

								__lowerCamelCase					:	str	       =				self.encoder(__a						,	output_hidden_states=__a						,	return_dict=__a     )

								__lowerCamelCase					:	Tuple	       =				outputs.hidden_states

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

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

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









"""simple docstring"""
import math





def 						UpperCAmelCase				(			A__:    int = 100     )  ->     int:
			__lowerCamelCase					:	Optional[Any]	       =				sum(i * i for i in range(1							,				n + 1     )     )
			__lowerCamelCase					:	Union[str, Any]	       =				int(math.pow(sum(range(1							,				n + 1     )     )							,				2     )     )
			return square_of_sum - sum_of_squares


if __name__ == "__main__":
					print(F"""{solution() = }""")



