

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






					"""simple docstring"""



					def __init__( self    :       Optional[int]     ,lowercase_    :       str     ,lowercase_    :       List[Any]=1_3     ,lowercase_    :       str=6_4     ,lowercase_    :       Any=4     ,lowercase_    :       str=3     ,lowercase_    :       List[Any]=1_6     ,lowercase_    :       Union[str, Any]=[1, 2, 1]     ,lowercase_    :       Optional[Any]=[2, 4, 8]     ,lowercase_    :       Optional[int]=3     ,lowercase_    :       Tuple=2.0     ,lowercase_    :       int=True     ,lowercase_    :       Union[str, Any]=0.0     ,lowercase_    :       Dict=0.0     ,lowercase_    :       Tuple=0.1     ,lowercase_    :       Any="gelu"     ,lowercase_    :       Optional[int]=True     ,lowercase_    :       int=0.02     ,lowercase_    :       Tuple=1E-5     ,lowercase_    :       List[str]=True     ,lowercase_    :       Dict=None     ,lowercase_    :       Union[str, Any]=True     ,lowercase_    :       Tuple=1_0     ,lowercase_    :       Tuple=["stage1", "stage2"]     ,lowercase_    :       Optional[Any]=[1, 2]     ,):
						lowerCAmelCase__			:		Any						       =			parent
						lowerCAmelCase__			:		Tuple						       =			batch_size
						lowerCAmelCase__			:		Tuple						       =			image_size
						lowerCAmelCase__			:		List[str]						       =			patch_size
						lowerCAmelCase__			:		str						       =			num_channels
						lowerCAmelCase__			:		Optional[Any]						       =			embed_dim
						lowerCAmelCase__			:		Dict						       =			depths
						lowerCAmelCase__			:		List[str]						       =			num_heads
						lowerCAmelCase__			:		List[Any]						       =			kernel_size
						lowerCAmelCase__			:		Tuple						       =			mlp_ratio
						lowerCAmelCase__			:		List[Any]						       =			qkv_bias
						lowerCAmelCase__			:		List[str]						       =			hidden_dropout_prob
						lowerCAmelCase__			:		Tuple						       =			attention_probs_dropout_prob
						lowerCAmelCase__			:		List[Any]						       =			drop_path_rate
						lowerCAmelCase__			:		Union[str, Any]						       =			hidden_act
						lowerCAmelCase__			:		Dict						       =			patch_norm
						lowerCAmelCase__			:		str						       =			layer_norm_eps
						lowerCAmelCase__			:		List[str]						       =			initializer_range
						lowerCAmelCase__			:		Tuple						       =			is_training
						lowerCAmelCase__			:		Union[str, Any]						       =			scope
						lowerCAmelCase__			:		List[str]						       =			use_labels
						lowerCAmelCase__			:		Tuple						       =			num_labels
						lowerCAmelCase__			:		Dict						       =			out_features
						lowerCAmelCase__			:		Tuple						       =			out_indices







					def  __lowerCAmelCase				( self    :       Optional[Any]	):
						lowerCAmelCase__			:		str						       =			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

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

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

						return config, pixel_values, labels







					def  __lowerCAmelCase				( self    :       List[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  __lowerCAmelCase				( self    :       Any     ,lowercase_    :       List[str]     ,lowercase_    :       List[str]     ,lowercase_    :       Any	):
						lowerCAmelCase__			:		List[Any]						       =			NatModel(config=lowercase_	)
						model.to(lowercase_	)
						model.eval()
						lowerCAmelCase__			:		int						       =			model(lowercase_	)

						lowerCAmelCase__			:		Optional[int]						       =			(config.image_size // config.patch_size) // (2 ** (len(config.depths	) - 1))
						lowerCAmelCase__			:		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    :       Any     ,lowercase_    :       List[Any]     ,lowercase_    :       Optional[Any]     ,lowercase_    :       Dict	):
						lowerCAmelCase__			:		Union[str, Any]						       =			NatForImageClassification(lowercase_	)
						model.to(lowercase_	)
						model.eval()
						lowerCAmelCase__			:		Dict						       =			model(lowercase_     ,labels=lowercase_	)
						self.parent.assertEqual(result.logits.shape     ,(self.batch_size, self.num_labels)	)

						# test greyscale images
						lowerCAmelCase__			:		Optional[int]						       =			1
						lowerCAmelCase__			:		Any						       =			NatForImageClassification(lowercase_	)
						model.to(lowercase_	)
						model.eval()

						lowerCAmelCase__			:		Optional[Any]						       =			floats_tensor([self.batch_size, 1, self.image_size, self.image_size]	)
						lowerCAmelCase__			:		int						       =			model(lowercase_	)
						self.parent.assertEqual(result.logits.shape     ,(self.batch_size, self.num_labels)	)







					def  __lowerCAmelCase				( self    :       int     ,lowercase_    :       List[Any]     ,lowercase_    :       Optional[int]     ,lowercase_    :       Dict	):
						lowerCAmelCase__			:		str						       =			NatBackbone(config=lowercase_	)
						model.to(lowercase_	)
						model.eval()
						lowerCAmelCase__			:		Optional[int]						       =			model(lowercase_	)

						# 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], 1_6, 1_6]	)

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

						# verify backbone works with out_features=None
						lowerCAmelCase__			:		List[str]						       =			None
						lowerCAmelCase__			:		List[Any]						       =			NatBackbone(config=lowercase_	)
						model.to(lowercase_	)
						model.eval()
						lowerCAmelCase__			:		List[str]						       =			model(lowercase_	)

						# 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	):
						lowerCAmelCase__			:		int						       =			self.prepare_config_and_inputs()
						lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__			:		Optional[int]						       =			config_and_inputs
						lowerCAmelCase__			:		str						       =			{'''pixel_values''': pixel_values}
						return config, inputs_dict







@require_natten
@require_torch
class        SCREAMING_SNAKE_CASE      (	a_					,							a_					,							unittest.TestCase ):






					"""simple docstring"""



					lowercase__       				= (
					    (
					        NatModel,
					        NatForImageClassification,
					        NatBackbone,
					    )
					    if is_torch_available()
					    else ()
					)
					lowercase__       				= (
					    {"feature-extraction": NatModel, "image-classification": NatForImageClassification}
					    if is_torch_available()
					    else {}
					)
					lowercase__       				= False

					lowercase__       				= False
					lowercase__       				= False
					lowercase__       				= False
					lowercase__       				= False







					def  __lowerCAmelCase				( self    :       List[Any]	):
						lowerCAmelCase__			:		Optional[int]						       =			NatModelTester(self	)
						lowerCAmelCase__			:		Union[str, Any]						       =			ConfigTester(self     ,config_class=lowercase_     ,embed_dim=3_7	)







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







					def  __lowerCAmelCase				( self    :       List[Any]	):
						lowerCAmelCase__			:		Optional[Any]						       =			self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*lowercase_	)







					def  __lowerCAmelCase				( self    :       Tuple	):
						lowerCAmelCase__			:		Dict						       =			self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_image_classification(*lowercase_	)







					def  __lowerCAmelCase				( self    :       Union[str, Any]	):
						lowerCAmelCase__			:		str						       =			self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_backbone(*lowercase_	)







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







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







					def  __lowerCAmelCase				( self    :       Union[str, Any]	):
						lowerCAmelCase__       ,lowerCAmelCase__			:		str						       =			self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
							lowerCAmelCase__			:		Tuple						       =			model_class(lowercase_	)
							self.assertIsInstance(model.get_input_embeddings()     ,(nn.Module)	)
							lowerCAmelCase__			:		Dict						       =			model.get_output_embeddings()
							self.assertTrue(x is None or isinstance(lowercase_     ,nn.Linear	)	)







					def  __lowerCAmelCase				( self    :       Dict	):
						lowerCAmelCase__       ,lowerCAmelCase__			:		int						       =			self.model_tester.prepare_config_and_inputs_for_common()

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

							lowerCAmelCase__			:		str						       =			['''pixel_values''']
							self.assertListEqual(arg_names[:1]     ,lowercase_	)







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







					def  __lowerCAmelCase				( self    :       Optional[int]     ,lowercase_    :       List[str]     ,lowercase_    :       Any     ,lowercase_    :       Optional[int]     ,lowercase_    :       str	):
						lowerCAmelCase__			:		List[Any]						       =			model_class(lowercase_	)
						model.to(lowercase_	)
						model.eval()

						with torch.no_grad():
							lowerCAmelCase__			:		int						       =			model(**self._prepare_for_class(lowercase_     ,lowercase_	)	)

						lowerCAmelCase__			:		Optional[int]						       =			outputs.hidden_states

						lowerCAmelCase__			:		Dict						       =			getattr(
						    self.model_tester     ,'''expected_num_hidden_layers'''     ,len(self.model_tester.depths	) + 1	)
						self.assertEqual(len(lowercase_	)     ,lowercase_	)

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

						lowerCAmelCase__			:		Dict						       =			image_size[0] // patch_size[0]
						lowerCAmelCase__			:		List[str]						       =			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__			:		Optional[Any]						       =			outputs.reshaped_hidden_states
							self.assertEqual(len(lowercase_	)     ,lowercase_	)

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







					def  __lowerCAmelCase				( self    :       List[Any]	):
						lowerCAmelCase__       ,lowerCAmelCase__			:		Tuple						       =			self.model_tester.prepare_config_and_inputs_for_common()

						lowerCAmelCase__			:		Dict						       =			(
						    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__			:		Tuple						       =			True
							self.check_hidden_states_output(lowercase_     ,lowercase_     ,lowercase_     ,lowercase_	)

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

							self.check_hidden_states_output(lowercase_     ,lowercase_     ,lowercase_     ,lowercase_	)







					@slow
					def  __lowerCAmelCase				( self    :       List[str]	):
						for model_name in NAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							lowerCAmelCase__			:		Union[str, Any]						       =			NatModel.from_pretrained(lowercase_	)
							self.assertIsNotNone(lowercase_	)







					def  __lowerCAmelCase				( self    :       List[str]	):
						lowerCAmelCase__       ,lowerCAmelCase__			:		Dict						       =			self.model_tester.prepare_config_and_inputs_for_common()

						lowerCAmelCase__			:		List[Any]						       =			_config_zero_init(lowercase_	)
						for model_class in self.all_model_classes:
							lowerCAmelCase__			:		List[Any]						       =			model_class(config=lowercase_	)
							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 ):






					"""simple docstring"""



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







					@slow
					def  __lowerCAmelCase				( self    :       Optional[int]	):
						lowerCAmelCase__			:		str						       =			NatForImageClassification.from_pretrained('''shi-labs/nat-mini-in1k-224'''	).to(lowercase_	)
						lowerCAmelCase__			:		List[Any]						       =			self.default_image_processor

						lowerCAmelCase__			:		Optional[Any]						       =			Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''	)
						lowerCAmelCase__			:		Any						       =			image_processor(images=lowercase_     ,return_tensors='''pt'''	).to(lowercase_	)

						# forward pass
						with torch.no_grad():
							lowerCAmelCase__			:		Union[str, Any]						       =			model(**lowercase_	)

						# verify the logits
						lowerCAmelCase__			:		Optional[Any]						       =			torch.Size((1, 1_0_0_0)	)
						self.assertEqual(outputs.logits.shape     ,lowercase_	)
						lowerCAmelCase__			:		Union[str, Any]						       =			torch.tensor([0.3805, -0.8676, -0.3912]	).to(lowercase_	)
						self.assertTrue(torch.allclose(outputs.logits[0, :3]     ,lowercase_     ,atol=1E-4	)	)







