
'''simple docstring'''

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





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


				"""simple docstring"""

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





	def 							__SCREAMING_SNAKE_CASE  (					self			:       str							):


				"""simple docstring"""

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

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

				lowerCAmelCase__								=							self.get_config()

				return config, pixel_values, labels





	def 							__SCREAMING_SNAKE_CASE  (					self			:       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 							__SCREAMING_SNAKE_CASE  (					self			:       str      ,							__magic_name__			:       List[Any]      ,							__magic_name__			:       Optional[Any]      ,							__magic_name__			:       Any							):


				"""simple docstring"""

				lowerCAmelCase__								=							DinatModel(config=__magic_name__							)
				model.to(__magic_name__							)
				model.eval()
				lowerCAmelCase__								=							model(__magic_name__							)

				lowerCAmelCase__								=							lowerCAmelCase__								=							(config.image_size // config.patch_size) // (2 ** (len(config.depths							) - 1))
				lowerCAmelCase__								=							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 							__SCREAMING_SNAKE_CASE  (					self			:       Union[str, Any]      ,							__magic_name__			:       Optional[Any]      ,							__magic_name__			:       Tuple      ,							__magic_name__			:       int							):


				"""simple docstring"""

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

				# test greyscale images
				lowerCAmelCase__								=							1
				lowerCAmelCase__								=							DinatForImageClassification(__magic_name__							)
				model.to(__magic_name__							)
				model.eval()

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





	def 							__SCREAMING_SNAKE_CASE  (					self			:       int      ,							__magic_name__			:       int      ,							__magic_name__			:       Tuple      ,							__magic_name__			:       List[str]							):


				"""simple docstring"""

				lowerCAmelCase__								=							DinatBackbone(config=__magic_name__							)
				model.to(__magic_name__							)
				model.eval()
				lowerCAmelCase__								=							model(__magic_name__							)

				# 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__								=							None
				lowerCAmelCase__								=							DinatBackbone(config=__magic_name__							)
				model.to(__magic_name__							)
				model.eval()
				lowerCAmelCase__								=							model(__magic_name__							)

				# 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 							__SCREAMING_SNAKE_CASE  (					self			:       Tuple							):


				"""simple docstring"""

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






@require_natten
@require_torch
class    A     (	SCREAMING_SNAKE_CASE__  ,      SCREAMING_SNAKE_CASE__  ,      unittest.TestCase    ):
	snake_case__      :Tuple        =     (
	    (
	        DinatModel,
	        DinatForImageClassification,
	        DinatBackbone,
	    )
	    if is_torch_available()
	    else ()
	)
	snake_case__      :Union[str, Any]        =     (
	    {'feature-extraction': DinatModel, 'image-classification': DinatForImageClassification}
	    if is_torch_available()
	    else {}
	)
	snake_case__      :Dict        =     False

	snake_case__      :Optional[Any]        =     False
	snake_case__      :int        =     False
	snake_case__      :List[Any]        =     False
	snake_case__      :Optional[int]        =     False





	def 							__SCREAMING_SNAKE_CASE  (					self			:       List[str]							):


				"""simple docstring"""

				lowerCAmelCase__								=							DinatModelTester(self							)
				lowerCAmelCase__								=							ConfigTester(self      ,							config_class=__magic_name__      ,							embed_dim=37							)





	def 							__SCREAMING_SNAKE_CASE  (					self			:       Tuple							):


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


				"""simple docstring"""

				return





	def 							__SCREAMING_SNAKE_CASE  (					self			:       Optional[int]							):


				"""simple docstring"""

				lowerCAmelCase__								=							self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*__magic_name__							)





	def 							__SCREAMING_SNAKE_CASE  (					self			:       Optional[int]							):


				"""simple docstring"""

				lowerCAmelCase__								=							self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_image_classification(*__magic_name__							)





	def 							__SCREAMING_SNAKE_CASE  (					self			:       int							):


				"""simple docstring"""

				lowerCAmelCase__								=							self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_backbone(*__magic_name__							)





	@unittest.skip(reason="Dinat does not use inputs_embeds"							)
	def 							__SCREAMING_SNAKE_CASE  (					self			:       List[str]							):


				"""simple docstring"""

				pass





	@unittest.skip(reason="Dinat does not use feedforward chunking"							)
	def 							__SCREAMING_SNAKE_CASE  (					self			:       Optional[int]							):


				"""simple docstring"""

				pass





	def 							__SCREAMING_SNAKE_CASE  (					self			:       List[Any]							):


				"""simple docstring"""

				lowerCAmelCase__	,lowerCAmelCase__								=							self.model_tester.prepare_config_and_inputs_for_common()

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





	def 							__SCREAMING_SNAKE_CASE  (					self			:       Optional[Any]							):


				"""simple docstring"""

				lowerCAmelCase__	,lowerCAmelCase__								=							self.model_tester.prepare_config_and_inputs_for_common()

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

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





	def 							__SCREAMING_SNAKE_CASE  (					self			:       Optional[Any]							):


				"""simple docstring"""

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





	def 							__SCREAMING_SNAKE_CASE  (					self			:       Dict      ,							__magic_name__			:       Union[str, Any]      ,							__magic_name__			:       Union[str, Any]      ,							__magic_name__			:       List[str]      ,							__magic_name__			:       List[Any]							):


				"""simple docstring"""

				lowerCAmelCase__								=							model_class(__magic_name__							)
				model.to(__magic_name__							)
				model.eval()

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

				lowerCAmelCase__								=							outputs.hidden_states

				lowerCAmelCase__								=							getattr(
				    self.model_tester      ,							"expected_num_hidden_layers"      ,							len(self.model_tester.depths							) + 1							)
				self.assertEqual(len(__magic_name__							)      ,							__magic_name__							)

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

				lowerCAmelCase__								=							image_size[0] // patch_size[0]
				lowerCAmelCase__								=							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":
							lowerCAmelCase__								=							outputs.reshaped_hidden_states
							self.assertEqual(len(__magic_name__							)      ,							__magic_name__							)

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





	def 							__SCREAMING_SNAKE_CASE  (					self			:       Tuple							):


				"""simple docstring"""

				lowerCAmelCase__	,lowerCAmelCase__								=							self.model_tester.prepare_config_and_inputs_for_common()

				lowerCAmelCase__								=							(
				    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__								=							True
							self.check_hidden_states_output(__magic_name__      ,							__magic_name__      ,							__magic_name__      ,							__magic_name__							)

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

							self.check_hidden_states_output(__magic_name__      ,							__magic_name__      ,							__magic_name__      ,							__magic_name__							)





	@slow
	def 							__SCREAMING_SNAKE_CASE  (					self			:       Dict							):


				"""simple docstring"""

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







	def 							__SCREAMING_SNAKE_CASE  (					self			:       Optional[int]							):


				"""simple docstring"""

				lowerCAmelCase__	,lowerCAmelCase__								=							self.model_tester.prepare_config_and_inputs_for_common()

				lowerCAmelCase__								=							_config_zero_init(__magic_name__							)
				for model_class in self.all_model_classes:
							lowerCAmelCase__								=							model_class(config=__magic_name__							)
							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    A     (	unittest.TestCase    ):





	@cached_property
	def 							__SCREAMING_SNAKE_CASE  (					self			:       int							):


				"""simple docstring"""

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







	@slow
	def 							__SCREAMING_SNAKE_CASE  (					self			:       str							):


				"""simple docstring"""

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

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

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

				# verify the logits
				lowerCAmelCase__								=							torch.Size((1, 1000)							)
				self.assertEqual(outputs.logits.shape      ,							__magic_name__							)
				lowerCAmelCase__								=							torch.tensor([-0.1545, -0.7667, 0.4642]							).to(__magic_name__							)
				self.assertTrue(torch.allclose(outputs.logits[0, :3]      ,							__magic_name__      ,							atol=1E-4							)							)






@require_torch
@require_natten
class    A     (	unittest.TestCase  ,      SCREAMING_SNAKE_CASE__    ):
	snake_case__      :Dict        =     (DinatBackbone,) if is_torch_available() else ()
	snake_case__      :Union[str, Any]        =     DinatConfig





	def 							__SCREAMING_SNAKE_CASE  (					self			:       List[Any]							):


				"""simple docstring"""

				lowerCAmelCase__								=							DinatModelTester(self							)


'''simple docstring'''

from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


UpperCAmelCase__   : Any					=		{
    "configuration_fsmt": ["FSMT_PRETRAINED_CONFIG_ARCHIVE_MAP", "FSMTConfig"],
    "tokenization_fsmt": ["FSMTTokenizer"],
}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		UpperCAmelCase__   : str					=		["FSMTForConditionalGeneration", "FSMTModel", "PretrainedFSMTModel"]


if TYPE_CHECKING:
		from .configuration_fsmt import FSMT_PRETRAINED_CONFIG_ARCHIVE_MAP, FSMTConfig
		from .tokenization_fsmt import FSMTTokenizer

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_fsmt import FSMTForConditionalGeneration, FSMTModel, PretrainedFSMTModel

else:
		import sys

		UpperCAmelCase__   : int					=		_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)





