
'''simple docstring'''






import collections
import inspect
import unittest

from transformers import NatConfig
from transformers.testing_utils import require_natten, require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

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


if is_torch_available():
							import torch
							from torch import nn

							from transformers import NatBackbone, NatForImageClassification, NatModel
							from transformers.models.nat.modeling_nat import NAT_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
							from PIL import Image

							from transformers import AutoImageProcessor

class 							_snake_case     :
	"""simple docstring"""





	def __init__(						self				: Union[str, Any]					,						UpperCamelCase_				: Optional[int]					,						UpperCamelCase_				: Union[str, Any]=13					,						UpperCamelCase_				: str=64					,						UpperCamelCase_				: str=4					,						UpperCamelCase_				: Optional[int]=3					,						UpperCamelCase_				: Any=16					,						UpperCamelCase_				: Optional[Any]=[1, 2, 1]					,						UpperCamelCase_				: str=[2, 4, 8]					,						UpperCamelCase_				: Tuple=3					,						UpperCamelCase_				: str=2.0					,						UpperCamelCase_				: Any=True					,						UpperCamelCase_				: Optional[int]=0.0					,						UpperCamelCase_				: Optional[int]=0.0					,						UpperCamelCase_				: int=0.1					,						UpperCamelCase_				: List[str]="gelu"					,						UpperCamelCase_				: Dict=True					,						UpperCamelCase_				: Dict=0.0_2					,						UpperCamelCase_				: Union[str, Any]=1E-5					,						UpperCamelCase_				: Tuple=True					,						UpperCamelCase_				: Union[str, Any]=None					,						UpperCamelCase_				: Union[str, Any]=True					,						UpperCamelCase_				: Optional[int]=10					,						UpperCamelCase_				: str=["stage1", "stage2"]					,						UpperCamelCase_				: List[Any]=[1, 2]					,						):
			lowerCAmelCase_   :       str    							=parent
			lowerCAmelCase_   :       Union[str, Any]    							=batch_size
			lowerCAmelCase_   :       int    							=image_size
			lowerCAmelCase_   :       Union[str, Any]    							=patch_size
			lowerCAmelCase_   :       Union[str, Any]    							=num_channels
			lowerCAmelCase_   :       int    							=embed_dim
			lowerCAmelCase_   :       Dict    							=depths
			lowerCAmelCase_   :       Tuple    							=num_heads
			lowerCAmelCase_   :       List[Any]    							=kernel_size
			lowerCAmelCase_   :       List[str]    							=mlp_ratio
			lowerCAmelCase_   :       Tuple    							=qkv_bias
			lowerCAmelCase_   :       Tuple    							=hidden_dropout_prob
			lowerCAmelCase_   :       Dict    							=attention_probs_dropout_prob
			lowerCAmelCase_   :       Dict    							=drop_path_rate
			lowerCAmelCase_   :       int    							=hidden_act
			lowerCAmelCase_   :       int    							=patch_norm
			lowerCAmelCase_   :       Optional[int]    							=layer_norm_eps
			lowerCAmelCase_   :       List[Any]    							=initializer_range
			lowerCAmelCase_   :       Union[str, Any]    							=is_training
			lowerCAmelCase_   :       Dict    							=scope
			lowerCAmelCase_   :       str    							=use_labels
			lowerCAmelCase_   :       Optional[Any]    							=num_labels
			lowerCAmelCase_   :       List[str]    							=out_features
			lowerCAmelCase_   :       str    							=out_indices




	def 	__A      (						self				: Optional[Any]      ):
			lowerCAmelCase_   :       Optional[Any]    							=floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

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

			lowerCAmelCase_   :       Dict    							=self.get_config()

			return config, pixel_values, labels




	def 	__A      (						self				: Optional[Any]      ):
			return NatConfig(
			    num_labels=self.num_labels					,						image_size=self.image_size					,						patch_size=self.patch_size					,						num_channels=self.num_channels					,						embed_dim=self.embed_dim					,						depths=self.depths					,						num_heads=self.num_heads					,						kernel_size=self.kernel_size					,						mlp_ratio=self.mlp_ratio					,						qkv_bias=self.qkv_bias					,						hidden_dropout_prob=self.hidden_dropout_prob					,						attention_probs_dropout_prob=self.attention_probs_dropout_prob					,						drop_path_rate=self.drop_path_rate					,						hidden_act=self.hidden_act					,						patch_norm=self.patch_norm					,						layer_norm_eps=self.layer_norm_eps					,						initializer_range=self.initializer_range					,						out_features=self.out_features					,						out_indices=self.out_indices					,						)




	def 	__A      (						self				: Optional[int]					,						UpperCamelCase_				: Tuple					,						UpperCamelCase_				: Dict					,						UpperCamelCase_				: List[Any]      ):
			lowerCAmelCase_   :       Dict    							=NatModel(config=UpperCamelCase_      )
			model.to(UpperCamelCase_      )
			model.eval()
			lowerCAmelCase_   :       Tuple    							=model(UpperCamelCase_      )

			lowerCAmelCase_   :       List[str]    							=(config.image_size // config.patch_size) // (2 ** (len(config.depths      ) - 1))
			lowerCAmelCase_   :       List[str]    							=int(config.embed_dim * 2 ** (len(config.depths      ) - 1)      )

			self.parent.assertEqual(
			    result.last_hidden_state.shape					,						(self.batch_size, expected_height, expected_width, expected_dim)      )




	def 	__A      (						self				: Tuple					,						UpperCamelCase_				: Any					,						UpperCamelCase_				: Dict					,						UpperCamelCase_				: Union[str, Any]      ):
			lowerCAmelCase_   :       Tuple    							=NatForImageClassification(UpperCamelCase_      )
			model.to(UpperCamelCase_      )
			model.eval()
			lowerCAmelCase_   :       Dict    							=model(UpperCamelCase_					,						labels=UpperCamelCase_      )
			self.parent.assertEqual(result.logits.shape					,						(self.batch_size, self.num_labels)      )

			# test greyscale images
			lowerCAmelCase_   :       Tuple    							=1
			lowerCAmelCase_   :       Optional[Any]    							=NatForImageClassification(UpperCamelCase_      )
			model.to(UpperCamelCase_      )
			model.eval()

			lowerCAmelCase_   :       Dict    							=floats_tensor([self.batch_size, 1, self.image_size, self.image_size]      )
			lowerCAmelCase_   :       Union[str, Any]    							=model(UpperCamelCase_      )
			self.parent.assertEqual(result.logits.shape					,						(self.batch_size, self.num_labels)      )




	def 	__A      (						self				: Optional[Any]					,						UpperCamelCase_				: Any					,						UpperCamelCase_				: Optional[Any]					,						UpperCamelCase_				: List[Any]      ):
			lowerCAmelCase_   :       Tuple    							=NatBackbone(config=UpperCamelCase_      )
			model.to(UpperCamelCase_      )
			model.eval()
			lowerCAmelCase_   :       List[str]    							=model(UpperCamelCase_      )

			# verify hidden states
			self.parent.assertEqual(len(result.feature_maps      )					,						len(config.out_features      )      )
			self.parent.assertListEqual(list(result.feature_maps[0].shape      )					,						[self.batch_size, model.channels[0], 16, 16]      )

			# verify channels
			self.parent.assertEqual(len(model.channels      )					,						len(config.out_features      )      )

			# verify backbone works with out_features=None
			lowerCAmelCase_   :       Tuple    							=None
			lowerCAmelCase_   :       Union[str, Any]    							=NatBackbone(config=UpperCamelCase_      )
			model.to(UpperCamelCase_      )
			model.eval()
			lowerCAmelCase_   :       Optional[int]    							=model(UpperCamelCase_      )

			# verify feature maps
			self.parent.assertEqual(len(result.feature_maps      )					,						1      )
			self.parent.assertListEqual(list(result.feature_maps[0].shape      )					,						[self.batch_size, model.channels[-1], 4, 4]      )

			# verify channels
			self.parent.assertEqual(len(model.channels      )					,						1      )





	def 	__A      (						self				: Dict      ):
			lowerCAmelCase_   :       Any    							=self.prepare_config_and_inputs()
			lowerCAmelCase_							,		lowerCAmelCase_							,		lowerCAmelCase_   :       Optional[int]    							=config_and_inputs
			lowerCAmelCase_   :       Any    							={'''pixel_values''': pixel_values}
			return config, inputs_dict







@require_natten
@require_torch
class 							_snake_case     (  lowerCAmelCase_						,    lowerCAmelCase_						,    unittest.TestCase ):
	"""simple docstring"""





	_UpperCamelCase							:  Tuple								=		(
	    (
	        NatModel,
	        NatForImageClassification,
	        NatBackbone,
	    )
	    if is_torch_available()
	    else ()
	)
	_UpperCamelCase							:  List[Any]								=		(
	    {'''feature-extraction''': NatModel, '''image-classification''': NatForImageClassification}
	    if is_torch_available()
	    else {}
	)
	_UpperCamelCase							:  int								=		False

	_UpperCamelCase							:  Optional[int]								=		False
	_UpperCamelCase							:  List[Any]								=		False
	_UpperCamelCase							:  Dict								=		False
	_UpperCamelCase							:  Dict								=		False




	def 	__A      (						self				: Optional[Any]      ):
			lowerCAmelCase_   :       Tuple    							=NatModelTester(self      )
			lowerCAmelCase_   :       Optional[Any]    							=ConfigTester(self					,						config_class=UpperCamelCase_					,						embed_dim=37      )




	def 	__A      (						self				: Dict      ):
			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 	__A      (						self				: Dict      ):
			return




	def 	__A      (						self				: Optional[Any]      ):
			lowerCAmelCase_   :       Any    							=self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_model(*UpperCamelCase_      )




	def 	__A      (						self				: int      ):
			lowerCAmelCase_   :       Any    							=self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_for_image_classification(*UpperCamelCase_      )




	def 	__A      (						self				: Optional[Any]      ):
			lowerCAmelCase_   :       Dict    							=self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_backbone(*UpperCamelCase_      )




	@unittest.skip(reason='''Nat does not use inputs_embeds'''      )
	def 	__A      (						self				: Any      ):
			pass




	@unittest.skip(reason='''Nat does not use feedforward chunking'''      )
	def 	__A      (						self				: Any      ):
			pass




	def 	__A      (						self				: Dict      ):
			lowerCAmelCase_							,		lowerCAmelCase_   :       List[str]    							=self.model_tester.prepare_config_and_inputs_for_common()

			for model_class in self.all_model_classes:
					lowerCAmelCase_   :       Any    							=model_class(UpperCamelCase_      )
					self.assertIsInstance(model.get_input_embeddings()					,						(nn.Module)      )
					lowerCAmelCase_   :       List[Any]    							=model.get_output_embeddings()
					self.assertTrue(x is None or isinstance(UpperCamelCase_					,						nn.Linear      )      )




	def 	__A      (						self				: int      ):
			lowerCAmelCase_							,		lowerCAmelCase_   :       int    							=self.model_tester.prepare_config_and_inputs_for_common()

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

					lowerCAmelCase_   :       Optional[int]    							=['''pixel_values''']
					self.assertListEqual(arg_names[:1]					,						UpperCamelCase_      )




	def 	__A      (						self				: Optional[Any]      ):
			self.skipTest('''Nat\'s attention operation is handled entirely by NATTEN.'''      )




	def 	__A      (						self				: Any					,						UpperCamelCase_				: str					,						UpperCamelCase_				: List[str]					,						UpperCamelCase_				: int					,						UpperCamelCase_				: List[str]      ):
			lowerCAmelCase_   :       int    							=model_class(UpperCamelCase_      )
			model.to(UpperCamelCase_      )
			model.eval()

			with torch.no_grad():
					lowerCAmelCase_   :       Tuple    							=model(**self._prepare_for_class(UpperCamelCase_					,						UpperCamelCase_      )      )

			lowerCAmelCase_   :       Any    							=outputs.hidden_states

			lowerCAmelCase_   :       str    							=getattr(
			    self.model_tester					,						'''expected_num_hidden_layers'''					,						len(self.model_tester.depths      ) + 1      )
			self.assertEqual(len(UpperCamelCase_      )					,						UpperCamelCase_      )

			# Nat has a different seq_length
			lowerCAmelCase_   :       Optional[int]    							=(
			    config.patch_size
			    if isinstance(config.patch_size					,						collections.abc.Iterable      )
			    else (config.patch_size, config.patch_size)
			)

			lowerCAmelCase_   :       Optional[Any]    							=image_size[0] // patch_size[0]
			lowerCAmelCase_   :       List[Any]    							=image_size[1] // patch_size[1]

			self.assertListEqual(
			    list(hidden_states[0].shape[-3:]      )					,						[height, width, self.model_tester.embed_dim]					,						)

			if model_class.__name__ != "NatBackbone":
					lowerCAmelCase_   :       str    							=outputs.reshaped_hidden_states
					self.assertEqual(len(UpperCamelCase_      )					,						UpperCamelCase_      )

					lowerCAmelCase_							,		lowerCAmelCase_							,		lowerCAmelCase_							,		lowerCAmelCase_   :       Optional[Any]    							=reshaped_hidden_states[0].shape
					lowerCAmelCase_   :       List[Any]    							=(
					    reshaped_hidden_states[0].view(UpperCamelCase_					,						UpperCamelCase_					,						UpperCamelCase_					,						UpperCamelCase_      ).permute(0					,						2					,						3					,						1      )
					)
					self.assertListEqual(
					    list(reshaped_hidden_states.shape[-3:]      )					,						[height, width, self.model_tester.embed_dim]					,						)




	def 	__A      (						self				: int      ):
			lowerCAmelCase_							,		lowerCAmelCase_   :       Optional[Any]    							=self.model_tester.prepare_config_and_inputs_for_common()

			lowerCAmelCase_   :       int    							=(
			    self.model_tester.image_size
			    if isinstance(self.model_tester.image_size					,						collections.abc.Iterable      )
			    else (self.model_tester.image_size, self.model_tester.image_size)
			)

			for model_class in self.all_model_classes:
					lowerCAmelCase_   :       Union[str, Any]    							=True
					self.check_hidden_states_output(UpperCamelCase_					,						UpperCamelCase_					,						UpperCamelCase_					,						UpperCamelCase_      )

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

					self.check_hidden_states_output(UpperCamelCase_					,						UpperCamelCase_					,						UpperCamelCase_					,						UpperCamelCase_      )




	@slow
	def 	__A      (						self				: Union[str, Any]      ):
			for model_name in NAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					lowerCAmelCase_   :       Tuple    							=NatModel.from_pretrained(UpperCamelCase_      )
					self.assertIsNotNone(UpperCamelCase_      )





	def 	__A      (						self				: Any      ):
			lowerCAmelCase_							,		lowerCAmelCase_   :       str    							=self.model_tester.prepare_config_and_inputs_for_common()

			lowerCAmelCase_   :       Optional[int]    							=_config_zero_init(UpperCamelCase_      )
			for model_class in self.all_model_classes:
					lowerCAmelCase_   :       Union[str, Any]    							=model_class(config=UpperCamelCase_      )
					for name, param in model.named_parameters():
							if "embeddings" not in name and param.requires_grad:
									self.assertIn(
									    ((param.data.mean() * 1E9).round() / 1E9).item()					,						[0.0, 1.0]					,						msg=F'Parameter {name} of model {model_class} seems not properly initialized'					,						)







@require_natten
@require_vision
@require_torch
class 							_snake_case     (  unittest.TestCase ):
	"""simple docstring"""





	@cached_property
	def 	__A      (						self				: Tuple      ):
			return AutoImageProcessor.from_pretrained('''shi-labs/nat-mini-in1k-224'''      ) if is_vision_available() else None





	@slow
	def 	__A      (						self				: int      ):
			lowerCAmelCase_   :       Dict    							=NatForImageClassification.from_pretrained('''shi-labs/nat-mini-in1k-224'''      ).to(UpperCamelCase_      )
			lowerCAmelCase_   :       Optional[int]    							=self.default_image_processor

			lowerCAmelCase_   :       List[Any]    							=Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''      )
			lowerCAmelCase_   :       List[str]    							=image_processor(images=UpperCamelCase_					,						return_tensors='''pt'''      ).to(UpperCamelCase_      )

			# forward pass
			with torch.no_grad():
					lowerCAmelCase_   :       Optional[Any]    							=model(**UpperCamelCase_      )

			# verify the logits
			lowerCAmelCase_   :       Any    							=torch.Size((1, 1000)      )
			self.assertEqual(outputs.logits.shape					,						UpperCamelCase_      )
			lowerCAmelCase_   :       List[Any]    							=torch.tensor([0.3_8_0_5, -0.8_6_7_6, -0.3_9_1_2]      ).to(UpperCamelCase_      )
			self.assertTrue(torch.allclose(outputs.logits[0, :3]					,						UpperCamelCase_					,						atol=1E-4      )      )







