

'''simple docstring'''


import copy
import inspect
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

from transformers import VideoMAEConfig
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
						import torch
						from torch import nn

						from transformers import (
						    MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING,
						    VideoMAEForPreTraining,
						    VideoMAEForVideoClassification,
						    VideoMAEModel,
						)
						from transformers.models.videomae.modeling_videomae import VIDEOMAE_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
						from transformers import VideoMAEImageProcessor



class 					lowercase						:


							def __init__(			self    ,			_snake_case    ,			_snake_case=13    ,			_snake_case=10    ,			_snake_case=3    ,			_snake_case=2    ,			_snake_case=2    ,			_snake_case=2    ,			_snake_case=True    ,			_snake_case=True    ,			_snake_case=32    ,			_snake_case=5    ,			_snake_case=4    ,			_snake_case=37    ,			_snake_case="gelu"    ,			_snake_case=0.1    ,			_snake_case=0.1    ,			_snake_case=10    ,			_snake_case=0.02    ,			_snake_case=0.9    ,			_snake_case=None    ,			)							->				Optional[Any]:
								UpperCAmelCase_		:      int       	=					parent
								UpperCAmelCase_		:      List[str]       	=					batch_size
								UpperCAmelCase_		:      Optional[Any]       	=					image_size
								UpperCAmelCase_		:      Union[str, Any]       	=					num_channels
								UpperCAmelCase_		:      Optional[int]       	=					patch_size
								UpperCAmelCase_		:      Optional[int]       	=					tubelet_size
								UpperCAmelCase_		:      Union[str, Any]       	=					num_frames
								UpperCAmelCase_		:      List[Any]       	=					is_training
								UpperCAmelCase_		:      List[str]       	=					use_labels
								UpperCAmelCase_		:      Optional[int]       	=					hidden_size
								UpperCAmelCase_		:      List[str]       	=					num_hidden_layers
								UpperCAmelCase_		:      Tuple       	=					num_attention_heads
								UpperCAmelCase_		:      Optional[Any]       	=					intermediate_size
								UpperCAmelCase_		:      Union[str, Any]       	=					hidden_act
								UpperCAmelCase_		:      Dict       	=					hidden_dropout_prob
								UpperCAmelCase_		:      int       	=					attention_probs_dropout_prob
								UpperCAmelCase_		:      str       	=					type_sequence_label_size
								UpperCAmelCase_		:      Optional[Any]       	=					initializer_range
								UpperCAmelCase_		:      Dict       	=					mask_ratio
								UpperCAmelCase_		:      Dict       	=					scope

								# in VideoMAE, the number of tokens equals num_frames/tubelet_size * num_patches per frame
								UpperCAmelCase_		:      List[str]       	=					(image_size // patch_size) ** 2
								UpperCAmelCase_		:      Tuple       	=					(num_frames // tubelet_size) * self.num_patches_per_frame

								# use this variable to define bool_masked_pos
								UpperCAmelCase_		:      Optional[int]       	=					int(mask_ratio * self.seq_length)


							def 						_snake_case							(			self)							->				Tuple:
								UpperCAmelCase_		:      List[str]       	=					floats_tensor(
								    [self.batch_size, self.num_frames, self.num_channels, self.image_size, self.image_size])

								UpperCAmelCase_		:      List[str]       	=					None
								if self.use_labels:
									UpperCAmelCase_		:      Any       	=					ids_tensor([self.batch_size]    ,			self.type_sequence_label_size)

								UpperCAmelCase_		:      Dict       	=					self.get_config()

								return config, pixel_values, labels


							def 						_snake_case							(			self)							->				Optional[int]:
								return VideoMAEConfig(
								    image_size=self.image_size    ,			patch_size=self.patch_size    ,			num_channels=self.num_channels    ,			num_frames=self.num_frames    ,			tubelet_size=self.tubelet_size    ,			hidden_size=self.hidden_size    ,			num_hidden_layers=self.num_hidden_layers    ,			num_attention_heads=self.num_attention_heads    ,			intermediate_size=self.intermediate_size    ,			hidden_act=self.hidden_act    ,			hidden_dropout_prob=self.hidden_dropout_prob    ,			attention_probs_dropout_prob=self.attention_probs_dropout_prob    ,			is_decoder=_snake_case    ,			initializer_range=self.initializer_range    ,			)


							def 						_snake_case							(			self    ,			_snake_case    ,			_snake_case    ,			_snake_case)							->				Dict:
								UpperCAmelCase_		:      List[Any]       	=					VideoMAEModel(config=_snake_case)
								model.to(_snake_case)
								model.eval()
								UpperCAmelCase_		:      List[str]       	=					model(_snake_case)
								self.parent.assertEqual(result.last_hidden_state.shape    ,			(self.batch_size, self.seq_length, self.hidden_size))


							def 						_snake_case							(			self    ,			_snake_case    ,			_snake_case    ,			_snake_case)							->				Union[str, Any]:
								UpperCAmelCase_		:      str       	=					VideoMAEForPreTraining(_snake_case)
								model.to(_snake_case)
								model.eval()
								# important: each video needs to have the same number of masked patches
								# hence we define a single mask, which we then repeat for each example in the batch
								UpperCAmelCase_		:      List[Any]       	=					torch.ones((self.num_masks,))
								UpperCAmelCase_		:      List[str]       	=					torch.cat([mask, torch.zeros(self.seq_length - mask.size(0))])
								UpperCAmelCase_		:      int       	=					mask.expand(self.batch_size    ,			-1).bool()

								UpperCAmelCase_		:      str       	=					model(_snake_case    ,			_snake_case)
								# model only returns predictions for masked patches
								UpperCAmelCase_		:      Union[str, Any]       	=					mask.sum().item()
								UpperCAmelCase_		:      Any       	=					3 * self.tubelet_size * self.patch_size**2
								self.parent.assertEqual(result.logits.shape    ,			(self.batch_size, num_masked_patches, decoder_num_labels))





							def 						_snake_case							(			self)							->				Dict:
								UpperCAmelCase_		:      str       	=					self.prepare_config_and_inputs()
								UpperCAmelCase_		:      List[str]       	=					config_and_inputs
								UpperCAmelCase_		:      Optional[Any]       	=					{'pixel_values': pixel_values}
								return config, inputs_dict



@require_torch
class 					lowercase						(  a_,					a_,					unittest.TestCase ):
							_lowerCamelCase		:      Optional[int]=   (
							    (VideoMAEModel, VideoMAEForPreTraining, VideoMAEForVideoClassification) if is_torch_available() else ()
							)
							_lowerCamelCase		:      List[str]=   (
							    {"feature-extraction": VideoMAEModel, "video-classification": VideoMAEForVideoClassification}
							    if is_torch_available()
							    else {}
							)

							_lowerCamelCase		:      Any=   False
							_lowerCamelCase		:      Optional[int]=   False
							_lowerCamelCase		:      str=   False
							_lowerCamelCase		:      Optional[Any]=   False


							def 						_snake_case							(			self)							->				Tuple:
								UpperCAmelCase_		:      List[Any]       	=					VideoMAEModelTester(self)
								UpperCAmelCase_		:      Optional[int]       	=					ConfigTester(self    ,			config_class=_snake_case    ,			has_text_modality=_snake_case    ,			hidden_size=37)


							def 						_snake_case							(			self    ,			_snake_case    ,			_snake_case    ,			_snake_case=False)							->				Optional[int]:
								UpperCAmelCase_		:      Dict       	=					copy.deepcopy(_snake_case)

								if model_class == VideoMAEForPreTraining:
									# important: each video needs to have the same number of masked patches
									# hence we define a single mask, which we then repeat for each example in the batch
									UpperCAmelCase_		:      Any       	=					torch.ones((self.model_tester.num_masks,))
									UpperCAmelCase_		:      int       	=					torch.cat([mask, torch.zeros(self.model_tester.seq_length - mask.size(0))])
									UpperCAmelCase_		:      Dict       	=					mask.expand(self.model_tester.batch_size    ,			-1).bool()
									UpperCAmelCase_		:      List[Any]       	=					bool_masked_pos.to(_snake_case)

								if return_labels:
									if model_class in [
									    *get_values(_snake_case),
									]:
										UpperCAmelCase_		:      List[Any]       	=					torch.zeros(
										    self.model_tester.batch_size    ,			dtype=torch.long    ,			device=_snake_case)

								return inputs_dict


							def 						_snake_case							(			self)							->				Union[str, Any]:
								self.config_tester.run_common_tests()


							@unittest.skip(reason='VideoMAE does not use inputs_embeds')
							def 						_snake_case							(			self)							->				Union[str, Any]:
								pass


							def 						_snake_case							(			self)							->				Optional[int]:
								UpperCAmelCase_		:      Any       	=					self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
									UpperCAmelCase_		:      Union[str, Any]       	=					model_class(_snake_case)
									self.assertIsInstance(model.get_input_embeddings()    ,			(nn.Module))
									UpperCAmelCase_		:      Dict       	=					model.get_output_embeddings()
									self.assertTrue(x is None or isinstance(_snake_case    ,			nn.Linear))


							def 						_snake_case							(			self)							->				Dict:
								UpperCAmelCase_		:      List[Any]       	=					self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
									UpperCAmelCase_		:      Union[str, Any]       	=					model_class(_snake_case)
									UpperCAmelCase_		:      Dict       	=					inspect.signature(model.forward)
									# signature.parameters is an OrderedDict => so arg_names order is deterministic
									UpperCAmelCase_		:      Optional[Any]       	=					[*signature.parameters.keys()]

									UpperCAmelCase_		:      str       	=					['pixel_values']
									self.assertListEqual(arg_names[:1]    ,			_snake_case)


							def 						_snake_case							(			self)							->				Any:
								UpperCAmelCase_		:      Tuple       	=					self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*_snake_case)


							def 						_snake_case							(			self)							->				List[Any]:
								UpperCAmelCase_		:      List[str]       	=					self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_pretraining(*_snake_case)


							@slow
							def 						_snake_case							(			self)							->				Union[str, Any]:
								for model_name in VIDEOMAE_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									UpperCAmelCase_		:      str       	=					VideoMAEModel.from_pretrained(_snake_case)
									self.assertIsNotNone(_snake_case)


							def 						_snake_case							(			self)							->				Optional[Any]:
								if not self.has_attentions:
									pass

								else:
									UpperCAmelCase_		:      Any       	=					self.model_tester.prepare_config_and_inputs_for_common()
									UpperCAmelCase_		:      Optional[int]       	=					True

									for model_class in self.all_model_classes:
										UpperCAmelCase_		:      Union[str, Any]       	=					self.model_tester.seq_length - self.model_tester.num_masks
										UpperCAmelCase_		:      Tuple       	=					(
										    num_visible_patches if model_class == VideoMAEForPreTraining else self.model_tester.seq_length
										)

										UpperCAmelCase_		:      int       	=					True
										UpperCAmelCase_		:      Union[str, Any]       	=					False
										UpperCAmelCase_		:      Dict       	=					True
										UpperCAmelCase_		:      str       	=					model_class(_snake_case)
										model.to(_snake_case)
										model.eval()
										with torch.no_grad():
											UpperCAmelCase_		:      Optional[Any]       	=					model(**self._prepare_for_class(_snake_case    ,			_snake_case))
										UpperCAmelCase_		:      Union[str, Any]       	=					outputs.attentions
										self.assertEqual(len(_snake_case)    ,			self.model_tester.num_hidden_layers)

										# check that output_attentions also work using config
										del inputs_dict["output_attentions"]
										UpperCAmelCase_		:      Optional[Any]       	=					True
										UpperCAmelCase_		:      Dict       	=					model_class(_snake_case)
										model.to(_snake_case)
										model.eval()
										with torch.no_grad():
											UpperCAmelCase_		:      List[Any]       	=					model(**self._prepare_for_class(_snake_case    ,			_snake_case))
										UpperCAmelCase_		:      List[str]       	=					outputs.attentions
										self.assertEqual(len(_snake_case)    ,			self.model_tester.num_hidden_layers)

										self.assertListEqual(
										    list(attentions[0].shape[-3:])    ,			[self.model_tester.num_attention_heads, seq_len, seq_len]    ,			)
										UpperCAmelCase_		:      Optional[Any]       	=					len(_snake_case)

										# Check attention is always last and order is fine
										UpperCAmelCase_		:      Optional[int]       	=					True
										UpperCAmelCase_		:      Optional[Any]       	=					True
										UpperCAmelCase_		:      Tuple       	=					model_class(_snake_case)
										model.to(_snake_case)
										model.eval()
										with torch.no_grad():
											UpperCAmelCase_		:      Dict       	=					model(**self._prepare_for_class(_snake_case    ,			_snake_case))

										self.assertEqual(out_len + 1    ,			len(_snake_case))

										UpperCAmelCase_		:      Union[str, Any]       	=					outputs.attentions

										self.assertEqual(len(_snake_case)    ,			self.model_tester.num_hidden_layers)
										self.assertListEqual(
										    list(self_attentions[0].shape[-3:])    ,			[self.model_tester.num_attention_heads, seq_len, seq_len]    ,			)


							def 						_snake_case							(			self)							->				Tuple:
								def check_hidden_states_output(_snake_case    ,			_snake_case    ,			_snake_case):
									UpperCAmelCase_		:      List[Any]       	=					model_class(_snake_case)
									model.to(_snake_case)
									model.eval()

									with torch.no_grad():
										UpperCAmelCase_		:      Union[str, Any]       	=					model(**self._prepare_for_class(_snake_case    ,			_snake_case))

									UpperCAmelCase_		:      Tuple       	=					outputs.hidden_states
									UpperCAmelCase_		:      Tuple       	=					self.model_tester.num_hidden_layers + 1
									self.assertEqual(len(_snake_case)    ,			_snake_case)

									UpperCAmelCase_		:      List[str]       	=					self.model_tester.seq_length - self.model_tester.num_masks
									UpperCAmelCase_		:      Union[str, Any]       	=					num_visible_patches if model_class == VideoMAEForPreTraining else self.model_tester.seq_length

									self.assertListEqual(
									    list(hidden_states[0].shape[-2:])    ,			[seq_length, self.model_tester.hidden_size]    ,			)

								UpperCAmelCase_		:      Tuple       	=					self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
									UpperCAmelCase_		:      int       	=					True
									check_hidden_states_output(_snake_case    ,			_snake_case    ,			_snake_case)

									# check that output_hidden_states also work using config
									del inputs_dict["output_hidden_states"]
									UpperCAmelCase_		:      Union[str, Any]       	=					True

									check_hidden_states_output(_snake_case    ,			_snake_case    ,			_snake_case)





							@unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.')
							def 						_snake_case							(			self)							->				Optional[Any]:
								pass







def 						SCREAMING_SNAKE_CASE(  )    ->    Any:

	'''simple docstring'''





	UpperCAmelCase_		:      Any       	=					hf_hub_download(
	    repo_id='hf-internal-testing/spaghetti-video'   ,filename='eating_spaghetti.npy'   ,repo_type='dataset'  )
	UpperCAmelCase_		:      Dict       	=					np.load(UpperCamelCase  )
	return list(UpperCamelCase  )







@require_torch
@require_vision
class 					lowercase						(  unittest.TestCase ):


							@cached_property
							def 						_snake_case							(			self)							->				Dict:
								# logits were tested with a different mean and std, so we use the same here
								return (
								    VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5]    ,			image_std=[0.5, 0.5, 0.5])
								    if is_vision_available()
								    else None
								)


							@slow
							def 						_snake_case							(			self)							->				Dict:
								UpperCAmelCase_		:      Any       	=					VideoMAEForVideoClassification.from_pretrained('MCG-NJU/videomae-base-finetuned-kinetics').to(
								    _snake_case)

								UpperCAmelCase_		:      Optional[Any]       	=					self.default_image_processor
								UpperCAmelCase_		:      Optional[int]       	=					prepare_video()
								UpperCAmelCase_		:      Union[str, Any]       	=					image_processor(_snake_case    ,			return_tensors='pt').to(_snake_case)

								# forward pass
								with torch.no_grad():
									UpperCAmelCase_		:      Union[str, Any]       	=					model(**_snake_case)

								# verify the logits
								UpperCAmelCase_		:      Dict       	=					torch.Size((1, 400))
								self.assertEqual(outputs.logits.shape    ,			_snake_case)

								UpperCAmelCase_		:      int       	=					torch.tensor([0.3_669, -0.0_688, -0.2_421]).to(_snake_case)

								self.assertTrue(torch.allclose(outputs.logits[0, :3]    ,			_snake_case    ,			atol=1e-4))





							@slow
							def 						_snake_case							(			self)							->				Optional[Any]:
								UpperCAmelCase_		:      List[str]       	=					VideoMAEForPreTraining.from_pretrained('MCG-NJU/videomae-base-short').to(_snake_case)

								UpperCAmelCase_		:      List[Any]       	=					self.default_image_processor
								UpperCAmelCase_		:      Union[str, Any]       	=					prepare_video()
								UpperCAmelCase_		:      List[str]       	=					image_processor(_snake_case    ,			return_tensors='pt').to(_snake_case)

								# add boolean mask, indicating which patches to mask
								UpperCAmelCase_		:      Optional[Any]       	=					hf_hub_download(repo_id='hf-internal-testing/bool-masked-pos'    ,			filename='bool_masked_pos.pt')
								UpperCAmelCase_		:      str       	=					torch.load(_snake_case)

								# forward pass
								with torch.no_grad():
									UpperCAmelCase_		:      List[str]       	=					model(**_snake_case)

								# verify the logits
								UpperCAmelCase_		:      str       	=					torch.Size([1, 1408, 1536])
								UpperCAmelCase_		:      Dict       	=					torch.tensor(
								    [[0.7_994, 0.9_612, 0.8_508], [0.7_401, 0.8_958, 0.8_302], [0.5_862, 0.7_468, 0.7_325]]    ,			device=_snake_case)
								self.assertEqual(outputs.logits.shape    ,			_snake_case)
								self.assertTrue(torch.allclose(outputs.logits[0, :3, :3]    ,			_snake_case    ,			atol=1e-4))

								# verify the loss (`config.norm_pix_loss` = `True`)
								UpperCAmelCase_		:      Union[str, Any]       	=					torch.tensor([0.5_142]    ,			device=_snake_case)
								self.assertTrue(torch.allclose(outputs.loss    ,			_snake_case    ,			atol=1e-4))

								# verify the loss (`config.norm_pix_loss` = `False`)
								UpperCAmelCase_		:      Optional[Any]       	=					VideoMAEForPreTraining.from_pretrained('MCG-NJU/videomae-base-short'    ,			norm_pix_loss=_snake_case).to(
								    _snake_case)

								with torch.no_grad():
									UpperCAmelCase_		:      List[str]       	=					model(**_snake_case)

								UpperCAmelCase_		:      Optional[int]       	=					torch.tensor(torch.tensor([0.6_469])    ,			device=_snake_case)
								self.assertTrue(torch.allclose(outputs.loss    ,			_snake_case    ,			atol=1e-4))









