




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







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


														"""simple docstring"""


														_a     					=    parent
														_a     					=    batch_size
														_a     					=    image_size
														_a     					=    num_channels
														_a     					=    embeddings_size
														_a     					=    hidden_sizes
														_a     					=    depths
														_a     					=    is_training
														_a     					=    use_labels
														_a     					=    hidden_act
														_a     					=    num_labels
														_a     					=    scope
														_a     					=    len(_a )







							def        __lowerCAmelCase      (  self	:  Dict )      ->							List[Any]:


														"""simple docstring"""


														_a     					=    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

														_a     					=    None
														if self.use_labels:
																					_a     					=    ids_tensor([self.batch_size]							,      self.num_labels )

														_a     					=    self.get_config()

														return config, pixel_values, labels







							def        __lowerCAmelCase      (  self	:  str )      ->							str:


														"""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        __lowerCAmelCase      (  self	:  Any							,      lowerCAmelCase_	:  Any							,      lowerCAmelCase_	:  str							,      lowerCAmelCase_	:  List[Any] )      ->							Dict:


														"""simple docstring"""


														_a     					=    RegNetModel(config=_a )
														model.to(_a )
														model.eval()
														_a     					=    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        __lowerCAmelCase      (  self	:  str							,      lowerCAmelCase_	:  Any							,      lowerCAmelCase_	:  Any							,      lowerCAmelCase_	:  Dict )      ->							Dict:


														"""simple docstring"""


														_a     					=    self.num_labels
														_a     					=    RegNetForImageClassification(_a )
														model.to(_a )
														model.eval()
														_a     					=    model(_a							,      labels=_a )
														self.parent.assertEqual(result.logits.shape							,      (self.batch_size, self.num_labels) )







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


														"""simple docstring"""


														_a     					=    self.prepare_config_and_inputs()
														_a     					=    config_and_inputs
														_a     					=    {"""pixel_values""": pixel_values}
														return config, inputs_dict



@require_torch
class       A   (		UpperCamelCase_					,UpperCamelCase_					,unittest.TestCase   ):
							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        __lowerCAmelCase      (  self	:  Dict )      ->							int:


														"""simple docstring"""


														_a     					=    RegNetModelTester(self )
														_a     					=    ConfigTester(self							,      config_class=_a							,      has_text_modality=_a )







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


														"""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        __lowerCAmelCase      (  self	:  List[str] )      ->							Tuple:


														"""simple docstring"""


														return







							@unittest.skip(reason='''RegNet does not use inputs_embeds''' )
							def        __lowerCAmelCase      (  self	:  Optional[int] )      ->							List[Any]:


														"""simple docstring"""


														pass







							@unittest.skip(reason='''RegNet does not support input and output embeddings''' )
							def        __lowerCAmelCase      (  self	:  str )      ->							Any:


														"""simple docstring"""


														pass







							def        __lowerCAmelCase      (  self	:  Optional[Any] )      ->							Any:


														"""simple docstring"""


														_a     					=    self.model_tester.prepare_config_and_inputs_for_common()

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

																					_a     					=    ["""pixel_values"""]
																					self.assertListEqual(arg_names[:1]							,      _a )







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


														"""simple docstring"""


														_a     					=    self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_model(*_a )







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


														"""simple docstring"""


														_a     					=    self.model_tester.prepare_config_and_inputs_for_common()

														for model_class in self.all_model_classes:
																					_a     					=    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        __lowerCAmelCase      (  self	:  List[str] )      ->							Optional[Any]:


														"""simple docstring"""


														def check_hidden_states_output(lowerCAmelCase_	:  str							,      lowerCAmelCase_	:  Optional[Any]							,      lowerCAmelCase_	:  Any ):
																					_a     					=    model_class(_a )
																					model.to(_a )
																					model.eval()

																					with torch.no_grad():
																												_a     					=    model(**self._prepare_for_class(_a							,      _a ) )

																					_a     					=    outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

																					_a     					=    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]							,      )

														_a     					=    self.model_tester.prepare_config_and_inputs_for_common()
														_a     					=    ["""basic""", """bottleneck"""]
														for model_class in self.all_model_classes:
																					for layer_type in layers_type:
																												_a     					=    layer_type
																												_a     					=    True
																												check_hidden_states_output(_a							,      _a							,      _a )

																												# check that output_hidden_states also work using config
																												del inputs_dict["output_hidden_states"]
																												_a     					=    True

																												check_hidden_states_output(_a							,      _a							,      _a )







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


														"""simple docstring"""


														_a     					=    self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_for_image_classification(*_a )







							@slow
							def        __lowerCAmelCase      (  self	:  Any )      ->							List[str]:


														"""simple docstring"""


														for model_name in REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																					_a     					=    RegNetModel.from_pretrained(_a )
																					self.assertIsNotNone(_a )



