



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 				snake_case__:

					"""simple docstring"""






					def __init__(							self :     List[Any]				,       SCREAMING_SNAKE_CASE :     int				,       SCREAMING_SNAKE_CASE :     Union[str, Any]=3				,       SCREAMING_SNAKE_CASE :     str=32				,       SCREAMING_SNAKE_CASE :     Tuple=3				,       SCREAMING_SNAKE_CASE :     Any=10				,       SCREAMING_SNAKE_CASE :     Optional[int]=[10, 20, 30, 40]				,       SCREAMING_SNAKE_CASE :     Tuple=[1, 1, 2, 1]				,       SCREAMING_SNAKE_CASE :     Union[str, Any]=True				,       SCREAMING_SNAKE_CASE :     Union[str, Any]=True				,       SCREAMING_SNAKE_CASE :     List[Any]="relu"				,       SCREAMING_SNAKE_CASE :     List[Any]=3				,       SCREAMING_SNAKE_CASE :     Dict=None				,       ):
									lowercase__					:   int													=					parent
									lowercase__					:   Optional[Any]													=					batch_size
									lowercase__					:   Union[str, Any]													=					image_size
									lowercase__					:   str													=					num_channels
									lowercase__					:   int													=					embeddings_size
									lowercase__					:   int													=					hidden_sizes
									lowercase__					:   Any													=					depths
									lowercase__					:   Union[str, Any]													=					is_training
									lowercase__					:   Union[str, Any]													=					use_labels
									lowercase__					:   int													=					hidden_act
									lowercase__					:   Tuple													=					num_labels
									lowercase__					:   List[Any]													=					scope
									lowercase__					:   str													=					len(SCREAMING_SNAKE_CASE					)







					def 			snake_case					(							self :     int					):
									lowercase__					:   str													=					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

									lowercase__					:   Optional[int]													=					None
									if self.use_labels:
													lowercase__					:   List[str]													=					ids_tensor([self.batch_size]				,       self.num_labels					)

									lowercase__					:   Tuple													=					self.get_config()

									return config, pixel_values, labels







					def 			snake_case					(							self :     Tuple					):
									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 			snake_case					(							self :     Union[str, Any]				,       SCREAMING_SNAKE_CASE :     Tuple				,       SCREAMING_SNAKE_CASE :     Union[str, Any]				,       SCREAMING_SNAKE_CASE :     int					):
									lowercase__					:   List[str]													=					RegNetModel(config=SCREAMING_SNAKE_CASE					)
									model.to(SCREAMING_SNAKE_CASE					)
									model.eval()
									lowercase__					:   List[str]													=					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 			snake_case					(							self :     int				,       SCREAMING_SNAKE_CASE :     int				,       SCREAMING_SNAKE_CASE :     Tuple				,       SCREAMING_SNAKE_CASE :     Tuple					):
									lowercase__					:   int													=					self.num_labels
									lowercase__					:   Any													=					RegNetForImageClassification(SCREAMING_SNAKE_CASE					)
									model.to(SCREAMING_SNAKE_CASE					)
									model.eval()
									lowercase__					:   Tuple													=					model(SCREAMING_SNAKE_CASE				,       labels=SCREAMING_SNAKE_CASE					)
									self.parent.assertEqual(result.logits.shape				,       (self.batch_size, self.num_labels)					)







					def 			snake_case					(							self :     str					):
									lowercase__					:   Optional[int]													=					self.prepare_config_and_inputs()
									lowercase__							,							lowercase__							,							lowercase__					:   str													=					config_and_inputs
									lowercase__					:   Any													=					{"pixel_values": pixel_values}
									return config, inputs_dict






