






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, 2048, 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      lowercase__     (			nn.Module	):

	def __init__(							self		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase = 3		,    __UpperCAmelCase = 1		,    __UpperCAmelCase = "relu"       )->					int:







							'''simple docstring'''





							super().__init__()
							lowerCAmelCase__       =						nn.Convad(
							    __UpperCAmelCase		,    __UpperCAmelCase		,    kernel_size=__UpperCAmelCase		,    stride=__UpperCAmelCase		,    padding=kernel_size // 2		,    bias=__UpperCAmelCase       )
							lowerCAmelCase__       =						nn.BatchNormad(__UpperCAmelCase       )
							lowerCAmelCase__       =						ACTaFN[activation] if activation is not None else nn.Identity()


	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase       )->					Tensor:







							'''simple docstring'''





							lowerCAmelCase__       =						self.convolution(__UpperCAmelCase       )
							lowerCAmelCase__       =						self.normalization(__UpperCAmelCase       )
							lowerCAmelCase__       =						self.activation(__UpperCAmelCase       )
							return hidden_state





class      lowercase__     (			nn.Module	):

	def __init__(							self		,    __UpperCAmelCase       )->					int:







							'''simple docstring'''





							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 		UpperCAmelCase  (							self		,    __UpperCAmelCase       )->					Tensor:







							'''simple docstring'''





							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(__UpperCAmelCase       )
							lowerCAmelCase__       =						self.pooler(__UpperCAmelCase       )
							return embedding





class      lowercase__     (			nn.Module	):

	def __init__(							self		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase = 2       )->					Tuple:







							'''simple docstring'''





							super().__init__()
							lowerCAmelCase__       =						nn.Convad(__UpperCAmelCase		,    __UpperCAmelCase		,    kernel_size=1		,    stride=__UpperCAmelCase		,    bias=__UpperCAmelCase       )
							lowerCAmelCase__       =						nn.BatchNormad(__UpperCAmelCase       )


	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase       )->					Tensor:







							'''simple docstring'''





							lowerCAmelCase__       =						self.convolution(__UpperCAmelCase       )
							lowerCAmelCase__       =						self.normalization(__UpperCAmelCase       )
							return hidden_state





class      lowercase__     (			nn.Module	):

	def __init__(							self		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase = 1		,    __UpperCAmelCase = "relu"       )->					str:







							'''simple docstring'''





							super().__init__()
							lowerCAmelCase__       =						in_channels != out_channels or stride != 1
							lowerCAmelCase__       =						(
							    ResNetShortCut(__UpperCAmelCase		,    __UpperCAmelCase		,    stride=__UpperCAmelCase       ) if should_apply_shortcut else nn.Identity()
							)
							lowerCAmelCase__       =						nn.Sequential(
							    ResNetConvLayer(__UpperCAmelCase		,    __UpperCAmelCase		,    stride=__UpperCAmelCase       )		,    ResNetConvLayer(__UpperCAmelCase		,    __UpperCAmelCase		,    activation=__UpperCAmelCase       )		,    )
							lowerCAmelCase__       =						ACTaFN[activation]


	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase       )->					Optional[int]:







							'''simple docstring'''





							lowerCAmelCase__       =						hidden_state
							lowerCAmelCase__       =						self.layer(__UpperCAmelCase       )
							lowerCAmelCase__       =						self.shortcut(__UpperCAmelCase       )
							hidden_state += residual
							lowerCAmelCase__       =						self.activation(__UpperCAmelCase       )
							return hidden_state





