


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:	Optional[int]						,				a:	List[Any]						,				a:	List[Any]=3						,				a:	Tuple=32						,				a:	Optional[Any]=3						,				a:	str=10						,				a:	Any=[10, 20, 30, 40]						,				a:	List[Any]=[1, 1, 2, 1]						,				a:	Dict=True						,				a:	Optional[int]=True						,				a:	int="relu"						,				a:	Tuple=3						,				a:	Tuple=None						,				):
							__lowerCamelCase		:							Optional[Any]		 =						parent
							__lowerCamelCase		:							Dict		 =						batch_size
							__lowerCamelCase		:							List[str]		 =						image_size
							__lowerCamelCase		:							int		 =						num_channels
							__lowerCamelCase		:							Optional[int]		 =						embeddings_size
							__lowerCamelCase		:							Tuple		 =						hidden_sizes
							__lowerCamelCase		:							Optional[Any]		 =						depths
							__lowerCamelCase		:							Dict		 =						is_training
							__lowerCamelCase		:							Tuple		 =						use_labels
							__lowerCamelCase		:							int		 =						hidden_act
							__lowerCamelCase		:							Dict		 =						num_labels
							__lowerCamelCase		:							Optional[Any]		 =						scope
							__lowerCamelCase		:							Optional[Any]		 =						len(a    )




						def 					_snake_case     (    self:	Optional[Any]    ):
							__lowerCamelCase		:							Dict		 =						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )

							__lowerCamelCase		:							Optional[int]		 =						None
							if self.use_labels:
								__lowerCamelCase		:							Optional[Any]		 =						ids_tensor([self.batch_size]						,				self.num_labels    )

							__lowerCamelCase		:							Any		 =						self.get_config()

							return config, pixel_values, labels




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




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



@require_torch
class 	A_ (	__UpperCamelCase ,				__UpperCamelCase ,				unittest.TestCase   ):




						'''simple docstring'''


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

						__snake_case 	=       False
						__snake_case 	=       False
						__snake_case 	=       False
						__snake_case 	=       False




						def 					_snake_case     (    self:	int    ):
							__lowerCamelCase		:							Any		 =						RegNetModelTester(self    )
							__lowerCamelCase		:							Dict		 =						ConfigTester(self						,				config_class=a						,				has_text_modality=a    )




						def 					_snake_case     (    self:	Union[str, 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:	List[Any]    ):
							return




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




						@unittest.skip(reason='RegNet does not support input and output embeddings'    )
						def 					_snake_case     (    self:	int    ):
							pass




						def 					_snake_case     (    self:	Optional[int]    ):
							__lowerCamelCase		:							Optional[Any]		 =						self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
								__lowerCamelCase		:							List[str]		 =						model_class(a    )
								__lowerCamelCase		:							Dict		 =						inspect.signature(model.forward    )
								# signature.parameters is an OrderedDict => so arg_names order is deterministic
								__lowerCamelCase		:							List[Any]		 =						[*signature.parameters.keys()]

								__lowerCamelCase		:							List[str]		 =						['pixel_values']
								self.assertListEqual(arg_names[:1]						,				a    )




						def 					_snake_case     (    self:	Tuple    ):
							__lowerCamelCase		:							Dict		 =						self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*a    )




						def 					_snake_case     (    self:	Optional[Any]    ):
							__lowerCamelCase		:							List[Any]		 =						self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
								__lowerCamelCase		:							List[str]		 =						model_class(config=a    )
								for name, module in model.named_modules():
									if isinstance(a						,				(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:	str    ):
							def check_hidden_states_output(a:	int						,				a:	Dict						,				a:	int    ):
								__lowerCamelCase		:							Tuple		 =						model_class(a    )
								model.to(a    )
								model.eval()

								with torch.no_grad():
									__lowerCamelCase		:							List[Any]		 =						model(**self._prepare_for_class(a						,				a    )    )

								__lowerCamelCase		:							List[str]		 =						outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

								__lowerCamelCase		:							Optional[Any]		 =						self.model_tester.num_stages
								self.assertEqual(len(a    )						,				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		:							List[str]		 =						self.model_tester.prepare_config_and_inputs_for_common()
							__lowerCamelCase		:							Tuple		 =						['basic', 'bottleneck']
							for model_class in self.all_model_classes:
								for layer_type in layers_type:
									__lowerCamelCase		:							Optional[Any]		 =						layer_type
									__lowerCamelCase		:							List[Any]		 =						True
									check_hidden_states_output(a						,				a						,				a    )

									# check that output_hidden_states also work using config
									del inputs_dict["output_hidden_states"]
									__lowerCamelCase		:							List[Any]		 =						True

									check_hidden_states_output(a						,				a						,				a    )




						def 					_snake_case     (    self:	Any    ):
							__lowerCamelCase		:							Any		 =						self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*a    )




						@slow
						def 					_snake_case     (    self:	Optional[Any]    ):
							for model_name in REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
								__lowerCamelCase		:							int		 =						RegNetModel.from_pretrained(a    )
								self.assertIsNotNone(a    )



def 				UpperCamelCase__					(  ):
	__lowerCamelCase		:							Optional[int]		 =						Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'						)
	return image



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




						'''simple docstring'''


						@cached_property
						def 					_snake_case     (    self:	Optional[Any]    ):
							return (
							    AutoImageProcessor.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]    )
							    if is_vision_available()
							    else None
							)




						@slow
						def 					_snake_case     (    self:	List[str]    ):
							__lowerCamelCase		:							Optional[int]		 =						RegNetForImageClassification.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]    ).to(a    )

							__lowerCamelCase		:							Union[str, Any]		 =						self.default_image_processor
							__lowerCamelCase		:							Any		 =						prepare_img()
							__lowerCamelCase		:							str		 =						image_processor(images=a						,				return_tensors='pt'    ).to(a    )

							# forward pass
							with torch.no_grad():
								__lowerCamelCase		:							Tuple		 =						model(**a    )

							# verify the logits
							__lowerCamelCase		:							str		 =						torch.Size((1, 1000)    )
							self.assertEqual(outputs.logits.shape						,				a    )

							__lowerCamelCase		:							Union[str, Any]		 =						torch.tensor([-0.4_1_8_0, -1.5_0_5_1, -3.4_8_3_6]    ).to(a    )

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





import warnings

from ...utils import logging
from .image_processing_chinese_clip import ChineseCLIPImageProcessor


lowercase_	   =     logging.get_logger(__name__)


class 	A_ (	__UpperCamelCase   ):




      '''simple docstring'''


      def __init__(    self:	List[str]						,				*a:	List[Any]						,				**a:	Optional[Any]    ):
       warnings.warn(
           'The class ChineseCLIPFeatureExtractor is deprecated and will be removed in version 5 of Transformers.'
           ' Please use ChineseCLIPImageProcessor instead.'						,				a						,				)
       super().__init__(*a						,				**a    )

