



"""simple docstring"""






import inspect
import unittest

from transformers import RegNetConfig
from transformers.file_utils import cached_property, is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

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 RegNetForImageClassification, RegNetModel
	from transformers.models.regnet.modeling_regnet import REGNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
	from PIL import Image

	from transformers import AutoImageProcessor



class     A__     :




	'''simple docstring'''





	def __init__(  self:	Dict ,    _SCREAMING_SNAKE_CASE:	List[str] ,    _SCREAMING_SNAKE_CASE:	Union[str, Any]=3 ,    _SCREAMING_SNAKE_CASE:	Optional[Any]=32 ,    _SCREAMING_SNAKE_CASE:	Union[str, Any]=3 ,    _SCREAMING_SNAKE_CASE:	List[Any]=10 ,    _SCREAMING_SNAKE_CASE:	Optional[int]=[10, 20, 30, 40] ,    _SCREAMING_SNAKE_CASE:	Optional[Any]=[1, 1, 2, 1] ,    _SCREAMING_SNAKE_CASE:	List[Any]=True ,    _SCREAMING_SNAKE_CASE:	int=True ,    _SCREAMING_SNAKE_CASE:	List[str]="relu" ,    _SCREAMING_SNAKE_CASE:	Tuple=3 ,    _SCREAMING_SNAKE_CASE:	Union[str, Any]=None ,    )       -> Tuple:

				"""simple docstring"""

				__lowerCAmelCase   :						str				= parent
				__lowerCAmelCase   :						List[str]				= batch_size
				__lowerCAmelCase   :						Any				= image_size
				__lowerCAmelCase   :						Tuple				= num_channels
				__lowerCAmelCase   :						Any				= embeddings_size
				__lowerCAmelCase   :						Any				= hidden_sizes
				__lowerCAmelCase   :						Optional[Any]				= depths
				__lowerCAmelCase   :						List[str]				= is_training
				__lowerCAmelCase   :						Dict				= use_labels
				__lowerCAmelCase   :						Tuple				= hidden_act
				__lowerCAmelCase   :						str				= num_labels
				__lowerCAmelCase   :						Optional[Any]				= scope
				__lowerCAmelCase   :						Any				= len(_SCREAMING_SNAKE_CASE)

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

				"""simple docstring"""

				__lowerCAmelCase   :						Optional[int]				= floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

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

				__lowerCAmelCase   :						List[str]				= self.get_config()

				return config, pixel_values, labels

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

				"""simple docstring"""

				return RegNetConfig(
				    num_channels=self.num_channels ,    embeddings_size=self.embeddings_size ,    hidden_sizes=self.hidden_sizes ,    depths=self.depths ,    hidden_act=self.hidden_act ,    num_labels=self.num_labels ,    )

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

				"""simple docstring"""

				__lowerCAmelCase   :						List[Any]				= RegNetModel(config=_SCREAMING_SNAKE_CASE)
				model.to(_SCREAMING_SNAKE_CASE)
				model.eval()
				__lowerCAmelCase   :						Dict				= model(_SCREAMING_SNAKE_CASE)
				# expected last hidden states: B, C, H // 32, W // 32
				self.parent.assertEqual(
				    result.last_hidden_state.shape ,    (self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32) ,    )

	def 							_SCREAMING_SNAKE_CASE     (  self:	Dict ,    _SCREAMING_SNAKE_CASE:	Tuple ,    _SCREAMING_SNAKE_CASE:	str ,    _SCREAMING_SNAKE_CASE:	Union[str, Any])       -> Union[str, Any]:

				"""simple docstring"""

				__lowerCAmelCase   :						Dict				= self.num_labels
				__lowerCAmelCase   :						Dict				= RegNetForImageClassification(_SCREAMING_SNAKE_CASE)
				model.to(_SCREAMING_SNAKE_CASE)
				model.eval()
				__lowerCAmelCase   :						Optional[Any]				= model(_SCREAMING_SNAKE_CASE ,    labels=_SCREAMING_SNAKE_CASE)
				self.parent.assertEqual(result.logits.shape ,    (self.batch_size, self.num_labels))







	def 							_SCREAMING_SNAKE_CASE     (  self:	Any)       -> int:

				"""simple docstring"""

				__lowerCAmelCase   :						Any				= self.prepare_config_and_inputs()
				__lowerCAmelCase		,			__lowerCAmelCase		,			__lowerCAmelCase   :						List[str]				= config_and_inputs
				__lowerCAmelCase   :						str				= {"pixel_values": pixel_values}
				return config, inputs_dict






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




	'''simple docstring'''





	SCREAMING_SNAKE_CASE					   =			(RegNetModel, RegNetForImageClassification) if is_torch_available() else ()
	SCREAMING_SNAKE_CASE					   =			(
	    {'feature-extraction': RegNetModel, 'image-classification': RegNetForImageClassification}
	    if is_torch_available()
	    else {}
	)

	SCREAMING_SNAKE_CASE					   =			False
	SCREAMING_SNAKE_CASE					   =			False
	SCREAMING_SNAKE_CASE					   =			False
	SCREAMING_SNAKE_CASE					   =			False

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

				"""simple docstring"""

				__lowerCAmelCase   :						int				= RegNetModelTester(self)
				__lowerCAmelCase   :						Optional[int]				= ConfigTester(self ,    config_class=_SCREAMING_SNAKE_CASE ,    has_text_modality=_SCREAMING_SNAKE_CASE)

	def 							_SCREAMING_SNAKE_CASE     (  self:	Union[str, Any])       -> Dict:

				"""simple docstring"""

				self.create_and_test_config_common_properties()
				self.config_tester.create_and_test_config_to_json_string()
				self.config_tester.create_and_test_config_to_json_file()
				self.config_tester.create_and_test_config_from_and_save_pretrained()
				self.config_tester.create_and_test_config_with_num_labels()
				self.config_tester.check_config_can_be_init_without_params()
				self.config_tester.check_config_arguments_init()

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

				"""simple docstring"""

				return

	@unittest.skip(reason="RegNet does not use inputs_embeds")
	def 							_SCREAMING_SNAKE_CASE     (  self:	Tuple)       -> Tuple:

				"""simple docstring"""

				pass

	@unittest.skip(reason="RegNet does not support input and output embeddings")
	def 							_SCREAMING_SNAKE_CASE     (  self:	Dict)       -> List[str]:

				"""simple docstring"""

				pass

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

				"""simple docstring"""

				__lowerCAmelCase		,			__lowerCAmelCase   :						List[str]				= self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
							__lowerCAmelCase   :						str				= model_class(_SCREAMING_SNAKE_CASE)
							__lowerCAmelCase   :						Optional[int]				= inspect.signature(model.forward)
							# signature.parameters is an OrderedDict => so arg_names order is deterministic
							__lowerCAmelCase   :						List[str]				= [*signature.parameters.keys()]

							__lowerCAmelCase   :						List[str]				= ["pixel_values"]
							self.assertListEqual(arg_names[:1] ,    _SCREAMING_SNAKE_CASE)

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

				"""simple docstring"""

				__lowerCAmelCase   :						Optional[int]				= self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*_SCREAMING_SNAKE_CASE)

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

				"""simple docstring"""

				__lowerCAmelCase		,			__lowerCAmelCase   :						str				= self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
							__lowerCAmelCase   :						Union[str, Any]				= model_class(config=_SCREAMING_SNAKE_CASE)
							for name, module in model.named_modules():
										if isinstance(_SCREAMING_SNAKE_CASE ,    (nn.BatchNormad, nn.GroupNorm)):
													self.assertTrue(
													    torch.all(module.weight == 1) ,    msg=F"""Parameter {name} of model {model_class} seems not properly initialized""" ,    )
													self.assertTrue(
													    torch.all(module.bias == 0) ,    msg=F"""Parameter {name} of model {model_class} seems not properly initialized""" ,    )

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

				"""simple docstring"""

				def check_hidden_states_output(_SCREAMING_SNAKE_CASE:	Any ,    _SCREAMING_SNAKE_CASE:	str ,    _SCREAMING_SNAKE_CASE:	Dict):
							__lowerCAmelCase   :						List[Any]				= model_class(_SCREAMING_SNAKE_CASE)
							model.to(_SCREAMING_SNAKE_CASE)
							model.eval()

							with torch.no_grad():
										__lowerCAmelCase   :						int				= model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE ,    _SCREAMING_SNAKE_CASE))

							__lowerCAmelCase   :						Any				= outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

							__lowerCAmelCase   :						Optional[int]				= self.model_tester.num_stages
							self.assertEqual(len(_SCREAMING_SNAKE_CASE) ,    expected_num_stages + 1)

							# RegNet's feature maps are of shape (batch_size, num_channels, height, width)
							self.assertListEqual(
							    list(hidden_states[0].shape[-2:]) ,    [self.model_tester.image_size // 2, self.model_tester.image_size // 2] ,    )

				__lowerCAmelCase		,			__lowerCAmelCase   :						List[str]				= self.model_tester.prepare_config_and_inputs_for_common()
				__lowerCAmelCase   :						Union[str, Any]				= ["basic", "bottleneck"]
				for model_class in self.all_model_classes:
							for layer_type in layers_type:
										__lowerCAmelCase   :						Optional[Any]				= layer_type
										__lowerCAmelCase   :						List[str]				= True
										check_hidden_states_output(_SCREAMING_SNAKE_CASE ,    _SCREAMING_SNAKE_CASE ,    _SCREAMING_SNAKE_CASE)

										# check that output_hidden_states also work using config
										del inputs_dict["output_hidden_states"]
										__lowerCAmelCase   :						str				= True

										check_hidden_states_output(_SCREAMING_SNAKE_CASE ,    _SCREAMING_SNAKE_CASE ,    _SCREAMING_SNAKE_CASE)

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

				"""simple docstring"""

				__lowerCAmelCase   :						Optional[int]				= self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_image_classification(*_SCREAMING_SNAKE_CASE)







	@slow
	def 							_SCREAMING_SNAKE_CASE     (  self:	str)       -> int:

				"""simple docstring"""

				for model_name in REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							__lowerCAmelCase   :						Optional[int]				= RegNetModel.from_pretrained(_SCREAMING_SNAKE_CASE)
							self.assertIsNotNone(_SCREAMING_SNAKE_CASE)






def     _lowercase       (						)		->     List[Any]:
			__lowerCAmelCase   :						List[Any]				= Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"			)
			return image





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




	'''simple docstring'''





	@cached_property
	def 							_SCREAMING_SNAKE_CASE     (  self:	List[str])       -> Optional[Any]:

				"""simple docstring"""

				return (
				    AutoImageProcessor.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0])
				    if is_vision_available()
				    else None
				)







	@slow
	def 							_SCREAMING_SNAKE_CASE     (  self:	Union[str, Any])       -> Dict:

				"""simple docstring"""

				__lowerCAmelCase   :						Optional[int]				= RegNetForImageClassification.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]).to(_SCREAMING_SNAKE_CASE)

				__lowerCAmelCase   :						Any				= self.default_image_processor
				__lowerCAmelCase   :						List[Any]				= prepare_img()
				__lowerCAmelCase   :						Optional[int]				= image_processor(images=_SCREAMING_SNAKE_CASE ,    return_tensors="pt").to(_SCREAMING_SNAKE_CASE)

				# forward pass
				with torch.no_grad():
							__lowerCAmelCase   :						int				= model(**_SCREAMING_SNAKE_CASE)

				# verify the logits
				__lowerCAmelCase   :						List[Any]				= torch.Size((1, 1000))
				self.assertEqual(outputs.logits.shape ,    _SCREAMING_SNAKE_CASE)

				__lowerCAmelCase   :						str				= torch.tensor([-0.4180, -1.5051, -3.4836]).to(_SCREAMING_SNAKE_CASE)

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