@require_torch
@require_natten
class        SCREAMING_SNAKE_CASE      (	unittest.TestCase					,							a_ ):






					"""simple docstring"""



					lowercase__       				= (NatBackbone,) if is_torch_available() else ()
					lowercase__       				= NatConfig







					def  __lowerCAmelCase				( self    :       Optional[int]	):
						lowerCAmelCase__			:		List[Any]						       =			NatModelTester(self	)







"""simple docstring"""





from typing import TYPE_CHECKING

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


__UpperCamelCase						:   Union[str, Any]							   =	{
    '''configuration_layoutlm''': ['''LAYOUTLM_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''LayoutLMConfig''', '''LayoutLMOnnxConfig'''],
    '''tokenization_layoutlm''': ['''LayoutLMTokenizer'''],
}

try:
							if not is_tokenizers_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__UpperCamelCase						:   Union[str, Any]							   =	['''LayoutLMTokenizerFast''']

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__UpperCamelCase						:   Dict							   =	[
							    '''LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST''',
							    '''LayoutLMForMaskedLM''',
							    '''LayoutLMForSequenceClassification''',
							    '''LayoutLMForTokenClassification''',
							    '''LayoutLMForQuestionAnswering''',
							    '''LayoutLMModel''',
							    '''LayoutLMPreTrainedModel''',
							]

