
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


_A   =     logging.get_logger(__name__)

# General docstring
_A   =     'RegNetConfig'

# Base docstring
_A   =     'facebook/regnet-y-040'
_A   =     [1, 10_88, 7, 7]

# Image classification docstring
_A   =     'facebook/regnet-y-040'
_A   =     'tabby, tabby cat'

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





class 	_lowerCAmelCase					(	nn.Module       ):




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




				def      __a						(					self				,				_UpperCamelCase     )				->      Any:
							lowerCAmelCase_						=	self.convolution(_SCREAMING_SNAKE_CASE     )
							lowerCAmelCase_						=	self.normalization(_SCREAMING_SNAKE_CASE     )
							lowerCAmelCase_						=	self.activation(_SCREAMING_SNAKE_CASE     )
							return hidden_state





class 	_lowerCAmelCase					(	nn.Module       ):




				def __init__(					self				,				_UpperCamelCase     )				->      Dict:
							super().__init__()
							lowerCAmelCase_						=	RegNetConvLayer(
							    config.num_channels				,				config.embedding_size				,				kernel_size=3				,				stride=2				,				activation=config.hidden_act     )
							lowerCAmelCase_						=	config.num_channels




				def      __a						(					self				,				_UpperCamelCase     )				->      Any:
							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(_SCREAMING_SNAKE_CASE     )
							return hidden_state





class 	_lowerCAmelCase					(	nn.Module       ):




				def __init__(					self				,				_UpperCamelCase				,				_UpperCamelCase				,				_UpperCamelCase = 2     )				->      Any:
							super().__init__()
							lowerCAmelCase_						=	nn.Convad(_SCREAMING_SNAKE_CASE				,				_SCREAMING_SNAKE_CASE				,				kernel_size=1				,				stride=_SCREAMING_SNAKE_CASE				,				bias=_SCREAMING_SNAKE_CASE     )
							lowerCAmelCase_						=	nn.BatchNormad(_SCREAMING_SNAKE_CASE     )




				def      __a						(					self				,				_UpperCamelCase     )				->      Tensor:
							lowerCAmelCase_						=	self.convolution(_SCREAMING_SNAKE_CASE     )
							lowerCAmelCase_						=	self.normalization(_SCREAMING_SNAKE_CASE     )
							return hidden_state





class 	_lowerCAmelCase					(	nn.Module       ):




				def __init__(					self				,				_UpperCamelCase				,				_UpperCamelCase     )				->      Union[str, Any]:
							super().__init__()

							lowerCAmelCase_						=	nn.AdaptiveAvgPoolad((1, 1)     )
							lowerCAmelCase_						=	nn.Sequential(
							    nn.Convad(_SCREAMING_SNAKE_CASE				,				_SCREAMING_SNAKE_CASE				,				kernel_size=1     )				,				nn.ReLU()				,				nn.Convad(_SCREAMING_SNAKE_CASE				,				_SCREAMING_SNAKE_CASE				,				kernel_size=1     )				,				nn.Sigmoid()				,				)




				def      __a						(					self				,				_UpperCamelCase     )				->      Union[str, Any]:
							lowerCAmelCase_						=	self.pooler(_SCREAMING_SNAKE_CASE     )
							lowerCAmelCase_						=	self.attention(_SCREAMING_SNAKE_CASE     )
							lowerCAmelCase_						=	hidden_state * attention
							return hidden_state