@require_torch
@require_natten
class 							_snake_case     (  unittest.TestCase						,    lowerCAmelCase_ ):
	"""simple docstring"""





	_UpperCamelCase							:  Tuple								=		(NatBackbone,) if is_torch_available() else ()
	_UpperCamelCase							:  Optional[Any]								=		NatConfig




	def 	__A      (						self				: int      ):
			lowerCAmelCase_   :       Dict    							=NatModelTester(self      )








'''simple docstring'''






from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_torch_available


__lowercase	=    {
    '''configuration_xlm_prophetnet''': ['''XLM_PROPHETNET_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''XLMProphetNetConfig'''],
}

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

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__lowercase	=    [
							    '''XLM_PROPHETNET_PRETRAINED_MODEL_ARCHIVE_LIST''',
							    '''XLMProphetNetDecoder''',
							    '''XLMProphetNetEncoder''',
							    '''XLMProphetNetForCausalLM''',
							    '''XLMProphetNetForConditionalGeneration''',
							    '''XLMProphetNetModel''',
							    '''XLMProphetNetPreTrainedModel''',
							]


if TYPE_CHECKING:
							from .configuration_xlm_prophetnet import XLM_PROPHETNET_PRETRAINED_CONFIG_ARCHIVE_MAP, XLMProphetNetConfig

							try:
														if not is_sentencepiece_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .tokenization_xlm_prophetnet import XLMProphetNetTokenizer

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_xlm_prophetnet import (
														    XLM_PROPHETNET_PRETRAINED_MODEL_ARCHIVE_LIST,
														    XLMProphetNetDecoder,
														    XLMProphetNetEncoder,
														    XLMProphetNetForCausalLM,
														    XLMProphetNetForConditionalGeneration,
														    XLMProphetNetModel,
														    XLMProphetNetPreTrainedModel,
														)

else:
							import sys

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