'''simple docstring'''


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


lowerCAmelCase__										= logging.get_logger(__name__)

# General docstring
lowerCAmelCase__										= "RegNetConfig"

# Base docstring
lowerCAmelCase__										= "facebook/regnet-y-040"
lowerCAmelCase__										= [1, 1088, 7, 7]

# Image classification docstring
lowerCAmelCase__										= "facebook/regnet-y-040"
lowerCAmelCase__										= "tabby, tabby cat"

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



class 					lowercase						(  nn.Module ):


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





							def 						_snake_case							(			self    ,			_snake_case)							->				Tuple:
								UpperCAmelCase_		:      Optional[int]       	=					self.convolution(_snake_case)
								UpperCAmelCase_		:      int       	=					self.normalization(_snake_case)
								UpperCAmelCase_		:      Optional[int]       	=					self.activation(_snake_case)
								return hidden_state



class 					lowercase						(  nn.Module ):


							def __init__(			self    ,			_snake_case)							->				List[Any]:
								super().__init__()
								UpperCAmelCase_		:      Tuple       	=					RegNetConvLayer(
								    config.num_channels    ,			config.embedding_size    ,			kernel_size=3    ,			stride=2    ,			activation=config.hidden_act)
								UpperCAmelCase_		:      Optional[Any]       	=					config.num_channels





							def 						_snake_case							(			self    ,			_snake_case)							->				Dict:
								UpperCAmelCase_		:      List[Any]       	=					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.')
								UpperCAmelCase_		:      Any       	=					self.embedder(_snake_case)
								return hidden_state