class 	_lowerCAmelCase					(	nn.Module       ):




				def __init__(					self				,				_UpperCamelCase				,				_UpperCamelCase				,				_UpperCamelCase				,				_UpperCamelCase = 1     )				->      List[Any]:
							super().__init__()
							lowerCAmelCase_						=	in_channels != out_channels or stride != 1
							lowerCAmelCase_						=	max(1				,				out_channels // config.groups_width     )
							lowerCAmelCase_						=	(
							    RegNetShortCut(_SCREAMING_SNAKE_CASE				,				_SCREAMING_SNAKE_CASE				,				stride=_SCREAMING_SNAKE_CASE     ) if should_apply_shortcut else nn.Identity()
							)
							lowerCAmelCase_						=	nn.Sequential(
							    RegNetConvLayer(_SCREAMING_SNAKE_CASE				,				_SCREAMING_SNAKE_CASE				,				kernel_size=1				,				activation=config.hidden_act     )				,				RegNetConvLayer(_SCREAMING_SNAKE_CASE				,				_SCREAMING_SNAKE_CASE				,				stride=_SCREAMING_SNAKE_CASE				,				groups=_SCREAMING_SNAKE_CASE				,				activation=config.hidden_act     )				,				RegNetConvLayer(_SCREAMING_SNAKE_CASE				,				_SCREAMING_SNAKE_CASE				,				kernel_size=1				,				activation=_SCREAMING_SNAKE_CASE     )				,				)
							lowerCAmelCase_						=	ACTaFN[config.hidden_act]




				def      __a						(					self				,				_UpperCamelCase     )				->      List[Any]:
							lowerCAmelCase_						=	hidden_state
							lowerCAmelCase_						=	self.layer(_SCREAMING_SNAKE_CASE     )
							lowerCAmelCase_						=	self.shortcut(_SCREAMING_SNAKE_CASE     )
							hidden_state += residual
							lowerCAmelCase_						=	self.activation(_SCREAMING_SNAKE_CASE     )
							return hidden_state





class 	_lowerCAmelCase					(	nn.Module       ):




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




				def      __a						(					self				,				_UpperCamelCase     )				->      List[Any]:
							lowerCAmelCase_						=	hidden_state
							lowerCAmelCase_						=	self.layer(_SCREAMING_SNAKE_CASE     )
							lowerCAmelCase_						=	self.shortcut(_SCREAMING_SNAKE_CASE     )
							hidden_state += residual
							lowerCAmelCase_						=	self.activation(_SCREAMING_SNAKE_CASE     )
							return hidden_state





class 	_lowerCAmelCase					(	nn.Module       ):




				def __init__(					self				,				_UpperCamelCase				,				_UpperCamelCase				,				_UpperCamelCase				,				_UpperCamelCase = 2				,				_UpperCamelCase = 2				,				)				->      Union[str, Any]:
							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(
							        _SCREAMING_SNAKE_CASE				,				_SCREAMING_SNAKE_CASE				,				_SCREAMING_SNAKE_CASE				,				stride=_SCREAMING_SNAKE_CASE				,				)				,				*[layer(_SCREAMING_SNAKE_CASE				,				_SCREAMING_SNAKE_CASE				,				_SCREAMING_SNAKE_CASE     ) for _ in range(depth - 1     )]				,				)




				def      __a						(					self				,				_UpperCamelCase     )				->      Any:
							lowerCAmelCase_						=	self.layers(_SCREAMING_SNAKE_CASE     )
							return hidden_state