try:
							if not is_tf_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__UpperCamelCase						:   str							   =	[
							    '''TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST''',
							    '''TFLayoutLMForMaskedLM''',
							    '''TFLayoutLMForSequenceClassification''',
							    '''TFLayoutLMForTokenClassification''',
							    '''TFLayoutLMForQuestionAnswering''',
							    '''TFLayoutLMMainLayer''',
							    '''TFLayoutLMModel''',
							    '''TFLayoutLMPreTrainedModel''',
							]


if TYPE_CHECKING:
							from .configuration_layoutlm import LAYOUTLM_PRETRAINED_CONFIG_ARCHIVE_MAP, LayoutLMConfig, LayoutLMOnnxConfig
							from .tokenization_layoutlm import LayoutLMTokenizer

							try:
														if not is_tokenizers_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .tokenization_layoutlm_fast import LayoutLMTokenizerFast

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_layoutlm import (
														    LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST,
														    LayoutLMForMaskedLM,
														    LayoutLMForQuestionAnswering,
														    LayoutLMForSequenceClassification,
														    LayoutLMForTokenClassification,
														    LayoutLMModel,
														    LayoutLMPreTrainedModel,
														)
							try:
														if not is_tf_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_tf_layoutlm import (
														    TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST,
														    TFLayoutLMForMaskedLM,
														    TFLayoutLMForQuestionAnswering,
														    TFLayoutLMForSequenceClassification,
														    TFLayoutLMForTokenClassification,
														    TFLayoutLMMainLayer,
														    TFLayoutLMModel,
														    TFLayoutLMPreTrainedModel,
														)

else:
							import sys

							__UpperCamelCase						:   int							   =	_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)