class 					lowercase						(  nn.Module ):


							def __init__(			self    ,			_snake_case    ,			_snake_case    ,			_snake_case = 2)							->				Optional[Any]:
								super().__init__()
								UpperCAmelCase_		:      Any       	=					nn.Convad(_snake_case    ,			_snake_case    ,			kernel_size=1    ,			stride=_snake_case    ,			bias=_snake_case)
								UpperCAmelCase_		:      Optional[Any]       	=					nn.BatchNormad(_snake_case)





							def 						_snake_case							(			self    ,			_snake_case)							->				Tensor:
								UpperCAmelCase_		:      Optional[Any]       	=					self.convolution(_snake_case)
								UpperCAmelCase_		:      Dict       	=					self.normalization(_snake_case)
								return hidden_state



class 					lowercase						(  nn.Module ):


							def __init__(			self    ,			_snake_case    ,			_snake_case)							->				Any:
								super().__init__()

								UpperCAmelCase_		:      Tuple       	=					nn.AdaptiveAvgPoolad((1, 1))
								UpperCAmelCase_		:      int       	=					nn.Sequential(
								    nn.Convad(_snake_case    ,			_snake_case    ,			kernel_size=1)    ,			nn.ReLU()    ,			nn.Convad(_snake_case    ,			_snake_case    ,			kernel_size=1)    ,			nn.Sigmoid()    ,			)





							def 						_snake_case							(			self    ,			_snake_case)							->				Any:
								# b c h w -> b c 1 1
								UpperCAmelCase_		:      Union[str, Any]       	=					self.pooler(_snake_case)
								UpperCAmelCase_		:      Any       	=					self.attention(_snake_case)
								UpperCAmelCase_		:      Optional[Any]       	=					hidden_state * attention
								return hidden_state