class 	_lowerCAmelCase					(	nn.Module       ):




				def __init__(					self				,				_UpperCamelCase     )				->      Union[str, Any]:
							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(
							        _SCREAMING_SNAKE_CASE				,				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(_SCREAMING_SNAKE_CASE				,				config.depths[1:]     ):
										self.stages.append(RegNetStage(_SCREAMING_SNAKE_CASE				,				_SCREAMING_SNAKE_CASE				,				_SCREAMING_SNAKE_CASE				,				depth=_SCREAMING_SNAKE_CASE     )     )




				def      __a						(					self				,				_UpperCamelCase				,				_UpperCamelCase = False				,				_UpperCamelCase = True     )				->      BaseModelOutputWithNoAttention:
							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(_SCREAMING_SNAKE_CASE     )

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





class 	_lowerCAmelCase					(	__SCREAMING_SNAKE_CASE       ):
				_lowercase					=RegNetConfig
				_lowercase					='''regnet'''
				_lowercase					='''pixel_values'''
				_lowercase					=True




				def      __a						(					self				,				_UpperCamelCase     )				->      List[str]:

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




				def      __a						(					self				,				_UpperCamelCase				,				_UpperCamelCase=False     )				->      Optional[int]:

							if isinstance(_SCREAMING_SNAKE_CASE				,				_SCREAMING_SNAKE_CASE     ):
										lowerCAmelCase_						=	value


_A   =     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 ([`RegNetConfig`]): 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   =     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 [`~file_utils.ModelOutput`] instead of a plain tuple.\n'





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




				def __init__(					self				,				_UpperCamelCase     )				->      List[Any]:
							super().__init__(_SCREAMING_SNAKE_CASE     )
							lowerCAmelCase_						=	config
							lowerCAmelCase_						=	RegNetEmbeddings(_SCREAMING_SNAKE_CASE     )
							lowerCAmelCase_						=	RegNetEncoder(_SCREAMING_SNAKE_CASE     )
							lowerCAmelCase_						=	nn.AdaptiveAvgPoolad((1, 1)     )
							# Initialize weights and apply final processing
							self.post_init()




				@add_start_docstrings_to_model_forward(_SCREAMING_SNAKE_CASE     )
				@add_code_sample_docstrings(
				    checkpoint=_CHECKPOINT_FOR_DOC				,				output_type=_SCREAMING_SNAKE_CASE				,				config_class=_CONFIG_FOR_DOC				,				modality="vision"				,				expected_output=_EXPECTED_OUTPUT_SHAPE				,				)
				def      __a						(					self				,				_UpperCamelCase				,				_UpperCamelCase = None				,				_UpperCamelCase = None     )				->      BaseModelOutputWithPoolingAndNoAttention:
							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(_SCREAMING_SNAKE_CASE     )

							lowerCAmelCase_						=	self.encoder(
							    _SCREAMING_SNAKE_CASE				,				output_hidden_states=_SCREAMING_SNAKE_CASE				,				return_dict=_SCREAMING_SNAKE_CASE     )

							lowerCAmelCase_						=	encoder_outputs[0]

							lowerCAmelCase_						=	self.pooler(_SCREAMING_SNAKE_CASE     )

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

							return BaseModelOutputWithPoolingAndNoAttention(
							    last_hidden_state=_SCREAMING_SNAKE_CASE				,				pooler_output=_SCREAMING_SNAKE_CASE				,				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    '''					,      __SCREAMING_SNAKE_CASE					,      )
# Copied from transformers.models.resnet.modeling_resnet.ResNetForImageClassification with RESNET->REGNET,ResNet->RegNet,resnet->regnet
class 	_lowerCAmelCase					(	__SCREAMING_SNAKE_CASE       ):




				def __init__(					self				,				_UpperCamelCase     )				->      Dict:
							super().__init__(_SCREAMING_SNAKE_CASE     )
							lowerCAmelCase_						=	config.num_labels
							lowerCAmelCase_						=	RegNetModel(_SCREAMING_SNAKE_CASE     )
							# 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(_SCREAMING_SNAKE_CASE     )
				@add_code_sample_docstrings(
				    checkpoint=_IMAGE_CLASS_CHECKPOINT				,				output_type=_SCREAMING_SNAKE_CASE				,				config_class=_CONFIG_FOR_DOC				,				expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT				,				)
				def      __a						(					self				,				_UpperCamelCase = None				,				_UpperCamelCase = None				,				_UpperCamelCase = None				,				_UpperCamelCase = None				,				)				->      ImageClassifierOutputWithNoAttention:
							lowerCAmelCase_						=	return_dict if return_dict is not None else self.config.use_return_dict

							lowerCAmelCase_						=	self.regnet(_SCREAMING_SNAKE_CASE				,				output_hidden_states=_SCREAMING_SNAKE_CASE				,				return_dict=_SCREAMING_SNAKE_CASE     )

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

							lowerCAmelCase_						=	self.classifier(_SCREAMING_SNAKE_CASE     )

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

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

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








"""simple docstring"""






import os
import unittest

from transformers import FunnelTokenizer, FunnelTokenizerFast
from transformers.models.funnel.tokenization_funnel import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin



@require_tokenizers
class 			A__   (  __SCREAMING_SNAKE_CASE  ,		unittest.TestCase							):




	'''simple docstring'''





	SCREAMING_SNAKE_CASE          =	FunnelTokenizer
	SCREAMING_SNAKE_CASE          =	FunnelTokenizerFast
	SCREAMING_SNAKE_CASE          =	True
	SCREAMING_SNAKE_CASE          =	True

	def 							_SCREAMING_SNAKE_CASE   (     self:		Tuple)				->       Optional[int]:

				"""simple docstring"""

				super().setUp()

				__lowerCAmelCase      :  str												=       [
				    "<unk>",
				    "<cls>",
				    "<sep>",
				    "want",
				    "##want",
				    "##ed",
				    "wa",
				    "un",
				    "runn",
				    "##ing",
				    ",",
				    "low",
				    "lowest",
				]
				__lowerCAmelCase      :  int												=       os.path.join(self.tmpdirname       ,			VOCAB_FILES_NAMES["vocab_file"])
				with open(self.vocab_file       ,			"w"       ,			encoding="utf-8") as vocab_writer:
							vocab_writer.write("".join([x + "\n" for x in vocab_tokens]))

	def 							_SCREAMING_SNAKE_CASE   (     self:		Optional[Any]       ,			**_SCREAMING_SNAKE_CASE:		Union[str, Any])				->       int:

				"""simple docstring"""

				return FunnelTokenizer.from_pretrained(self.tmpdirname       ,			**_SCREAMING_SNAKE_CASE)

	def 							_SCREAMING_SNAKE_CASE   (     self:		Any       ,			**_SCREAMING_SNAKE_CASE:		Any)				->       str:

				"""simple docstring"""

				return FunnelTokenizerFast.from_pretrained(self.tmpdirname       ,			**_SCREAMING_SNAKE_CASE)

	def 							_SCREAMING_SNAKE_CASE   (     self:		Tuple       ,			_SCREAMING_SNAKE_CASE:		str)				->       Any:

				"""simple docstring"""

				__lowerCAmelCase      :  Union[str, Any]												=       "UNwant\u00E9d,running"
				__lowerCAmelCase      :  str												=       "unwanted, running"
				return input_text, output_text

	def 							_SCREAMING_SNAKE_CASE   (     self:		Optional[int])				->       List[str]:

				"""simple docstring"""

				__lowerCAmelCase      :  Any												=       self.tokenizer_class(self.vocab_file)

				__lowerCAmelCase      :  Any												=       tokenizer.tokenize("UNwant\u00E9d,running")
				self.assertListEqual(_SCREAMING_SNAKE_CASE       ,			["un", "##want", "##ed", ",", "runn", "##ing"])
				self.assertListEqual(tokenizer.convert_tokens_to_ids(_SCREAMING_SNAKE_CASE)       ,			[7, 4, 5, 10, 8, 9])







	def 							_SCREAMING_SNAKE_CASE   (     self:		List[str])				->       List[str]:

				"""simple docstring"""

				__lowerCAmelCase      :  Optional[Any]												=       self.get_tokenizers(do_lower_case=_SCREAMING_SNAKE_CASE)
				for tokenizer in tokenizers:
							__lowerCAmelCase      :  List[str]												=       tokenizer("UNwant\u00E9d,running")
							__lowerCAmelCase      :  Optional[int]												=       len(inputs["input_ids"]) - 1
							self.assertListEqual(inputs["token_type_ids"]       ,			[2] + [0] * sentence_len)

							__lowerCAmelCase      :  List[str]												=       tokenizer("UNwant\u00E9d,running"       ,			"UNwant\u00E9d,running")
							self.assertListEqual(inputs["token_type_ids"]       ,			[2] + [0] * sentence_len + [1] * sentence_len)