"""simple docstring"""






import string
from math import logaa


def     _lowercase       (						__snake_case      ,__snake_case			)		->     int:
			__lowerCAmelCase   :						int				= document.translate(
			    str.maketrans(""      ,""      ,string.punctuation			)			).replace("\n"      ,""			)
			__lowerCAmelCase   :						Dict				= document_without_punctuation.split(" "			)  # word tokenization
			return len([word for word in tokenize_document if word.lower() == term.lower()]			)


def     _lowercase       (						__snake_case      ,__snake_case			)		->     tuple[int, int]:
			__lowerCAmelCase   :						Optional[Any]				= corpus.lower().translate(
			    str.maketrans(""      ,""      ,string.punctuation			)			)  # strip all punctuation and replace it with ''
			__lowerCAmelCase   :						List[str]				= corpus_without_punctuation.split("\n"			)
			__lowerCAmelCase   :						str				= term.lower()
			return (len([doc for doc in docs if term in doc]			), len(__snake_case			))


def     _lowercase       (						__snake_case      ,__snake_case      ,__snake_case=False			)		->     float:
			if smoothing:
						if n == 0:
									raise ValueError("log10(0) is undefined."			)
						return round(1 + logaa(n / (1 + df)			)      ,3			)

			if df == 0:
						raise ZeroDivisionError("df must be > 0"			)
			elif n == 0:
						raise ValueError("log10(0) is undefined."			)
			return round(logaa(n / df			)      ,3			)





def     _lowercase       (						__snake_case      ,__snake_case			)		->     float:
			return round(tf * idf      ,3			)