






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[Any]   							=     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_		:    Tuple   							=     'microsoft/resnet-50'
a_		:    str   							=     'tiger cat'

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

class 		_snake_case	(	nn.Module       ):






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







			def  SCREAMING_SNAKE_CASE__     (							self		,       a)   ->							Tensor:
						SCREAMING_SNAKE_CASE							=			self.convolution(lowerCamelCase__)
						SCREAMING_SNAKE_CASE							=			self.normalization(lowerCamelCase__)
						SCREAMING_SNAKE_CASE							=			self.activation(lowerCamelCase__)
						return hidden_state



class 		_snake_case	(	nn.Module       ):






			def __init__(							self		,       a)   ->							Dict:
						super().__init__()
						SCREAMING_SNAKE_CASE							=			ResNetConvLayer(
						    config.num_channels		,       config.embedding_size		,       kernel_size=7		,       stride=2		,       activation=config.hidden_act)
						SCREAMING_SNAKE_CASE							=			nn.MaxPoolad(kernel_size=3		,       stride=2		,       padding=1)
						SCREAMING_SNAKE_CASE							=			config.num_channels







			def  SCREAMING_SNAKE_CASE__     (							self		,       a)   ->							Tensor:
						SCREAMING_SNAKE_CASE							=			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.')
						SCREAMING_SNAKE_CASE							=			self.embedder(lowerCamelCase__)
						SCREAMING_SNAKE_CASE							=			self.pooler(lowerCamelCase__)
						return embedding



class 		_snake_case	(	nn.Module       ):






			def __init__(							self		,       a		,       a		,       a = 2)   ->							Tuple:
						super().__init__()
						SCREAMING_SNAKE_CASE							=			nn.Convad(lowerCamelCase__		,       lowerCamelCase__		,       kernel_size=1		,       stride=lowerCamelCase__		,       bias=lowerCamelCase__)
						SCREAMING_SNAKE_CASE							=			nn.BatchNormad(lowerCamelCase__)







			def  SCREAMING_SNAKE_CASE__     (							self		,       a)   ->							Tensor:
						SCREAMING_SNAKE_CASE							=			self.convolution(lowerCamelCase__)
						SCREAMING_SNAKE_CASE							=			self.normalization(lowerCamelCase__)
						return hidden_state



class 		_snake_case	(	nn.Module       ):






			def __init__(							self		,       a		,       a		,       a = 1		,       a = "relu")   ->							Optional[int]:
						super().__init__()
						SCREAMING_SNAKE_CASE							=			in_channels != out_channels or stride != 1
						SCREAMING_SNAKE_CASE							=			(
						    ResNetShortCut(lowerCamelCase__		,       lowerCamelCase__		,       stride=lowerCamelCase__) if should_apply_shortcut else nn.Identity()
						)
						SCREAMING_SNAKE_CASE							=			nn.Sequential(
						    ResNetConvLayer(lowerCamelCase__		,       lowerCamelCase__		,       stride=lowerCamelCase__)		,       ResNetConvLayer(lowerCamelCase__		,       lowerCamelCase__		,       activation=lowerCamelCase__)		,       )
						SCREAMING_SNAKE_CASE							=			ACTaFN[activation]







			def  SCREAMING_SNAKE_CASE__     (							self		,       a)   ->							str:
						SCREAMING_SNAKE_CASE							=			hidden_state
						SCREAMING_SNAKE_CASE							=			self.layer(lowerCamelCase__)
						SCREAMING_SNAKE_CASE							=			self.shortcut(lowerCamelCase__)
						hidden_state += residual
						SCREAMING_SNAKE_CASE							=			self.activation(lowerCamelCase__)
						return hidden_state



class 		_snake_case	(	nn.Module       ):






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







			def  SCREAMING_SNAKE_CASE__     (							self		,       a)   ->							Tuple:
						SCREAMING_SNAKE_CASE							=			hidden_state
						SCREAMING_SNAKE_CASE							=			self.layer(lowerCamelCase__)
						SCREAMING_SNAKE_CASE							=			self.shortcut(lowerCamelCase__)
						hidden_state += residual
						SCREAMING_SNAKE_CASE							=			self.activation(lowerCamelCase__)
						return hidden_state



class 		_snake_case	(	nn.Module       ):






			def __init__(							self		,       a		,       a		,       a		,       a = 2		,       a = 2		,       )   ->							Any:
						super().__init__()

						SCREAMING_SNAKE_CASE							=			ResNetBottleNeckLayer if config.layer_type == 'bottleneck' else ResNetBasicLayer

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







			def  SCREAMING_SNAKE_CASE__     (							self		,       a)   ->							Tensor:
						SCREAMING_SNAKE_CASE							=			input
						for layer in self.layers:
									SCREAMING_SNAKE_CASE							=			layer(lowerCamelCase__)
						return hidden_state



class 		_snake_case	(	nn.Module       ):






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







			def  SCREAMING_SNAKE_CASE__     (							self		,       a		,       a = False		,       a = True)   ->							BaseModelOutputWithNoAttention:
						SCREAMING_SNAKE_CASE							=			() if output_hidden_states else None

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

									SCREAMING_SNAKE_CASE							=			stage_module(lowerCamelCase__)

						if output_hidden_states:
									SCREAMING_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 BaseModelOutputWithNoAttention(
						    last_hidden_state=lowerCamelCase__		,       hidden_states=lowerCamelCase__		,       )