class      lowercase__     (			nn.Module	):

	def __init__(							self		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase = 1		,    __UpperCAmelCase = "relu"		,    __UpperCAmelCase = 4       )->					Tuple:







							'''simple docstring'''





							super().__init__()
							lowerCAmelCase__       =						in_channels != out_channels or stride != 1
							lowerCAmelCase__       =						out_channels // reduction
							lowerCAmelCase__       =						(
							    ResNetShortCut(__UpperCAmelCase		,    __UpperCAmelCase		,    stride=__UpperCAmelCase       ) if should_apply_shortcut else nn.Identity()
							)
							lowerCAmelCase__       =						nn.Sequential(
							    ResNetConvLayer(__UpperCAmelCase		,    __UpperCAmelCase		,    kernel_size=1       )		,    ResNetConvLayer(__UpperCAmelCase		,    __UpperCAmelCase		,    stride=__UpperCAmelCase       )		,    ResNetConvLayer(__UpperCAmelCase		,    __UpperCAmelCase		,    kernel_size=1		,    activation=__UpperCAmelCase       )		,    )
							lowerCAmelCase__       =						ACTaFN[activation]


	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase       )->					Dict:







							'''simple docstring'''





							lowerCAmelCase__       =						hidden_state
							lowerCAmelCase__       =						self.layer(__UpperCAmelCase       )
							lowerCAmelCase__       =						self.shortcut(__UpperCAmelCase       )
							hidden_state += residual
							lowerCAmelCase__       =						self.activation(__UpperCAmelCase       )
							return hidden_state





class      lowercase__     (			nn.Module	):

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







							'''simple docstring'''





							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(__UpperCAmelCase		,    __UpperCAmelCase		,    stride=__UpperCAmelCase		,    activation=config.hidden_act       )		,    *[layer(__UpperCAmelCase		,    __UpperCAmelCase		,    activation=config.hidden_act       ) for _ in range(depth - 1       )]		,    )


	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase       )->					Tensor:







							'''simple docstring'''





							lowerCAmelCase__       =						input
							for layer in self.layers:
													lowerCAmelCase__       =						layer(__UpperCAmelCase       )
							return hidden_state





class      lowercase__     (			nn.Module	):

	def __init__(							self		,    __UpperCAmelCase       )->					str:







							'''simple docstring'''





							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(
							        __UpperCAmelCase		,    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(__UpperCAmelCase		,    config.depths[1:]       ):
													self.stages.append(ResNetStage(__UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    depth=__UpperCAmelCase       )       )


	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase		,    __UpperCAmelCase = False		,    __UpperCAmelCase = True       )->					BaseModelOutputWithNoAttention:







							'''simple docstring'''





							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(__UpperCAmelCase       )

							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=__UpperCAmelCase		,    hidden_states=__UpperCAmelCase		,    )





class      lowercase__     (			_UpperCAmelCase	):
	a_         =ResNetConfig
	a_         ="""resnet"""
	a_         ="""pixel_values"""
	a_         =True

	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase       )->					Union[str, Any]:







							'''simple docstring'''





							if isinstance(__UpperCAmelCase		,    nn.Convad       ):
													nn.init.kaiming_normal_(module.weight		,    mode="fan_out"		,    nonlinearity="relu"       )
							elif isinstance(__UpperCAmelCase		,    (nn.BatchNormad, nn.GroupNorm)       ):
													nn.init.constant_(module.weight		,    1       )
													nn.init.constant_(module.bias		,    0       )


	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase		,    __UpperCAmelCase=False       )->					Tuple:







							'''simple docstring'''





							if isinstance(__UpperCAmelCase		,    __UpperCAmelCase       ):
													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.""",					_UpperCAmelCase,					)
class      lowercase__     (			_UpperCAmelCase	):

	def __init__(							self		,    __UpperCAmelCase       )->					List[str]:







							'''simple docstring'''





							super().__init__(__UpperCAmelCase       )
							lowerCAmelCase__       =						config
							lowerCAmelCase__       =						ResNetEmbeddings(__UpperCAmelCase       )
							lowerCAmelCase__       =						ResNetEncoder(__UpperCAmelCase       )
							lowerCAmelCase__       =						nn.AdaptiveAvgPoolad((1, 1)       )
							# Initialize weights and apply final processing
							self.post_init()


	@add_start_docstrings_to_model_forward(__UpperCAmelCase       )
	@add_code_sample_docstrings(
	    checkpoint=_CHECKPOINT_FOR_DOC		,    output_type=__UpperCAmelCase		,    config_class=_CONFIG_FOR_DOC		,    modality="vision"		,    expected_output=_EXPECTED_OUTPUT_SHAPE		,    )
	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase		,    __UpperCAmelCase = None		,    __UpperCAmelCase = None       )->					BaseModelOutputWithPoolingAndNoAttention:







							'''simple docstring'''





							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(__UpperCAmelCase       )

							lowerCAmelCase__       =						self.encoder(
							    __UpperCAmelCase		,    output_hidden_states=__UpperCAmelCase		,    return_dict=__UpperCAmelCase       )

							lowerCAmelCase__       =						encoder_outputs[0]

							lowerCAmelCase__       =						self.pooler(__UpperCAmelCase       )

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

							return BaseModelOutputWithPoolingAndNoAttention(
							    last_hidden_state=__UpperCAmelCase		,    pooler_output=__UpperCAmelCase		,    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.
    """,					_UpperCAmelCase,					)