def 		snake_case_   ():





							'''simple docstring'''


							_a     					=    Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''				)
							return image

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







							@cached_property
							def        __lowerCAmelCase      (  self	:  Tuple )      ->							Optional[Any]:


														"""simple docstring"""


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







							@slow
							def        __lowerCAmelCase      (  self	:  str )      ->							Any:


														"""simple docstring"""


														_a     					=    RegNetForImageClassification.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0] ).to(_a )

														_a     					=    self.default_image_processor
														_a     					=    prepare_img()
														_a     					=    image_processor(images=_a							,      return_tensors='''pt''' ).to(_a )

														# forward pass
														with torch.no_grad():
																					_a     					=    model(**_a )

														# verify the logits
														_a     					=    torch.Size((1, 10_00) )
														self.assertEqual(outputs.logits.shape							,      _a )

														_a     					=    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 ) )







'''simple docstring'''


from typing import TYPE_CHECKING

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


_snake_case				:				List[str]       							=		{'configuration_xlnet': ['XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP', 'XLNetConfig']}

try:
				if not is_sentencepiece_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				_snake_case				:				List[Any]       							=		['XLNetTokenizer']

try:
				if not is_tokenizers_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				_snake_case				:				int       							=		['XLNetTokenizerFast']

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				_snake_case				:				Optional[int]       							=		[
				    'XLNET_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'XLNetForMultipleChoice',
				    'XLNetForQuestionAnswering',
				    'XLNetForQuestionAnsweringSimple',
				    'XLNetForSequenceClassification',
				    'XLNetForTokenClassification',
				    'XLNetLMHeadModel',
				    'XLNetModel',
				    'XLNetPreTrainedModel',
				    'load_tf_weights_in_xlnet',
				]

try:
				if not is_tf_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				_snake_case				:				str       							=		[
				    'TF_XLNET_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'TFXLNetForMultipleChoice',
				    'TFXLNetForQuestionAnsweringSimple',
				    'TFXLNetForSequenceClassification',
				    'TFXLNetForTokenClassification',
				    'TFXLNetLMHeadModel',
				    'TFXLNetMainLayer',
				    'TFXLNetModel',
				    'TFXLNetPreTrainedModel',
				]


if TYPE_CHECKING:
				from .configuration_xlnet import XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP, XLNetConfig

				try:
								if not is_sentencepiece_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .tokenization_xlnet import XLNetTokenizer

				try:
								if not is_tokenizers_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .tokenization_xlnet_fast import XLNetTokenizerFast

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_xlnet import (
								    XLNET_PRETRAINED_MODEL_ARCHIVE_LIST,
								    XLNetForMultipleChoice,
								    XLNetForQuestionAnswering,
								    XLNetForQuestionAnsweringSimple,
								    XLNetForSequenceClassification,
								    XLNetForTokenClassification,
								    XLNetLMHeadModel,
								    XLNetModel,
								    XLNetPreTrainedModel,
								    load_tf_weights_in_xlnet,
								)

				try:
								if not is_tf_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_tf_xlnet import (
								    TF_XLNET_PRETRAINED_MODEL_ARCHIVE_LIST,
								    TFXLNetForMultipleChoice,
								    TFXLNetForQuestionAnsweringSimple,
								    TFXLNetForSequenceClassification,
								    TFXLNetForTokenClassification,
								    TFXLNetLMHeadModel,
								    TFXLNetMainLayer,
								    TFXLNetModel,
								    TFXLNetPreTrainedModel,
								)

else:
				import sys

				_snake_case				:				Union[str, Any]       							=		_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)