class 		_snake_case	(	A__       ):
			_lowercase		:     int        =				ResNetConfig
			_lowercase		:     Union[str, Any]        =				'''resnet'''
			_lowercase		:     str        =				'''pixel_values'''
			_lowercase		:     Any        =				True






			def  SCREAMING_SNAKE_CASE__     (							self		,       a)   ->							List[Any]:
						if isinstance(lowerCamelCase__		,       nn.Convad):
									nn.init.kaiming_normal_(module.weight		,       mode='fan_out'		,       nonlinearity='relu')
						elif isinstance(lowerCamelCase__		,       (nn.BatchNormad, nn.GroupNorm)):
									nn.init.constant_(module.weight		,       1)
									nn.init.constant_(module.bias		,       0)







			def  SCREAMING_SNAKE_CASE__     (							self		,       a		,       a=False)   ->							int:
						if isinstance(lowerCamelCase__		,       lowerCamelCase__):
									SCREAMING_SNAKE_CASE							=			value



a_		:    Optional[int]   							=     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'

a_		:    Optional[Any]   							=     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 		_snake_case	(	A__       ):






			def __init__(							self		,       a)   ->							Tuple:
						super().__init__(lowerCamelCase__)
						SCREAMING_SNAKE_CASE							=			config
						SCREAMING_SNAKE_CASE							=			ResNetEmbeddings(lowerCamelCase__)
						SCREAMING_SNAKE_CASE							=			ResNetEncoder(lowerCamelCase__)
						SCREAMING_SNAKE_CASE							=			nn.AdaptiveAvgPoolad((1, 1))
						# Initialize weights and apply final processing
						self.post_init()







			@add_start_docstrings_to_model_forward(lowerCamelCase__)
			@add_code_sample_docstrings(
			    checkpoint=_CHECKPOINT_FOR_DOC		,       output_type=lowerCamelCase__		,       config_class=_CONFIG_FOR_DOC		,       modality='vision'		,       expected_output=_EXPECTED_OUTPUT_SHAPE		,       )
			def  SCREAMING_SNAKE_CASE__     (							self		,       a		,       a = None		,       a = None)   ->							BaseModelOutputWithPoolingAndNoAttention:
						SCREAMING_SNAKE_CASE							=			(
						    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
						)
						SCREAMING_SNAKE_CASE							=			return_dict if return_dict is not None else self.config.use_return_dict

						SCREAMING_SNAKE_CASE							=			self.embedder(lowerCamelCase__)

						SCREAMING_SNAKE_CASE							=			self.encoder(
						    lowerCamelCase__		,       output_hidden_states=lowerCamelCase__		,       return_dict=lowerCamelCase__)

						SCREAMING_SNAKE_CASE							=			encoder_outputs[0]

						SCREAMING_SNAKE_CASE							=			self.pooler(lowerCamelCase__)

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

						return BaseModelOutputWithPoolingAndNoAttention(
						    last_hidden_state=lowerCamelCase__		,       pooler_output=lowerCamelCase__		,       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 		_snake_case	(	A__       ):






			def __init__(							self		,       a)   ->							Union[str, Any]:
						super().__init__(lowerCamelCase__)
						SCREAMING_SNAKE_CASE							=			config.num_labels
						SCREAMING_SNAKE_CASE							=			ResNetModel(lowerCamelCase__)
						# classification head
						SCREAMING_SNAKE_CASE							=			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(lowerCamelCase__)
			@add_code_sample_docstrings(
			    checkpoint=_IMAGE_CLASS_CHECKPOINT		,       output_type=lowerCamelCase__		,       config_class=_CONFIG_FOR_DOC		,       expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT		,       )
			def  SCREAMING_SNAKE_CASE__     (							self		,       a = None		,       a = None		,       a = None		,       a = None		,       )   ->							ImageClassifierOutputWithNoAttention:
						SCREAMING_SNAKE_CASE							=			return_dict if return_dict is not None else self.config.use_return_dict

						SCREAMING_SNAKE_CASE							=			self.resnet(lowerCamelCase__		,       output_hidden_states=lowerCamelCase__		,       return_dict=lowerCamelCase__)

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

						SCREAMING_SNAKE_CASE							=			self.classifier(lowerCamelCase__)

						SCREAMING_SNAKE_CASE							=			None

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

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

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



@add_start_docstrings(
    '''
    ResNet backbone, to be used with frameworks like DETR and MaskFormer.
    ''' ,     A__ ,     )
class 		_snake_case	(	A__ ,     A__       ):






			def __init__(							self		,       a)   ->							Any:
						super().__init__(lowerCamelCase__)
						super()._init_backbone(lowerCamelCase__)

						SCREAMING_SNAKE_CASE							=			[config.embedding_size] + config.hidden_sizes
						SCREAMING_SNAKE_CASE							=			ResNetEmbeddings(lowerCamelCase__)
						SCREAMING_SNAKE_CASE							=			ResNetEncoder(lowerCamelCase__)

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







			@add_start_docstrings_to_model_forward(lowerCamelCase__)
			@replace_return_docstrings(output_type=lowerCamelCase__		,       config_class=_CONFIG_FOR_DOC)
			def  SCREAMING_SNAKE_CASE__     (							self		,       a		,       a = None		,       a = None)   ->							BackboneOutput:
						SCREAMING_SNAKE_CASE							=			return_dict if return_dict is not None else self.config.use_return_dict
						SCREAMING_SNAKE_CASE							=			(
						    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
						)

						SCREAMING_SNAKE_CASE							=			self.embedder(lowerCamelCase__)

						SCREAMING_SNAKE_CASE							=			self.encoder(lowerCamelCase__		,       output_hidden_states=lowerCamelCase__		,       return_dict=lowerCamelCase__)

						SCREAMING_SNAKE_CASE							=			outputs.hidden_states

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

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

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










import importlib.metadata
import operator
import re
import sys
from typing import Optional

from packaging import version


__A								=       {
    "<": operator.lt,
    "<=": operator.le,
    "==": operator.eq,
    "!=": operator.ne,
    ">=": operator.ge,
    ">": operator.gt,
}







def      lowerCamelCase_						(			UpperCamelCase__							: List[str]					,	UpperCamelCase__							: Dict					,	UpperCamelCase__							: Dict					,	UpperCamelCase__							: Any					,	UpperCamelCase__							: Dict					,	UpperCamelCase__							: int )	->			List[Any]:





				"""simple docstring"""


				if got_ver is None or want_ver is None:
								raise ValueError(
								    F"""Unable to compare versions for {requirement}: need={want_ver} found={got_ver}. This is unusual. Consider"""
								    F""" reinstalling {pkg}.""" )
				if not ops[op](version.parse(UpperCamelCase__ )					,	version.parse(UpperCamelCase__ ) ):
								raise ImportError(
								    F"""{requirement} is required for a normal functioning of this module, but found {pkg}=={got_ver}.{hint}""" )







def      lowerCamelCase_						(			UpperCamelCase__							: str					,	UpperCamelCase__							: Optional[str] = None )	->			None:





				"""simple docstring"""


				__lowerCamelCase									=       F"""\n{hint}""" if hint is not None else ''

				# non-versioned check
				if re.match(R'^[\w_\-\d]+$'					,	UpperCamelCase__ ):
								__lowerCamelCase			,		__lowerCamelCase			,		__lowerCamelCase									=       requirement, None, None
				else:
								__lowerCamelCase									=       re.findall(R'^([^!=<>\s]+)([\s!=<>]{1,2}.+)'					,	UpperCamelCase__ )
								if not match:
												raise ValueError(
												    'requirement needs to be in the pip package format, .e.g., package_a==1.23, or package_b>=1.23, but'
												    F""" got {requirement}""" )
								__lowerCamelCase			,		__lowerCamelCase									=       match[0]
								__lowerCamelCase									=       want_full.split(',' )  # there could be multiple requirements
								__lowerCamelCase									=       {}
								for w in want_range:
												__lowerCamelCase									=       re.findall(R'^([\s!=<>]{1,2})(.+)'					,	UpperCamelCase__ )
												if not match:
																raise ValueError(
																    'requirement needs to be in the pip package format, .e.g., package_a==1.23, or package_b>=1.23,'
																    F""" but got {requirement}""" )
												__lowerCamelCase			,		__lowerCamelCase									=       match[0]
												__lowerCamelCase									=       want_ver
												if op not in ops:
																raise ValueError(F"""{requirement}: need one of {list(ops.keys() )}, but got {op}""" )

    # special case
				if pkg == "python":
								__lowerCamelCase									=       '.'.join([str(UpperCamelCase__ ) for x in sys.version_info[:3]] )
								for op, want_ver in wanted.items():
												_compare_versions(UpperCamelCase__					,	UpperCamelCase__					,	UpperCamelCase__					,	UpperCamelCase__					,	UpperCamelCase__					,	UpperCamelCase__ )
								return

				# check if any version is installed
				try:
								__lowerCamelCase									=       importlib.metadata.version(UpperCamelCase__ )
				except importlib.metadata.PackageNotFoundError:
								raise importlib.metadata.PackageNotFoundError(
								    F"""The '{requirement}' distribution was not found and is required by this application. {hint}""" )

				# check that the right version is installed if version number or a range was provided
				if want_ver is not None:
								for op, want_ver in wanted.items():
												_compare_versions(UpperCamelCase__					,	UpperCamelCase__					,	UpperCamelCase__					,	UpperCamelCase__					,	UpperCamelCase__					,	UpperCamelCase__ )







def      lowerCamelCase_						(			UpperCamelCase__							: Optional[int] )	->			Optional[int]:





				"""simple docstring"""


				__lowerCamelCase									=       'Try: pip install transformers -U or pip install -e \'.[dev]\' if you\'re working with git main'
				return require_version(UpperCamelCase__					,	UpperCamelCase__ )


