



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



			def __init__(     self		:						List[Any]    ,			__UpperCamelCase		:						Optional[Any]    ,			__UpperCamelCase		:						List[Any]=13    ,			__UpperCamelCase		:						str=64    ,			__UpperCamelCase		:						Any=4    ,			__UpperCamelCase		:						str=3    ,			__UpperCamelCase		:						int=16    ,			__UpperCamelCase		:						Any=[1, 2, 1]    ,			__UpperCamelCase		:						str=[2, 4, 8]    ,			__UpperCamelCase		:						str=3    ,			__UpperCamelCase		:						Dict=2.0    ,			__UpperCamelCase		:						List[str]=True    ,			__UpperCamelCase		:						Tuple=0.0    ,			__UpperCamelCase		:						Optional[int]=0.0    ,			__UpperCamelCase		:						Any=0.1    ,			__UpperCamelCase		:						Optional[Any]="gelu"    ,			__UpperCamelCase		:						str=True    ,			__UpperCamelCase		:						Union[str, Any]=0.02    ,			__UpperCamelCase		:						Optional[int]=1e-5    ,			__UpperCamelCase		:						List[Any]=True    ,			__UpperCamelCase		:						Union[str, Any]=None    ,			__UpperCamelCase		:						List[str]=True    ,			__UpperCamelCase		:						List[str]=10    ,			__UpperCamelCase		:						Optional[Any]=["stage1", "stage2"]    ,			__UpperCamelCase		:						Union[str, Any]=[1, 2]    ,			)      ->      Optional[int]:
							"""simple docstring"""





							snake_case__      :   Union[str, Any]      =    parent
							snake_case__      :   Any      =    batch_size
							snake_case__      :   Optional[Any]      =    image_size
							snake_case__      :   Tuple      =    patch_size
							snake_case__      :   int      =    num_channels
							snake_case__      :   Optional[int]      =    embed_dim
							snake_case__      :   Dict      =    depths
							snake_case__      :   Union[str, Any]      =    num_heads
							snake_case__      :   Dict      =    kernel_size
							snake_case__      :   Optional[Any]      =    mlp_ratio
							snake_case__      :   Tuple      =    qkv_bias
							snake_case__      :   str      =    hidden_dropout_prob
							snake_case__      :   Dict      =    attention_probs_dropout_prob
							snake_case__      :   Optional[Any]      =    drop_path_rate
							snake_case__      :   Dict      =    hidden_act
							snake_case__      :   int      =    patch_norm
							snake_case__      :   List[str]      =    layer_norm_eps
							snake_case__      :   str      =    initializer_range
							snake_case__      :   Tuple      =    is_training
							snake_case__      :   Optional[Any]      =    scope
							snake_case__      :   Optional[int]      =    use_labels
							snake_case__      :   Any      =    num_labels
							snake_case__      :   Any      =    out_features
							snake_case__      :   Tuple      =    out_indices



			def 				lowerCAmelCase (     self		:						Any			)      ->      int:
							"""simple docstring"""





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

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

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

							return config, pixel_values, labels



			def 				lowerCAmelCase (     self		:						str			)      ->      Union[str, Any]:
							"""simple docstring"""





							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 				lowerCAmelCase (     self		:						Optional[int]    ,			__UpperCamelCase		:						List[Any]    ,			__UpperCamelCase		:						str    ,			__UpperCamelCase		:						Union[str, Any]			)      ->      List[Any]:
							"""simple docstring"""





							snake_case__      :   Optional[int]      =    NatModel(config=__UpperCamelCase			)
							model.to(__UpperCamelCase			)
							model.eval()
							snake_case__      :   Optional[Any]      =    model(__UpperCamelCase			)

							snake_case__      :   Any      =    (config.image_size // config.patch_size) // (2 ** (len(config.depths			) - 1))
							snake_case__      :   Union[str, Any]      =    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 				lowerCAmelCase (     self		:						str    ,			__UpperCamelCase		:						List[Any]    ,			__UpperCamelCase		:						List[Any]    ,			__UpperCamelCase		:						Any			)      ->      Optional[Any]:
							"""simple docstring"""





							snake_case__      :   Optional[Any]      =    NatForImageClassification(__UpperCamelCase			)
							model.to(__UpperCamelCase			)
							model.eval()
							snake_case__      :   str      =    model(__UpperCamelCase    ,			labels=__UpperCamelCase			)
							self.parent.assertEqual(result.logits.shape    ,			(self.batch_size, self.num_labels)			)

							# test greyscale images
							snake_case__      :   Union[str, Any]      =    1
							snake_case__      :   str      =    NatForImageClassification(__UpperCamelCase			)
							model.to(__UpperCamelCase			)
							model.eval()

							snake_case__      :   Dict      =    floats_tensor([self.batch_size, 1, self.image_size, self.image_size]			)
							snake_case__      :   List[str]      =    model(__UpperCamelCase			)
							self.parent.assertEqual(result.logits.shape    ,			(self.batch_size, self.num_labels)			)



			def 				lowerCAmelCase (     self		:						List[Any]    ,			__UpperCamelCase		:						Optional[int]    ,			__UpperCamelCase		:						Optional[Any]    ,			__UpperCamelCase		:						List[Any]			)      ->      Tuple:
							"""simple docstring"""





							snake_case__      :   Dict      =    NatBackbone(config=__UpperCamelCase			)
							model.to(__UpperCamelCase			)
							model.eval()
							snake_case__      :   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
							snake_case__      :   str      =    None
							snake_case__      :   int      =    NatBackbone(config=__UpperCamelCase			)
							model.to(__UpperCamelCase			)
							model.eval()
							snake_case__      :   Any      =    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 				lowerCAmelCase (     self		:						str			)      ->      List[str]:
							"""simple docstring"""





							snake_case__      :   str      =    self.prepare_config_and_inputs()
							snake_case__  ,      snake_case__  ,      snake_case__      :   Any      =    config_and_inputs
							snake_case__      :   Optional[Any]      =    {'''pixel_values''': pixel_values}
							return config, inputs_dict






@require_natten
@require_torch
class 			_SCREAMING_SNAKE_CASE				(lowercase__,	lowercase__,	unittest.TestCase      ):
			A__								=  (
			    (
			        NatModel,
			        NatForImageClassification,
			        NatBackbone,
			    )
			    if is_torch_available()
			    else ()
			)
			A__								=  (
			    {'feature-extraction': NatModel, 'image-classification': NatForImageClassification}
			    if is_torch_available()
			    else {}
			)
			A__								=  False

			A__								=  False
			A__								=  False
			A__								=  False
			A__								=  False



			def 				lowerCAmelCase (     self		:						Union[str, Any]			)      ->      int:
							"""simple docstring"""





							snake_case__      :   Dict      =    NatModelTester(self			)
							snake_case__      :   Union[str, Any]      =    ConfigTester(self    ,			config_class=__UpperCamelCase    ,			embed_dim=37			)



			def 				lowerCAmelCase (     self		:						Optional[Any]			)      ->      Optional[int]:
							"""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]			)      ->      List[str]:
							"""simple docstring"""





							return



			def 				lowerCAmelCase (     self		:						Any			)      ->      Tuple:
							"""simple docstring"""





							snake_case__      :   Tuple      =    self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*__UpperCamelCase			)



			def 				lowerCAmelCase (     self		:						List[Any]			)      ->      Any:
							"""simple docstring"""





							snake_case__      :   str      =    self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*__UpperCamelCase			)



			def 				lowerCAmelCase (     self		:						List[Any]			)      ->      Any:
							"""simple docstring"""





							snake_case__      :   List[Any]      =    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 				lowerCAmelCase (     self		:						Tuple			)      ->      Union[str, Any]:
							"""simple docstring"""





							pass



			@unittest.skip(reason='''Nat does not use feedforward chunking'''			)
			def 				lowerCAmelCase (     self		:						int			)      ->      List[str]:
							"""simple docstring"""





							pass



			def 				lowerCAmelCase (     self		:						int			)      ->      Tuple:
							"""simple docstring"""





							snake_case__  ,      snake_case__      :   Optional[Any]      =    self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
											snake_case__      :   Dict      =    model_class(__UpperCamelCase			)
											self.assertIsInstance(model.get_input_embeddings()    ,			(nn.Module)			)
											snake_case__      :   List[str]      =    model.get_output_embeddings()
											self.assertTrue(x is None or isinstance(__UpperCamelCase    ,			nn.Linear			)			)



			def 				lowerCAmelCase (     self		:						List[Any]			)      ->      Optional[Any]:
							"""simple docstring"""





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

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

											snake_case__      :   Optional[Any]      =    ['''pixel_values''']
											self.assertListEqual(arg_names[:1]    ,			__UpperCamelCase			)



			def 				lowerCAmelCase (     self		:						Any			)      ->      Optional[Any]:
							"""simple docstring"""





							self.skipTest('''Nat\'s attention operation is handled entirely by NATTEN.'''			)



			def 				lowerCAmelCase (     self		:						Dict    ,			__UpperCamelCase		:						Union[str, Any]    ,			__UpperCamelCase		:						List[Any]    ,			__UpperCamelCase		:						Optional[int]    ,			__UpperCamelCase		:						str			)      ->      int:
							"""simple docstring"""





							snake_case__      :   Dict      =    model_class(__UpperCamelCase			)
							model.to(__UpperCamelCase			)
							model.eval()

							with torch.no_grad():
											snake_case__      :   int      =    model(**self._prepare_for_class(__UpperCamelCase    ,			__UpperCamelCase			)			)

							snake_case__      :   Optional[Any]      =    outputs.hidden_states

							snake_case__      :   List[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
							snake_case__      :   Tuple      =    (
							    config.patch_size
							    if isinstance(config.patch_size    ,			collections.abc.Iterable			)
							    else (config.patch_size, config.patch_size)
							)

							snake_case__      :   Dict      =    image_size[0] // patch_size[0]
							snake_case__      :   Optional[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":
											snake_case__      :   Optional[int]      =    outputs.reshaped_hidden_states
											self.assertEqual(len(__UpperCamelCase			)    ,			__UpperCamelCase			)

											snake_case__  ,      snake_case__  ,      snake_case__  ,      snake_case__      :   int      =    reshaped_hidden_states[0].shape
											snake_case__      :   List[str]      =    (
											    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 				lowerCAmelCase (     self		:						Optional[Any]			)      ->      Union[str, Any]:
							"""simple docstring"""





							snake_case__  ,      snake_case__      :   Dict      =    self.model_tester.prepare_config_and_inputs_for_common()

							snake_case__      :   Any      =    (
							    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:
											snake_case__      :   int      =    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"]
											snake_case__      :   Tuple      =    True

											self.check_hidden_states_output(__UpperCamelCase    ,			__UpperCamelCase    ,			__UpperCamelCase    ,			__UpperCamelCase			)



			@slow
			def 				lowerCAmelCase (     self		:						int			)      ->      Optional[Any]:
							"""simple docstring"""





							for model_name in NAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											snake_case__      :   int      =    NatModel.from_pretrained(__UpperCamelCase			)
											self.assertIsNotNone(__UpperCamelCase			)







			def 				lowerCAmelCase (     self		:						Tuple			)      ->      str:
							"""simple docstring"""





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

							snake_case__      :   List[str]      =    _config_zero_init(__UpperCamelCase			)
							for model_class in self.all_model_classes:
											snake_case__      :   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 			_SCREAMING_SNAKE_CASE				(unittest.TestCase      ):



			@cached_property
			def 				lowerCAmelCase (     self		:						int			)      ->      Optional[int]:
							"""simple docstring"""





							return AutoImageProcessor.from_pretrained('''shi-labs/nat-mini-in1k-224'''			) if is_vision_available() else None







			@slow
			def 				lowerCAmelCase (     self		:						Union[str, Any]			)      ->      Optional[Any]:
							"""simple docstring"""





							snake_case__      :   str      =    NatForImageClassification.from_pretrained('''shi-labs/nat-mini-in1k-224'''			).to(__UpperCamelCase			)
							snake_case__      :   Tuple      =    self.default_image_processor

							snake_case__      :   Dict      =    Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''			)
							snake_case__      :   str      =    image_processor(images=__UpperCamelCase    ,			return_tensors='''pt'''			).to(__UpperCamelCase			)

							# forward pass
							with torch.no_grad():
											snake_case__      :   List[Any]      =    model(**__UpperCamelCase			)

							# verify the logits
							snake_case__      :   str      =    torch.Size((1, 1000)			)
							self.assertEqual(outputs.logits.shape    ,			__UpperCamelCase			)
							snake_case__      :   Union[str, Any]      =    torch.tensor([0.3805, -0.8676, -0.3912]			).to(__UpperCamelCase			)
							self.assertTrue(torch.allclose(outputs.logits[0, :3]    ,			__UpperCamelCase    ,			atol=1e-4			)			)






@require_torch
@require_natten
class 			_SCREAMING_SNAKE_CASE				(unittest.TestCase,	lowercase__      ):
			A__								=  (NatBackbone,) if is_torch_available() else ()
			A__								=  NatConfig



			def 				lowerCAmelCase (     self		:						Optional[int]			)      ->      int:
							"""simple docstring"""





							snake_case__      :   int      =    NatModelTester(self			)









'''simple docstring'''



from typing import TYPE_CHECKING

from ...utils import _LazyModule


_lowercase       :						List[str]						={"tokenization_bert_japanese": ["BertJapaneseTokenizer", "CharacterTokenizer", "MecabTokenizer"]}


if TYPE_CHECKING:
				from .tokenization_bert_japanese import BertJapaneseTokenizer, CharacterTokenizer, MecabTokenizer

else:
				import sys

				_lowercase       :						Dict						=_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)