class 					lowercase						(  nn.Module ):


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





							def 						_snake_case							(			self    ,			_snake_case)							->				Union[str, Any]:
								UpperCAmelCase_		:      str       	=					hidden_state
								UpperCAmelCase_		:      List[Any]       	=					self.layer(_snake_case)
								UpperCAmelCase_		:      Dict       	=					self.shortcut(_snake_case)
								hidden_state += residual
								UpperCAmelCase_		:      Any       	=					self.activation(_snake_case)
								return hidden_state



class 					lowercase						(  nn.Module ):


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





							def 						_snake_case							(			self    ,			_snake_case)							->				Union[str, Any]:
								UpperCAmelCase_		:      List[str]       	=					hidden_state
								UpperCAmelCase_		:      int       	=					self.layer(_snake_case)
								UpperCAmelCase_		:      Any       	=					self.shortcut(_snake_case)
								hidden_state += residual
								UpperCAmelCase_		:      Any       	=					self.activation(_snake_case)
								return hidden_state



class 					lowercase						(  nn.Module ):


							def __init__(			self    ,			_snake_case    ,			_snake_case    ,			_snake_case    ,			_snake_case = 2    ,			_snake_case = 2    ,			)							->				Optional[int]:
								super().__init__()

								UpperCAmelCase_		:      str       	=					RegNetXLayer if config.layer_type == 'x' else RegNetYLayer

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





							def 						_snake_case							(			self    ,			_snake_case)							->				Dict:
								UpperCAmelCase_		:      Optional[Any]       	=					self.layers(_snake_case)
								return hidden_state



