

'''simple docstring'''




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


lowerCAmelCase_							=	{
    '''configuration_nezha''': ['''NEZHA_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''NezhaConfig'''],
}

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				lowerCAmelCase_							=	[
				    '''NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST''',
				    '''NezhaForNextSentencePrediction''',
				    '''NezhaForMaskedLM''',
				    '''NezhaForPreTraining''',
				    '''NezhaForMultipleChoice''',
				    '''NezhaForQuestionAnswering''',
				    '''NezhaForSequenceClassification''',
				    '''NezhaForTokenClassification''',
				    '''NezhaModel''',
				    '''NezhaPreTrainedModel''',
				]


if TYPE_CHECKING:
				from .configuration_nezha import NEZHA_PRETRAINED_CONFIG_ARCHIVE_MAP, NezhaConfig

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_nezha import (
								    NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST,
								    NezhaForMaskedLM,
								    NezhaForMultipleChoice,
								    NezhaForNextSentencePrediction,
								    NezhaForPreTraining,
								    NezhaForQuestionAnswering,
								    NezhaForSequenceClassification,
								    NezhaForTokenClassification,
								    NezhaModel,
								    NezhaPreTrainedModel,
								)


else:
				import sys

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

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 ...file_utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward
from ...modeling_outputs import (
    BaseModelOutputWithNoAttention,
    BaseModelOutputWithPoolingAndNoAttention,
    ImageClassifierOutputWithNoAttention,
)
from ...modeling_utils import PreTrainedModel
from ...utils import logging
from .configuration_regnet import RegNetConfig


_lowercase:	Any       			=		logging.get_logger(__name__)

# General docstring
_lowercase:	List[Any]       			=		'''RegNetConfig'''

# Base docstring
_lowercase:	List[Any]       			=		'''facebook/regnet-y-040'''
_lowercase:	int       			=		[1, 1_0_8_8, 7, 7]

# Image classification docstring
_lowercase:	Union[str, Any]       			=		'''facebook/regnet-y-040'''
_lowercase:	Tuple       			=		'''tabby, tabby cat'''

_lowercase:	str       			=		[
    '''facebook/regnet-y-040''',
    # See all regnet models at https://huggingface.co/models?filter=regnet
]



class        lowerCamelCase__				(   nn.Module				):





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





			def   SCREAMING_SNAKE_CASE__     (       self	:	str  ,  lowercase__	:	Union[str, Any]						):
										_lowerCAmelCase							=							self.convolution(lowercase__						)
										_lowerCAmelCase							=							self.normalization(lowercase__						)
										_lowerCAmelCase							=							self.activation(lowercase__						)
										return hidden_state







class        lowerCamelCase__				(   nn.Module				):





			def __init__(       self	:	int  ,  lowercase__	:	RegNetConfig						):
										super().__init__()
										_lowerCAmelCase							=							RegNetConvLayer(
										    config.num_channels  ,  config.embedding_size  ,  kernel_size=3  ,  stride=2  ,  activation=config.hidden_act						)
										_lowerCAmelCase							=							config.num_channels





			def   SCREAMING_SNAKE_CASE__     (       self	:	Optional[Any]  ,  lowercase__	:	Optional[int]						):
										_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__						)
										return hidden_state







class        lowerCamelCase__				(   nn.Module				):





			def __init__(       self	:	Optional[Any]  ,  lowercase__	:	int  ,  lowercase__	:	int  ,  lowercase__	:	int = 2						):
										super().__init__()
										_lowerCAmelCase							=							nn.Convad(lowercase__  ,  lowercase__  ,  kernel_size=1  ,  stride=lowercase__  ,  bias=lowercase__						)
										_lowerCAmelCase							=							nn.BatchNormad(lowercase__						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	Tuple  ,  lowercase__	:	Tensor						):
										_lowerCAmelCase							=							self.convolution(lowercase__						)
										_lowerCAmelCase							=							self.normalization(lowercase__						)
										return hidden_state