@require_torch
class 				snake_case__(_UpperCamelCase    ,      _UpperCamelCase    ,      unittest.TestCase      ):

					"""simple docstring"""






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

					lowercase_								=		False
					lowercase_								=		False
					lowercase_								=		False
					lowercase_								=		False







					def 			snake_case					(							self :     str					):
									lowercase__					:   int													=					RegNetModelTester(self					)
									lowercase__					:   List[str]													=					ConfigTester(self				,       config_class=SCREAMING_SNAKE_CASE				,       has_text_modality=SCREAMING_SNAKE_CASE					)







					def 			snake_case					(							self :     Optional[Any]					):
									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 			snake_case					(							self :     Any					):
									return







					@unittest.skip(reason="RegNet does not use inputs_embeds"					)
					def 			snake_case					(							self :     str					):
									pass







					@unittest.skip(reason="RegNet does not support input and output embeddings"					)
					def 			snake_case					(							self :     Dict					):
									pass







					def 			snake_case					(							self :     Dict					):
									lowercase__							,							lowercase__					:   List[str]													=					self.model_tester.prepare_config_and_inputs_for_common()

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

													lowercase__					:   Optional[int]													=					["pixel_values"]
													self.assertListEqual(arg_names[:1]				,       SCREAMING_SNAKE_CASE					)







					def 			snake_case					(							self :     List[Any]					):
									lowercase__					:   List[str]													=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE					)







					def 			snake_case					(							self :     Dict					):
									lowercase__							,							lowercase__					:   List[str]													=					self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
													lowercase__					:   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 			snake_case					(							self :     Union[str, Any]					):
									def check_hidden_states_output(SCREAMING_SNAKE_CASE :     Tuple				,       SCREAMING_SNAKE_CASE :     Optional[Any]				,       SCREAMING_SNAKE_CASE :     Tuple					):
													lowercase__					:   Optional[Any]													=					model_class(SCREAMING_SNAKE_CASE					)
													model.to(SCREAMING_SNAKE_CASE					)
													model.eval()

													with torch.no_grad():
																	lowercase__					:   int													=					model(**self._prepare_for_class(SCREAMING_SNAKE_CASE				,       SCREAMING_SNAKE_CASE					)					)

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

													lowercase__					:   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]				,       )

									lowercase__							,							lowercase__					:   List[Any]													=					self.model_tester.prepare_config_and_inputs_for_common()
									lowercase__					:   Union[str, Any]													=					["basic", "bottleneck"]
									for model_class in self.all_model_classes:
													for layer_type in layers_type:
																	lowercase__					:   Union[str, Any]													=					layer_type
																	lowercase__					:   Any													=					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"]
																	lowercase__					:   List[Any]													=					True

																	check_hidden_states_output(SCREAMING_SNAKE_CASE				,       SCREAMING_SNAKE_CASE				,       SCREAMING_SNAKE_CASE					)







					def 			snake_case					(							self :     Any					):
									lowercase__					:   Any													=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE					)







					@slow
					def 			snake_case					(							self :     int					):
									for model_name in REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													lowercase__					:   Tuple													=					RegNetModel.from_pretrained(SCREAMING_SNAKE_CASE					)
													self.assertIsNotNone(SCREAMING_SNAKE_CASE					)






def  __lowerCamelCase (       ):

				"""simple docstring"""


				lowercase__					:   Any													=					Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"						)
				return image

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

					"""simple docstring"""






					@cached_property
					def 			snake_case					(							self :     int					):
									return (
									    AutoImageProcessor.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]					)
									    if is_vision_available()
									    else None
									)







					@slow
					def 			snake_case					(							self :     str					):
									lowercase__					:   Optional[int]													=					RegNetForImageClassification.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]					).to(SCREAMING_SNAKE_CASE					)

									lowercase__					:   List[Any]													=					self.default_image_processor
									lowercase__					:   Optional[Any]													=					prepare_img()
									lowercase__					:   Dict													=					image_processor(images=SCREAMING_SNAKE_CASE				,       return_tensors="pt"					).to(SCREAMING_SNAKE_CASE					)

									# forward pass
									with torch.no_grad():
													lowercase__					:   Optional[int]													=					model(**SCREAMING_SNAKE_CASE					)

									# verify the logits
									lowercase__					:   Optional[Any]													=					torch.Size((1, 1_000)					)
									self.assertEqual(outputs.logits.shape				,       SCREAMING_SNAKE_CASE					)

									lowercase__					:   Dict													=					torch.tensor([-0.4_180, -1.5_051, -3.4_836]					).to(SCREAMING_SNAKE_CASE					)

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









from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_tokenizers_available,
    is_torch_available,
)


lowerCAmelCase__					  =  {}

try:
				if not is_sentencepiece_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				lowerCAmelCase__					  =  ['''NllbTokenizer''']

try:
				if not is_tokenizers_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				lowerCAmelCase__					  =  ['''NllbTokenizerFast''']


if TYPE_CHECKING:
				try:
								if not is_sentencepiece_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .tokenization_nllb import NllbTokenizer

				try:
								if not is_tokenizers_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .tokenization_nllb_fast import NllbTokenizerFast

else:
				import sys

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