class 					lowercase						(  nn.Module ):


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





							def 						_snake_case							(			self    ,			_snake_case    ,			_snake_case = False    ,			_snake_case = True)							->				BaseModelOutputWithNoAttention:
								UpperCAmelCase_		:      List[Any]       	=					() if output_hidden_states else None

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

									UpperCAmelCase_		:      Tuple       	=					stage_module(_snake_case)

								if output_hidden_states:
									UpperCAmelCase_		:      Union[str, Any]       	=					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=_snake_case    ,			hidden_states=_snake_case)



class 					lowercase						(  a_ ):
							_lowerCamelCase		:      str=   RegNetConfig
							_lowerCamelCase		:      Optional[int]=   "regnet"
							_lowerCamelCase		:      Union[str, Any]=   "pixel_values"
							_lowerCamelCase		:      List[str]=   True


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





							def 						_snake_case							(			self    ,			_snake_case    ,			_snake_case=False)							->				List[Any]:
								if isinstance(_snake_case    ,			_snake_case):
									UpperCAmelCase_		:      str       	=					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 ([`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"

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 [`~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.",					a_,					)
# Copied from transformers.models.resnet.modeling_resnet.ResNetModel with RESNET->REGNET,ResNet->RegNet
class 					lowercase						(  a_ ):


							def __init__(			self    ,			_snake_case)							->				List[str]:
								super().__init__(_snake_case)
								UpperCAmelCase_		:      str       	=					config
								UpperCAmelCase_		:      Optional[int]       	=					RegNetEmbeddings(_snake_case)
								UpperCAmelCase_		:      int       	=					RegNetEncoder(_snake_case)
								UpperCAmelCase_		:      Any       	=					nn.AdaptiveAvgPoolad((1, 1))
								# Initialize weights and apply final processing
								self.post_init()





							@add_start_docstrings_to_model_forward(_snake_case)
							@add_code_sample_docstrings(
							    checkpoint=_CHECKPOINT_FOR_DOC    ,			output_type=_snake_case    ,			config_class=_CONFIG_FOR_DOC    ,			modality='vision'    ,			expected_output=_EXPECTED_OUTPUT_SHAPE    ,			)
							def 						_snake_case							(			self    ,			_snake_case    ,			_snake_case = None    ,			_snake_case = None)							->				BaseModelOutputWithPoolingAndNoAttention:
								UpperCAmelCase_		:      List[Any]       	=					(
								    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
								)
								UpperCAmelCase_		:      Optional[Any]       	=					return_dict if return_dict is not None else self.config.use_return_dict

								UpperCAmelCase_		:      int       	=					self.embedder(_snake_case)

								UpperCAmelCase_		:      str       	=					self.encoder(
								    _snake_case    ,			output_hidden_states=_snake_case    ,			return_dict=_snake_case)

								UpperCAmelCase_		:      List[Any]       	=					encoder_outputs[0]

								UpperCAmelCase_		:      str       	=					self.pooler(_snake_case)

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

								return BaseModelOutputWithPoolingAndNoAttention(
								    last_hidden_state=_snake_case    ,			pooler_output=_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    ",					a_,					)
# Copied from transformers.models.resnet.modeling_resnet.ResNetForImageClassification with RESNET->REGNET,ResNet->RegNet,resnet->regnet
class 					lowercase						(  a_ ):


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

								UpperCAmelCase_		:      Optional[Any]       	=					self.regnet(_snake_case    ,			output_hidden_states=_snake_case    ,			return_dict=_snake_case)

								UpperCAmelCase_		:      Dict       	=					outputs.pooler_output if return_dict else outputs[1]

								UpperCAmelCase_		:      int       	=					self.classifier(_snake_case)

								UpperCAmelCase_		:      List[Any]       	=					None

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

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

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






