


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


lowerCamelCase						=		logging.get_logger(__name__)

# General docstring
lowerCamelCase						=		"ResNetConfig"

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

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

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





class 					_a							(				nn.Module):




	def __init__(					self						:		Union[str, Any]		,					_SCREAMING_SNAKE_CASE						:		Any		,					_SCREAMING_SNAKE_CASE						:		Optional[Any]		,					_SCREAMING_SNAKE_CASE						:		Optional[Any] = 3		,					_SCREAMING_SNAKE_CASE						:		str = 1		,					_SCREAMING_SNAKE_CASE						:		Optional[int] = "relu"		)->       List[Any]:
			super().__init__()
			lowerCAmelCase__   :			Any         =					nn.Convad(
			    _A		,					_A		,					kernel_size=_A		,					stride=_A		,					padding=kernel_size // 2		,					bias=_A		)
			lowerCAmelCase__   :			Tuple         =					nn.BatchNormad(_A		)
			lowerCAmelCase__   :			Any         =					ACTaFN[activation] if activation is not None else nn.Identity()




	def 							UpperCAmelCase__(					self						:		List[str]		,					_SCREAMING_SNAKE_CASE						:		int		)->       List[str]:
			lowerCAmelCase__   :			Dict         =					self.convolution(_A		)
			lowerCAmelCase__   :			Dict         =					self.normalization(_A		)
			lowerCAmelCase__   :			List[Any]         =					self.activation(_A		)
			return hidden_state





class 					_a							(				nn.Module):




	def __init__(					self						:		Dict		,					_SCREAMING_SNAKE_CASE						:		List[str]		)->       int:
			super().__init__()
			lowerCAmelCase__   :			Optional[int]         =					ResNetConvLayer(
			    config.num_channels		,					config.embedding_size		,					kernel_size=7		,					stride=2		,					activation=config.hidden_act		)
			lowerCAmelCase__   :			Union[str, Any]         =					nn.MaxPoolad(kernel_size=3		,					stride=2		,					padding=1		)
			lowerCAmelCase__   :			Union[str, Any]         =					config.num_channels




	def 							UpperCAmelCase__(					self						:		Any		,					_SCREAMING_SNAKE_CASE						:		Optional[Any]		)->       Any:
			lowerCAmelCase__   :			Dict         =					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[str]         =					self.embedder(_A		)
			lowerCAmelCase__   :			List[str]         =					self.pooler(_A		)
			return embedding





class 					_a							(				nn.Module):




	def __init__(					self						:		Optional[int]		,					_SCREAMING_SNAKE_CASE						:		Any		,					_SCREAMING_SNAKE_CASE						:		List[str]		,					_SCREAMING_SNAKE_CASE						:		int = 2		)->       List[str]:
			super().__init__()
			lowerCAmelCase__   :			Optional[Any]         =					nn.Convad(_A		,					_A		,					kernel_size=1		,					stride=_A		,					bias=_A		)
			lowerCAmelCase__   :			List[str]         =					nn.BatchNormad(_A		)




	def 							UpperCAmelCase__(					self						:		Dict		,					_SCREAMING_SNAKE_CASE						:		List[str]		)->       Union[str, Any]:
			lowerCAmelCase__   :			Union[str, Any]         =					self.convolution(_A		)
			lowerCAmelCase__   :			Optional[int]         =					self.normalization(_A		)
			return hidden_state





class 					_a							(				nn.Module):




	def __init__(					self						:		Tuple		,					_SCREAMING_SNAKE_CASE						:		Optional[Any]		,					_SCREAMING_SNAKE_CASE						:		Optional[int]		,					_SCREAMING_SNAKE_CASE						:		Dict = 1		,					_SCREAMING_SNAKE_CASE						:		List[Any] = "relu"		)->       Tuple:
			super().__init__()
			lowerCAmelCase__   :			int         =					in_channels != out_channels or stride != 1
			lowerCAmelCase__   :			Dict         =					(
			    ResNetShortCut(_A		,					_A		,					stride=_A		) if should_apply_shortcut else nn.Identity()
			)
			lowerCAmelCase__   :			str         =					nn.Sequential(
			    ResNetConvLayer(_A		,					_A		,					stride=_A		)		,					ResNetConvLayer(_A		,					_A		,					activation=_A		)		,					)
			lowerCAmelCase__   :			Optional[int]         =					ACTaFN[activation]




	def 							UpperCAmelCase__(					self						:		Optional[Any]		,					_SCREAMING_SNAKE_CASE						:		Any		)->       List[Any]:
			lowerCAmelCase__   :			str         =					hidden_state
			lowerCAmelCase__   :			Optional[Any]         =					self.layer(_A		)
			lowerCAmelCase__   :			Dict         =					self.shortcut(_A		)
			hidden_state += residual
			lowerCAmelCase__   :			Any         =					self.activation(_A		)
			return hidden_state





class 					_a							(				nn.Module):




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




	def 							UpperCAmelCase__(					self						:		Tuple		,					_SCREAMING_SNAKE_CASE						:		int		)->       Dict:
			lowerCAmelCase__   :			str         =					hidden_state
			lowerCAmelCase__   :			List[Any]         =					self.layer(_A		)
			lowerCAmelCase__   :			Tuple         =					self.shortcut(_A		)
			hidden_state += residual
			lowerCAmelCase__   :			Optional[int]         =					self.activation(_A		)
			return hidden_state





class 					_a							(				nn.Module):




	def __init__(					self						:		Any		,					_SCREAMING_SNAKE_CASE						:		Optional[Any]		,					_SCREAMING_SNAKE_CASE						:		Dict		,					_SCREAMING_SNAKE_CASE						:		List[Any]		,					_SCREAMING_SNAKE_CASE						:		int = 2		,					_SCREAMING_SNAKE_CASE						:		Dict = 2		,					)->       int:
			super().__init__()

			lowerCAmelCase__   :			Union[str, Any]         =					ResNetBottleNeckLayer if config.layer_type == '''bottleneck''' else ResNetBasicLayer

			lowerCAmelCase__   :			Optional[int]         =					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 							UpperCAmelCase__(					self						:		Optional[int]		,					_SCREAMING_SNAKE_CASE						:		Any		)->       Tuple:
			lowerCAmelCase__   :			Any         =					input
			for layer in self.layers:
					lowerCAmelCase__   :			Dict         =					layer(_A		)
			return hidden_state





class 					_a							(				nn.Module):




	def __init__(					self						:		Dict		,					_SCREAMING_SNAKE_CASE						:		List[str]		)->       Optional[Any]:
			super().__init__()
			lowerCAmelCase__   :			Optional[int]         =					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[str]         =					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 							UpperCAmelCase__(					self						:		Any		,					_SCREAMING_SNAKE_CASE						:		str		,					_SCREAMING_SNAKE_CASE						:		Tuple = False		,					_SCREAMING_SNAKE_CASE						:		Any = True		)->       int:
			lowerCAmelCase__   :			Dict         =					() if output_hidden_states else None

			for stage_module in self.stages:
					if output_hidden_states:
							lowerCAmelCase__   :			Union[str, Any]         =					hidden_states + (hidden_state,)

					lowerCAmelCase__   :			List[str]         =					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 					_a							(				a_):
	_a  :  List[Any]          =							ResNetConfig
	_a  :  Any          =							'''resnet'''
	_a  :  Dict          =							'''pixel_values'''
	_a  :  str          =							True




	def 							UpperCAmelCase__(					self						:		List[str]		,					_SCREAMING_SNAKE_CASE						:		Tuple		)->       Optional[Any]:







			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 							UpperCAmelCase__(					self						:		int		,					_SCREAMING_SNAKE_CASE						:		int		,					_SCREAMING_SNAKE_CASE						:		str=False		)->       Optional[Any]:







			if isinstance(_A		,					_A		):
					lowerCAmelCase__   :			Tuple         =					value
lowerCamelCase						=		R"\n    This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass. Use it\n    as a regular PyTorch Module and refer to the PyTorch 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 [`~PreTrainedModel.from_pretrained`] method to load the model weights.\n"

lowerCamelCase						=		R"\n    Args:\n        pixel_values (`torch.FloatTensor` 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"





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




	def __init__(					self						:		str		,					_SCREAMING_SNAKE_CASE						:		List[Any]		)->       Any:
			super().__init__(_A		)
			lowerCAmelCase__   :			Optional[Any]         =					config
			lowerCAmelCase__   :			Optional[Any]         =					ResNetEmbeddings(_A		)
			lowerCAmelCase__   :			Optional[int]         =					ResNetEncoder(_A		)
			lowerCAmelCase__   :			List[Any]         =					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 							UpperCAmelCase__(					self						:		Union[str, Any]		,					_SCREAMING_SNAKE_CASE						:		Optional[Any]		,					_SCREAMING_SNAKE_CASE						:		Any = None		,					_SCREAMING_SNAKE_CASE						:		Dict = None		)->       List[Any]:
			lowerCAmelCase__   :			str         =					(
			    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
			)
			lowerCAmelCase__   :			Optional[int]         =					return_dict if return_dict is not None else self.config.use_return_dict

			lowerCAmelCase__   :			str         =					self.embedder(_A		)

			lowerCAmelCase__   :			int         =					self.encoder(
			    _A		,					output_hidden_states=_A		,					return_dict=_A		)

			lowerCAmelCase__   :			Dict         =					encoder_outputs[0]

			lowerCAmelCase__   :			Dict         =					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(
    '''
    ResNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for
    ImageNet.
    '''     ,						a_     ,						)
class 					_a							(				a_):




	def __init__(					self						:		List[Any]		,					_SCREAMING_SNAKE_CASE						:		Optional[Any]		)->       str:
			super().__init__(_A		)
			lowerCAmelCase__   :			List[Any]         =					config.num_labels
			lowerCAmelCase__   :			List[str]         =					ResNetModel(_A		)
			# classification head
			lowerCAmelCase__   :			Any         =					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 							UpperCAmelCase__(					self						:		List[str]		,					_SCREAMING_SNAKE_CASE						:		Optional[int] = None		,					_SCREAMING_SNAKE_CASE						:		Optional[int] = None		,					_SCREAMING_SNAKE_CASE						:		List[str] = None		,					_SCREAMING_SNAKE_CASE						:		Dict = None		,					)->       Optional[Any]:
			lowerCAmelCase__   :			Union[str, Any]         =					return_dict if return_dict is not None else self.config.use_return_dict

			lowerCAmelCase__   :			Any         =					self.resnet(_A		,					output_hidden_states=_A		,					return_dict=_A		)

			lowerCAmelCase__   :			Tuple         =					outputs.pooler_output if return_dict else outputs[1]

			lowerCAmelCase__   :			List[Any]         =					self.classifier(_A		)

			lowerCAmelCase__   :			List[Any]         =					None

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

			if not return_dict:
					lowerCAmelCase__   :			Tuple         =					(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(
    '''
    ResNet backbone, to be used with frameworks like DETR and MaskFormer.
    '''     ,						a_     ,						)
class 					_a							(				a_     ,						a_):




	def __init__(					self						:		Optional[Any]		,					_SCREAMING_SNAKE_CASE						:		List[str]		)->       Optional[int]:
			super().__init__(_A		)
			super()._init_backbone(_A		)

			lowerCAmelCase__   :			List[Any]         =					[config.embedding_size] + config.hidden_sizes
			lowerCAmelCase__   :			List[str]         =					ResNetEmbeddings(_A		)
			lowerCAmelCase__   :			List[str]         =					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 							UpperCAmelCase__(					self						:		Tuple		,					_SCREAMING_SNAKE_CASE						:		List[Any]		,					_SCREAMING_SNAKE_CASE						:		List[str] = None		,					_SCREAMING_SNAKE_CASE						:		Tuple = None		)->       str:
			lowerCAmelCase__   :			List[str]         =					return_dict if return_dict is not None else self.config.use_return_dict
			lowerCAmelCase__   :			Dict         =					(
			    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
			)

			lowerCAmelCase__   :			List[str]         =					self.embedder(_A		)

			lowerCAmelCase__   :			str         =					self.encoder(_A		,					output_hidden_states=_A		,					return_dict=_A		)

			lowerCAmelCase__   :			Dict         =					outputs.hidden_states

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

			if not return_dict:
					lowerCAmelCase__   :			Union[str, Any]         =					(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		,					)











def 						__SCREAMING_SNAKE_CASE  (				UpperCamelCase__ )  ->				list[int]:







			'''simple docstring'''

			if length <= 0 or not isinstance(UpperCamelCase__			,			UpperCamelCase__ ):
						raise ValueError('''Length must be a positive integer.''' )
			return [n * (2 * n - 1) for n in range(UpperCamelCase__ )]


if __name__ == "__main__":
				print(hexagonal_numbers(length=5))
				print(hexagonal_numbers(length=10))