class      lowercase__     (			_UpperCAmelCase	):

	def __init__(							self		,    __UpperCAmelCase       )->					int:







							'''simple docstring'''





							super().__init__(__UpperCAmelCase       )
							lowerCAmelCase__       =						config.num_labels
							lowerCAmelCase__       =						ResNetModel(__UpperCAmelCase       )
							# 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(__UpperCAmelCase       )
	@add_code_sample_docstrings(
	    checkpoint=_IMAGE_CLASS_CHECKPOINT		,    output_type=__UpperCAmelCase		,    config_class=_CONFIG_FOR_DOC		,    expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT		,    )
	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase = None		,    __UpperCAmelCase = None		,    __UpperCAmelCase = None		,    __UpperCAmelCase = None		,    )->					ImageClassifierOutputWithNoAttention:







							'''simple docstring'''





							lowerCAmelCase__       =						return_dict if return_dict is not None else self.config.use_return_dict

							lowerCAmelCase__       =						self.resnet(__UpperCAmelCase		,    output_hidden_states=__UpperCAmelCase		,    return_dict=__UpperCAmelCase       )

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

							lowerCAmelCase__       =						self.classifier(__UpperCAmelCase       )

							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(__UpperCAmelCase		,    __UpperCAmelCase       )
													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(__UpperCAmelCase		,    __UpperCAmelCase       )

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

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





@add_start_docstrings(
    """
    ResNet backbone, to be used with frameworks like DETR and MaskFormer.
    """,					_UpperCAmelCase,					)
class      lowercase__     (			_UpperCAmelCase,					_UpperCAmelCase	):

	def __init__(							self		,    __UpperCAmelCase       )->					Optional[int]:







							'''simple docstring'''





							super().__init__(__UpperCAmelCase       )
							super()._init_backbone(__UpperCAmelCase       )

							lowerCAmelCase__       =						[config.embedding_size] + config.hidden_sizes
							lowerCAmelCase__       =						ResNetEmbeddings(__UpperCAmelCase       )
							lowerCAmelCase__       =						ResNetEncoder(__UpperCAmelCase       )

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


	@add_start_docstrings_to_model_forward(__UpperCAmelCase       )
	@replace_return_docstrings(output_type=__UpperCAmelCase		,    config_class=_CONFIG_FOR_DOC       )
	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase		,    __UpperCAmelCase = None		,    __UpperCAmelCase = None       )->					BackboneOutput:







							'''simple docstring'''





							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(__UpperCAmelCase       )

							lowerCAmelCase__       =						self.encoder(__UpperCAmelCase		,    output_hidden_states=__UpperCAmelCase		,    return_dict=__UpperCAmelCase       )

							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=__UpperCAmelCase		,    hidden_states=outputs.hidden_states if output_hidden_states else None		,    attentions=__UpperCAmelCase		,    )














from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


a_							=    {'''configuration_ibert''': ['''IBERT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''IBertConfig''', '''IBertOnnxConfig''']}

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	a_							=    [
	    '''IBERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
	    '''IBertForMaskedLM''',
	    '''IBertForMultipleChoice''',
	    '''IBertForQuestionAnswering''',
	    '''IBertForSequenceClassification''',
	    '''IBertForTokenClassification''',
	    '''IBertModel''',
	    '''IBertPreTrainedModel''',
	]

if TYPE_CHECKING:
	from .configuration_ibert import IBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, IBertConfig, IBertOnnxConfig

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_ibert import (
		    IBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
		    IBertForMaskedLM,
		    IBertForMultipleChoice,
		    IBertForQuestionAnswering,
		    IBertForSequenceClassification,
		    IBertForTokenClassification,
		    IBertModel,
		    IBertPreTrainedModel,
		)

else:
	import sys

	a_							=    _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)