class        lowerCamelCase__				(   nn.Module				):





			def __init__(       self	:	Optional[Any]  ,  lowercase__	:	int  ,  lowercase__	:	int						):
										super().__init__()

										_lowerCAmelCase							=							nn.AdaptiveAvgPoolad((1, 1)						)
										_lowerCAmelCase							=							nn.Sequential(
										    nn.Convad(lowercase__  ,  lowercase__  ,  kernel_size=1						)  ,  nn.ReLU()  ,  nn.Convad(lowercase__  ,  lowercase__  ,  kernel_size=1						)  ,  nn.Sigmoid()  ,  )





			def   SCREAMING_SNAKE_CASE__     (       self	:	Any  ,  lowercase__	:	List[Any]						):
										# b c h w -> b c 1 1
										_lowerCAmelCase							=							self.pooler(lowercase__						)
										_lowerCAmelCase							=							self.attention(lowercase__						)
										_lowerCAmelCase							=							hidden_state * attention
										return hidden_state







class        lowerCamelCase__				(   nn.Module				):





			def __init__(       self	:	Dict  ,  lowercase__	:	RegNetConfig  ,  lowercase__	:	int  ,  lowercase__	:	int  ,  lowercase__	:	int = 1						):
										super().__init__()
										_lowerCAmelCase							=							in_channels != out_channels or stride != 1
										_lowerCAmelCase							=							max(1  ,  out_channels // config.groups_width						)
										_lowerCAmelCase							=							(
										    RegNetShortCut(lowercase__  ,  lowercase__  ,  stride=lowercase__						) if should_apply_shortcut else nn.Identity()
										)
										_lowerCAmelCase							=							nn.Sequential(
										    RegNetConvLayer(lowercase__  ,  lowercase__  ,  kernel_size=1  ,  activation=config.hidden_act						)  ,  RegNetConvLayer(lowercase__  ,  lowercase__  ,  stride=lowercase__  ,  groups=lowercase__  ,  activation=config.hidden_act						)  ,  RegNetConvLayer(lowercase__  ,  lowercase__  ,  kernel_size=1  ,  activation=lowercase__						)  ,  )
										_lowerCAmelCase							=							ACTaFN[config.hidden_act]





			def   SCREAMING_SNAKE_CASE__     (       self	:	Dict  ,  lowercase__	:	Any						):
										_lowerCAmelCase							=							hidden_state
										_lowerCAmelCase							=							self.layer(lowercase__						)
										_lowerCAmelCase							=							self.shortcut(lowercase__						)
										hidden_state += residual
										_lowerCAmelCase							=							self.activation(lowercase__						)
										return hidden_state







class        lowerCamelCase__				(   nn.Module				):





			def __init__(       self	:	Any  ,  lowercase__	:	RegNetConfig  ,  lowercase__	:	int  ,  lowercase__	:	int  ,  lowercase__	:	int = 1						):
										super().__init__()
										_lowerCAmelCase							=							in_channels != out_channels or stride != 1
										_lowerCAmelCase							=							max(1  ,  out_channels // config.groups_width						)
										_lowerCAmelCase							=							(
										    RegNetShortCut(lowercase__  ,  lowercase__  ,  stride=lowercase__						) if should_apply_shortcut else nn.Identity()
										)
										_lowerCAmelCase							=							nn.Sequential(
										    RegNetConvLayer(lowercase__  ,  lowercase__  ,  kernel_size=1  ,  activation=config.hidden_act						)  ,  RegNetConvLayer(lowercase__  ,  lowercase__  ,  stride=lowercase__  ,  groups=lowercase__  ,  activation=config.hidden_act						)  ,  RegNetSELayer(lowercase__  ,  reduced_channels=int(round(in_channels / 4						)						)						)  ,  RegNetConvLayer(lowercase__  ,  lowercase__  ,  kernel_size=1  ,  activation=lowercase__						)  ,  )
										_lowerCAmelCase							=							ACTaFN[config.hidden_act]





			def   SCREAMING_SNAKE_CASE__     (       self	:	Optional[int]  ,  lowercase__	:	Tuple						):
										_lowerCAmelCase							=							hidden_state
										_lowerCAmelCase							=							self.layer(lowercase__						)
										_lowerCAmelCase							=							self.shortcut(lowercase__						)
										hidden_state += residual
										_lowerCAmelCase							=							self.activation(lowercase__						)
										return hidden_state







class        lowerCamelCase__				(   nn.Module				):





			def __init__(       self	:	Dict  ,  lowercase__	:	RegNetConfig  ,  lowercase__	:	int  ,  lowercase__	:	int  ,  lowercase__	:	int = 2  ,  lowercase__	:	int = 2  ,  ):
										super().__init__()

										_lowerCAmelCase							=							RegNetXLayer if config.layer_type == 'x' else RegNetYLayer

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





			def   SCREAMING_SNAKE_CASE__     (       self	:	Tuple  ,  lowercase__	:	Any						):
										_lowerCAmelCase							=							self.layers(lowercase__						)
										return hidden_state







class        lowerCamelCase__				(   nn.Module				):





			def __init__(       self	:	Dict  ,  lowercase__	:	RegNetConfig						):
										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(
										    RegNetStage(
										        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(RegNetStage(lowercase__  ,  lowercase__  ,  lowercase__  ,  depth=lowercase__						)						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	List[str]  ,  lowercase__	:	Tensor  ,  lowercase__	:	bool = False  ,  lowercase__	:	bool = True						):
										_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        lowerCamelCase__				(   UpperCAmelCase				):
			UpperCamelCase__    							=RegNetConfig
			UpperCamelCase__    							="regnet"
			UpperCamelCase__    							="pixel_values"
			UpperCamelCase__    							=True





			def   SCREAMING_SNAKE_CASE__     (       self	:	Optional[int]  ,  lowercase__	:	List[Any]						):
										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	:	Any  ,  lowercase__	:	List[str]  ,  lowercase__	:	List[Any]=False						):
										if isinstance(lowercase__  ,  lowercase__						):
																	_lowerCAmelCase							=							value







_lowercase:	Optional[Any]       			=		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 ([`RegNetConfig`]): 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.
'''

_lowercase:	str       			=		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 [`~file_utils.ModelOutput`] instead of a plain tuple.
'''



@add_start_docstrings(
    "The bare RegNet model outputting raw features without any specific head on top."       ,UpperCAmelCase       ,)
# Copied from transformers.models.resnet.modeling_resnet.ResNetModel with RESNET->REGNET,ResNet->RegNet
class        lowerCamelCase__				(   UpperCAmelCase				):





			def __init__(       self	:	List[str]  ,  lowercase__	:	int						):
										super().__init__(lowercase__						)
										_lowerCAmelCase							=							config
										_lowerCAmelCase							=							RegNetEmbeddings(lowercase__						)
										_lowerCAmelCase							=							RegNetEncoder(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	:	Any  ,  lowercase__	:	Tensor  ,  lowercase__	:	Optional[bool] = None  ,  lowercase__	:	Optional[bool] = None						):
										_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    RegNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for\n    ImageNet.\n    "       ,UpperCAmelCase       ,)
# Copied from transformers.models.resnet.modeling_resnet.ResNetForImageClassification with RESNET->REGNET,ResNet->RegNet,resnet->regnet
class        lowerCamelCase__				(   UpperCAmelCase				):





			def __init__(       self	:	str  ,  lowercase__	:	Union[str, Any]						):
										super().__init__(lowercase__						)
										_lowerCAmelCase							=							config.num_labels
										_lowerCAmelCase							=							RegNetModel(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	:	int  ,  lowercase__	:	Optional[torch.FloatTensor] = None  ,  lowercase__	:	Optional[torch.LongTensor] = None  ,  lowercase__	:	Optional[bool] = None  ,  lowercase__	:	Optional[bool] = None  ,  ):
										_lowerCAmelCase							=							return_dict if return_dict is not None else self.config.use_return_dict

										_lowerCAmelCase							=							self.regnet(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						)






