





import collections
import inspect
import unittest

from transformers import DinatConfig
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 DinatBackbone, DinatForImageClassification, DinatModel
	from transformers.models.dinat.modeling_dinat import DINAT_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
	from PIL import Image

	from transformers import AutoImageProcessor




class      UpperCamelCase_				:


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



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=					parent
									SCREAMING_SNAKE_CASE__								=					batch_size
									SCREAMING_SNAKE_CASE__								=					image_size
									SCREAMING_SNAKE_CASE__								=					patch_size
									SCREAMING_SNAKE_CASE__								=					num_channels
									SCREAMING_SNAKE_CASE__								=					embed_dim
									SCREAMING_SNAKE_CASE__								=					depths
									SCREAMING_SNAKE_CASE__								=					num_heads
									SCREAMING_SNAKE_CASE__								=					kernel_size
									SCREAMING_SNAKE_CASE__								=					dilations
									SCREAMING_SNAKE_CASE__								=					mlp_ratio
									SCREAMING_SNAKE_CASE__								=					qkv_bias
									SCREAMING_SNAKE_CASE__								=					hidden_dropout_prob
									SCREAMING_SNAKE_CASE__								=					attention_probs_dropout_prob
									SCREAMING_SNAKE_CASE__								=					drop_path_rate
									SCREAMING_SNAKE_CASE__								=					hidden_act
									SCREAMING_SNAKE_CASE__								=					patch_norm
									SCREAMING_SNAKE_CASE__								=					layer_norm_eps
									SCREAMING_SNAKE_CASE__								=					initializer_range
									SCREAMING_SNAKE_CASE__								=					is_training
									SCREAMING_SNAKE_CASE__								=					scope
									SCREAMING_SNAKE_CASE__								=					use_labels
									SCREAMING_SNAKE_CASE__								=					num_labels
									SCREAMING_SNAKE_CASE__								=					out_features
									SCREAMING_SNAKE_CASE__								=					out_indices


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



									"""simple docstring"""



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

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

									SCREAMING_SNAKE_CASE__								=					self.get_config()

									return config, pixel_values, labels


							def    _snake_case     (							self			:List[Any]						)      ->      List[Any]:



									"""simple docstring"""



									return DinatConfig(
									    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							, dilations=self.dilations							, 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    _snake_case     (							self			:List[str]							, __A			:Tuple							, __A			:Dict							, __A			:int						)      ->      Any:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=					DinatModel(config=__A						)
									model.to(__A						)
									model.eval()
									SCREAMING_SNAKE_CASE__								=					model(__A						)

									SCREAMING_SNAKE_CASE__								=					SCREAMING_SNAKE_CASE__								=					(config.image_size // config.patch_size) // (2 ** (len(config.depths						) - 1))
									SCREAMING_SNAKE_CASE__								=					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    _snake_case     (							self			:int							, __A			:Any							, __A			:List[Any]							, __A			:List[Any]						)      ->      Optional[int]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=					DinatForImageClassification(__A						)
									model.to(__A						)
									model.eval()
									SCREAMING_SNAKE_CASE__								=					model(__A							, labels=__A						)
									self.parent.assertEqual(result.logits.shape							, (self.batch_size, self.num_labels)						)

									# test greyscale images
									SCREAMING_SNAKE_CASE__								=					1
									SCREAMING_SNAKE_CASE__								=					DinatForImageClassification(__A						)
									model.to(__A						)
									model.eval()

									SCREAMING_SNAKE_CASE__								=					floats_tensor([self.batch_size, 1, self.image_size, self.image_size]						)
									SCREAMING_SNAKE_CASE__								=					model(__A						)
									self.parent.assertEqual(result.logits.shape							, (self.batch_size, self.num_labels)						)


							def    _snake_case     (							self			:int							, __A			:List[Any]							, __A			:Optional[Any]							, __A			:Union[str, Any]						)      ->      str:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=					DinatBackbone(config=__A						)
									model.to(__A						)
									model.eval()
									SCREAMING_SNAKE_CASE__								=					model(__A						)

									# 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
									SCREAMING_SNAKE_CASE__								=					None
									SCREAMING_SNAKE_CASE__								=					DinatBackbone(config=__A						)
									model.to(__A						)
									model.eval()
									SCREAMING_SNAKE_CASE__								=					model(__A						)

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



									"""simple docstring"""



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




@require_natten
@require_torch
class      UpperCamelCase_				(   UpperCamelCase__ ,     UpperCamelCase__ ,     unittest.TestCase			):
							lowerCamelCase_							=    (
							    (
							        DinatModel,
							        DinatForImageClassification,
							        DinatBackbone,
							    )
							    if is_torch_available()
							    else ()
							)
							lowerCamelCase_							=    (
							    {"feature-extraction": DinatModel, "image-classification": DinatForImageClassification}
							    if is_torch_available()
							    else {}
							)
							lowerCamelCase_							=    False

							lowerCamelCase_							=    False
							lowerCamelCase_							=    False
							lowerCamelCase_							=    False
							lowerCamelCase_							=    False


							def    _snake_case     (							self			:List[Any]						)      ->      int:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=					DinatModelTester(self						)
									SCREAMING_SNAKE_CASE__								=					ConfigTester(self							, config_class=__A							, embed_dim=37						)


							def    _snake_case     (							self			:int						)      ->      Dict:



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



									"""simple docstring"""



									return


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



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*__A						)


							def    _snake_case     (							self			:Optional[Any]						)      ->      List[Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*__A						)


							def    _snake_case     (							self			:Optional[Any]						)      ->      str:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_backbone(*__A						)


							@unittest.skip(reason="""Dinat does not use inputs_embeds"""						)
							def    _snake_case     (							self			:Dict						)      ->      Optional[int]:



									"""simple docstring"""



									pass


							@unittest.skip(reason="""Dinat does not use feedforward chunking"""						)
							def    _snake_case     (							self			:List[str]						)      ->      str:



									"""simple docstring"""



									pass


							def    _snake_case     (							self			:Tuple						)      ->      int:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__		,  SCREAMING_SNAKE_CASE__								=					self.model_tester.prepare_config_and_inputs_for_common()

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


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



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__		,  SCREAMING_SNAKE_CASE__								=					self.model_tester.prepare_config_and_inputs_for_common()

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

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


							def    _snake_case     (							self			:Optional[int]						)      ->      Optional[int]:



									"""simple docstring"""



									self.skipTest("""Dinat's attention operation is handled entirely by NATTEN."""						)


							def    _snake_case     (							self			:Optional[Any]							, __A			:Tuple							, __A			:Optional[Any]							, __A			:Union[str, Any]							, __A			:int						)      ->      Optional[Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=					model_class(__A						)
									model.to(__A						)
									model.eval()

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

									SCREAMING_SNAKE_CASE__								=					outputs.hidden_states

									SCREAMING_SNAKE_CASE__								=					getattr(
									    self.model_tester							, """expected_num_hidden_layers"""							, len(self.model_tester.depths						) + 1						)
									self.assertEqual(len(__A						)							, __A						)

									# Dinat has a different seq_length
									SCREAMING_SNAKE_CASE__								=					(
									    config.patch_size
									    if isinstance(config.patch_size							, collections.abc.Iterable						)
									    else (config.patch_size, config.patch_size)
									)

									SCREAMING_SNAKE_CASE__								=					image_size[0] // patch_size[0]
									SCREAMING_SNAKE_CASE__								=					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__ != "DinatBackbone":
											SCREAMING_SNAKE_CASE__								=					outputs.reshaped_hidden_states
											self.assertEqual(len(__A						)							, __A						)

											SCREAMING_SNAKE_CASE__		,  SCREAMING_SNAKE_CASE__		,  SCREAMING_SNAKE_CASE__		,  SCREAMING_SNAKE_CASE__								=					reshaped_hidden_states[0].shape
											SCREAMING_SNAKE_CASE__								=					(
											    reshaped_hidden_states[0].view(__A							, __A							, __A							, __A						).permute(0							, 2							, 3							, 1						)
											)
											self.assertListEqual(
											    list(reshaped_hidden_states.shape[-3:]						)							, [height, width, self.model_tester.embed_dim]							, )


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



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__		,  SCREAMING_SNAKE_CASE__								=					self.model_tester.prepare_config_and_inputs_for_common()

									SCREAMING_SNAKE_CASE__								=					(
									    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:
											SCREAMING_SNAKE_CASE__								=					True
											self.check_hidden_states_output(__A							, __A							, __A							, __A						)

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

											self.check_hidden_states_output(__A							, __A							, __A							, __A						)


							@slow
							def    _snake_case     (							self			:Optional[int]						)      ->      Optional[int]:



									"""simple docstring"""



									for model_name in DINAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											SCREAMING_SNAKE_CASE__								=					DinatModel.from_pretrained(__A						)
											self.assertIsNotNone(__A						)


							def    _snake_case     (							self			:List[Any]						)      ->      Optional[Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__		,  SCREAMING_SNAKE_CASE__								=					self.model_tester.prepare_config_and_inputs_for_common()

									SCREAMING_SNAKE_CASE__								=					_config_zero_init(__A						)
									for model_class in self.all_model_classes:
											SCREAMING_SNAKE_CASE__								=					model_class(config=__A						)
											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      UpperCamelCase_				(   unittest.TestCase			):


							@cached_property
							def    _snake_case     (							self			:Optional[Any]						)      ->      Union[str, Any]:



									"""simple docstring"""



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


							@slow
							def    _snake_case     (							self			:Dict						)      ->      Dict:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=					DinatForImageClassification.from_pretrained("""shi-labs/dinat-mini-in1k-224"""						).to(__A						)
									SCREAMING_SNAKE_CASE__								=					self.default_image_processor

									SCREAMING_SNAKE_CASE__								=					Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""						)
									SCREAMING_SNAKE_CASE__								=					image_processor(images=__A							, return_tensors="""pt"""						).to(__A						)

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

									# verify the logits
									SCREAMING_SNAKE_CASE__								=					torch.Size((1, 1000)						)
									self.assertEqual(outputs.logits.shape							, __A						)
									SCREAMING_SNAKE_CASE__								=					torch.tensor([-0.1_5_4_5, -0.7_6_6_7, 0.4_6_4_2]						).to(__A						)
									self.assertTrue(torch.allclose(outputs.logits[0, :3]							, __A							, atol=1E-4						)						)




@require_torch
@require_natten
class      UpperCamelCase_				(   unittest.TestCase ,     UpperCamelCase__			):
							lowerCamelCase_							=    (DinatBackbone,) if is_torch_available() else ()
							lowerCamelCase_							=    DinatConfig


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



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=					DinatModelTester(self						)






from typing import TYPE_CHECKING

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


_lowerCamelCase       =	{
    'configuration_gptsan_japanese': ['GPTSAN_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP', 'GPTSanJapaneseConfig'],
    'tokenization_gptsan_japanese': ['GPTSanJapaneseTokenizer'],
}

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	_lowerCamelCase       =	[
	    'GPTSAN_JAPANESE_PRETRAINED_MODEL_ARCHIVE_LIST',
	    'GPTSanJapaneseForConditionalGeneration',
	    'GPTSanJapaneseModel',
	    'GPTSanJapanesePreTrainedModel',
	]
	_lowerCamelCase       =	[
	    'GPTSanJapaneseTokenizer',
	]


if TYPE_CHECKING:
	from .configuration_gptsan_japanese import GPTSAN_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTSanJapaneseConfig
	from .tokenization_gptsan_japanese import GPTSanJapaneseTokenizer

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_gptsan_japanese import (
		    GPTSAN_JAPANESE_PRETRAINED_MODEL_ARCHIVE_LIST,
		    GPTSanJapaneseForConditionalGeneration,
		    GPTSanJapaneseModel,
		    GPTSanJapanesePreTrainedModel,
		)
		from .tokenization_gptsan_japanese import GPTSanJapaneseTokenizer


else:
	import sys

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