





import collections
import inspect
import unittest

from transformers import SwinConfig
from transformers.testing_utils import 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 SwinBackbone, SwinForImageClassification, SwinForMaskedImageModeling, SwinModel
	from transformers.models.swin.modeling_swin import SWIN_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
	from PIL import Image

	from transformers import AutoImageProcessor



class       __lowerCAmelCase :






			def __init__(self      ,							__magic_name__      ,							__magic_name__=13      ,							__magic_name__=32      ,							__magic_name__=2      ,							__magic_name__=3      ,							__magic_name__=16      ,							__magic_name__=[1, 2, 1]      ,							__magic_name__=[2, 2, 4]      ,							__magic_name__=2      ,							__magic_name__=2.0      ,							__magic_name__=True      ,							__magic_name__=0.0      ,							__magic_name__=0.0      ,							__magic_name__=0.1      ,							__magic_name__="gelu"      ,							__magic_name__=False      ,							__magic_name__=True      ,							__magic_name__=0.02      ,							__magic_name__=1e-5      ,							__magic_name__=True      ,							__magic_name__=None      ,							__magic_name__=True      ,							__magic_name__=10      ,							__magic_name__=8      ,							__magic_name__=["stage1", "stage2"]      ,							__magic_name__=[1, 2]      ,							)  ->     Tuple:


							'''simple docstring'''



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






			def     lowerCamelCase						(self					)  ->     Dict:


							'''simple docstring'''



							snake_case_		:					Union[str, Any]			    =						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

							snake_case_		:					str			    =						None
							if self.use_labels:
											snake_case_		:					int			    =						ids_tensor([self.batch_size]      ,							self.type_sequence_label_size					)

							snake_case_		:					Dict			    =						self.get_config()

							return config, pixel_values, labels






			def     lowerCamelCase						(self					)  ->     List[str]:


							'''simple docstring'''



							return SwinConfig(
							    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      ,							window_size=self.window_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      ,							use_absolute_embeddings=self.use_absolute_embeddings      ,							path_norm=self.patch_norm      ,							layer_norm_eps=self.layer_norm_eps      ,							initializer_range=self.initializer_range      ,							encoder_stride=self.encoder_stride      ,							out_features=self.out_features      ,							out_indices=self.out_indices      ,							)






			def     lowerCamelCase						(self      ,							__magic_name__      ,							__magic_name__      ,							__magic_name__					)  ->     Tuple:


							'''simple docstring'''



							snake_case_		:					Union[str, Any]			    =						SwinModel(config=__magic_name__					)
							model.to(__magic_name__					)
							model.eval()
							snake_case_		:					Optional[int]			    =						model(__magic_name__					)

							snake_case_		:					Dict			    =						((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths					) - 1))
							snake_case_		:					Dict			    =						int(config.embed_dim * 2 ** (len(config.depths					) - 1)					)

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






			def     lowerCamelCase						(self      ,							__magic_name__      ,							__magic_name__      ,							__magic_name__					)  ->     Any:


							'''simple docstring'''



							snake_case_		:					List[Any]			    =						SwinBackbone(config=__magic_name__					)
							model.to(__magic_name__					)
							model.eval()
							snake_case_		:					Union[str, Any]			    =						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
							snake_case_		:					List[Any]			    =						None
							snake_case_		:					Dict			    =						SwinBackbone(config=__magic_name__					)
							model.to(__magic_name__					)
							model.eval()
							snake_case_		:					List[Any]			    =						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     lowerCamelCase						(self      ,							__magic_name__      ,							__magic_name__      ,							__magic_name__					)  ->     int:


							'''simple docstring'''



							snake_case_		:					Dict			    =						SwinForMaskedImageModeling(config=__magic_name__					)
							model.to(__magic_name__					)
							model.eval()
							snake_case_		:					Optional[int]			    =						model(__magic_name__					)
							self.parent.assertEqual(
							    result.logits.shape      ,							(self.batch_size, self.num_channels, self.image_size, self.image_size)					)

							# test greyscale images
							snake_case_		:					Optional[Any]			    =						1
							snake_case_		:					List[str]			    =						SwinForMaskedImageModeling(__magic_name__					)
							model.to(__magic_name__					)
							model.eval()

							snake_case_		:					Dict			    =						floats_tensor([self.batch_size, 1, self.image_size, self.image_size]					)
							snake_case_		:					Tuple			    =						model(__magic_name__					)
							self.parent.assertEqual(result.logits.shape      ,							(self.batch_size, 1, self.image_size, self.image_size)					)






			def     lowerCamelCase						(self      ,							__magic_name__      ,							__magic_name__      ,							__magic_name__					)  ->     Optional[Any]:


							'''simple docstring'''



							snake_case_		:					Optional[Any]			    =						self.type_sequence_label_size
							snake_case_		:					str			    =						SwinForImageClassification(__magic_name__					)
							model.to(__magic_name__					)
							model.eval()
							snake_case_		:					List[str]			    =						model(__magic_name__      ,							labels=__magic_name__					)
							self.parent.assertEqual(result.logits.shape      ,							(self.batch_size, self.type_sequence_label_size)					)

							# test greyscale images
							snake_case_		:					Tuple			    =						1
							snake_case_		:					Union[str, Any]			    =						SwinForImageClassification(__magic_name__					)
							model.to(__magic_name__					)
							model.eval()

							snake_case_		:					Any			    =						floats_tensor([self.batch_size, 1, self.image_size, self.image_size]					)
							snake_case_		:					str			    =						model(__magic_name__					)
							self.parent.assertEqual(result.logits.shape      ,							(self.batch_size, self.type_sequence_label_size)					)






			def     lowerCamelCase						(self					)  ->     List[str]:


							'''simple docstring'''



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




@require_torch
class       __lowerCAmelCase (    _a,  _a,  unittest.TestCase  ):
			lowerCamelCase_  :  Union[str, Any]     =   (
			    (
			        SwinModel,
			        SwinBackbone,
			        SwinForImageClassification,
			        SwinForMaskedImageModeling,
			    )
			    if is_torch_available()
			    else ()
			)
			lowerCamelCase_  :  Optional[Any]     =   (
			    {'''feature-extraction''': SwinModel, '''image-classification''': SwinForImageClassification}
			    if is_torch_available()
			    else {}
			)
			lowerCamelCase_  :  str     =   True

			lowerCamelCase_  :  Union[str, Any]     =   False
			lowerCamelCase_  :  Tuple     =   False
			lowerCamelCase_  :  Optional[Any]     =   False






			def     lowerCamelCase						(self					)  ->     List[str]:


							'''simple docstring'''



							snake_case_		:					Optional[int]			    =						SwinModelTester(self					)
							snake_case_		:					int			    =						ConfigTester(self      ,							config_class=__magic_name__      ,							embed_dim=37					)






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


							'''simple docstring'''



							return






			def     lowerCamelCase						(self					)  ->     int:


							'''simple docstring'''



							snake_case_		:					Optional[int]			    =						self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*__magic_name__					)






			@unittest.skip(reason='''Got `CUDA error: misaligned address` with PyTorch 2.0.0.'''					)
			def     lowerCamelCase						(self					)  ->     str:


							'''simple docstring'''



							pass






			def     lowerCamelCase						(self					)  ->     Dict:


							'''simple docstring'''



							super().test_training_gradient_checkpointing()






			def     lowerCamelCase						(self					)  ->     Any:


							'''simple docstring'''



							snake_case_		:					Dict			    =						self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_backbone(*__magic_name__					)






			def     lowerCamelCase						(self					)  ->     Any:


							'''simple docstring'''



							snake_case_		:					List[Any]			    =						self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_masked_image_modeling(*__magic_name__					)






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


							'''simple docstring'''



							snake_case_		:					Union[str, Any]			    =						self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*__magic_name__					)






			@unittest.skip(reason='''Swin does not use inputs_embeds'''					)
			def     lowerCamelCase						(self					)  ->     List[str]:


							'''simple docstring'''



							pass






			@unittest.skip(reason='''Swin Transformer does not use feedforward chunking'''					)
			def     lowerCamelCase						(self					)  ->     Tuple:


							'''simple docstring'''



							pass






			def     lowerCamelCase						(self					)  ->     str:


							'''simple docstring'''



							snake_case_    ,							snake_case_		:					Optional[int]			    =						self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
											snake_case_		:					Optional[Any]			    =						model_class(__magic_name__					)
											self.assertIsInstance(model.get_input_embeddings()      ,							(nn.Module)					)
											snake_case_		:					Union[str, Any]			    =						model.get_output_embeddings()
											self.assertTrue(x is None or isinstance(__magic_name__      ,							nn.Linear					)					)






			def     lowerCamelCase						(self					)  ->     List[str]:


							'''simple docstring'''



							snake_case_    ,							snake_case_		:					Optional[int]			    =						self.model_tester.prepare_config_and_inputs_for_common()

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

											snake_case_		:					Union[str, Any]			    =						['''pixel_values''']
											self.assertListEqual(arg_names[:1]      ,							__magic_name__					)






			def     lowerCamelCase						(self					)  ->     str:


							'''simple docstring'''



							snake_case_    ,							snake_case_		:					List[str]			    =						self.model_tester.prepare_config_and_inputs_for_common()
							snake_case_		:					List[Any]			    =						True

							for model_class in self.all_model_classes:
											snake_case_		:					str			    =						True
											snake_case_		:					Tuple			    =						False
											snake_case_		:					Optional[Any]			    =						True
											snake_case_		:					List[Any]			    =						model_class(__magic_name__					)
											model.to(__magic_name__					)
											model.eval()
											with torch.no_grad():
															snake_case_		:					List[Any]			    =						model(**self._prepare_for_class(__magic_name__      ,							__magic_name__					)					)
											snake_case_		:					int			    =						outputs.attentions
											snake_case_		:					Tuple			    =						len(self.model_tester.depths					)
											self.assertEqual(len(__magic_name__					)      ,							__magic_name__					)

											# check that output_attentions also work using config
											del inputs_dict["output_attentions"]
											snake_case_		:					List[Any]			    =						True
											snake_case_		:					int			    =						config.window_size**2
											snake_case_		:					Tuple			    =						model_class(__magic_name__					)
											model.to(__magic_name__					)
											model.eval()
											with torch.no_grad():
															snake_case_		:					Dict			    =						model(**self._prepare_for_class(__magic_name__      ,							__magic_name__					)					)
											snake_case_		:					List[Any]			    =						outputs.attentions
											self.assertEqual(len(__magic_name__					)      ,							__magic_name__					)

											self.assertListEqual(
											    list(attentions[0].shape[-3:]					)      ,							[self.model_tester.num_heads[0], window_size_squared, window_size_squared]      ,							)
											snake_case_		:					Optional[int]			    =						len(__magic_name__					)

											# Check attention is always last and order is fine
											snake_case_		:					Optional[Any]			    =						True
											snake_case_		:					int			    =						True
											snake_case_		:					List[Any]			    =						model_class(__magic_name__					)
											model.to(__magic_name__					)
											model.eval()
											with torch.no_grad():
															snake_case_		:					str			    =						model(**self._prepare_for_class(__magic_name__      ,							__magic_name__					)					)

											# also another +1 for reshaped_hidden_states
											snake_case_		:					int			    =						1 if model_class.__name__ == '''SwinBackbone''' else 2
											self.assertEqual(out_len + added_hidden_states      ,							len(__magic_name__					)					)

											snake_case_		:					Any			    =						outputs.attentions

											self.assertEqual(len(__magic_name__					)      ,							__magic_name__					)

											self.assertListEqual(
											    list(self_attentions[0].shape[-3:]					)      ,							[self.model_tester.num_heads[0], window_size_squared, window_size_squared]      ,							)






			def     lowerCamelCase						(self      ,							__magic_name__      ,							__magic_name__      ,							__magic_name__      ,							__magic_name__					)  ->     List[Any]:


							'''simple docstring'''



							snake_case_		:					Any			    =						model_class(__magic_name__					)
							model.to(__magic_name__					)
							model.eval()

							with torch.no_grad():
											snake_case_		:					Union[str, Any]			    =						model(**self._prepare_for_class(__magic_name__      ,							__magic_name__					)					)

							snake_case_		:					Tuple			    =						outputs.hidden_states

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

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

							snake_case_		:					int			    =						(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

							self.assertListEqual(
							    list(hidden_states[0].shape[-2:]					)      ,							[num_patches, self.model_tester.embed_dim]      ,							)

							if not model_class.__name__ == "SwinBackbone":
											snake_case_		:					Dict			    =						outputs.reshaped_hidden_states
											self.assertEqual(len(__magic_name__					)      ,							__magic_name__					)

											snake_case_    ,							snake_case_    ,							snake_case_    ,							snake_case_		:					List[str]			    =						reshaped_hidden_states[0].shape
											snake_case_		:					Optional[int]			    =						(
											    reshaped_hidden_states[0].view(__magic_name__      ,							__magic_name__      ,							height * width					).permute(0      ,							2      ,							1					)
											)
											self.assertListEqual(
											    list(reshaped_hidden_states.shape[-2:]					)      ,							[num_patches, self.model_tester.embed_dim]      ,							)






			def     lowerCamelCase						(self					)  ->     Tuple:


							'''simple docstring'''



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

							snake_case_		:					List[str]			    =						(
							    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_		:					List[Any]			    =						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"]
											snake_case_		:					int			    =						True

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






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


							'''simple docstring'''



							snake_case_    ,							snake_case_		:					Union[str, Any]			    =						self.model_tester.prepare_config_and_inputs_for_common()
							snake_case_		:					Union[str, Any]			    =						3

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

							snake_case_		:					str			    =						image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
							snake_case_		:					Union[str, Any]			    =						image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

							for model_class in self.all_model_classes:
											snake_case_		:					Tuple			    =						True
											self.check_hidden_states_output(__magic_name__      ,							__magic_name__      ,							__magic_name__      ,							(padded_height, padded_width)					)

											# check that output_hidden_states also work using config
											del inputs_dict["output_hidden_states"]
											snake_case_		:					Dict			    =						True
											self.check_hidden_states_output(__magic_name__      ,							__magic_name__      ,							__magic_name__      ,							(padded_height, padded_width)					)






			@slow
			def     lowerCamelCase						(self					)  ->     Tuple:


							'''simple docstring'''



							for model_name in SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											snake_case_		:					int			    =						SwinModel.from_pretrained(__magic_name__					)
											self.assertIsNotNone(__magic_name__					)






			def     lowerCamelCase						(self					)  ->     str:


							'''simple docstring'''



							snake_case_    ,							snake_case_		:					Tuple			    =						self.model_tester.prepare_config_and_inputs_for_common()

							snake_case_		:					int			    =						_config_zero_init(__magic_name__					)
							for model_class in self.all_model_classes:
											snake_case_		:					Dict			    =						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_vision
@require_torch
class       __lowerCAmelCase (    unittest.TestCase  ):






			@cached_property
			def     lowerCamelCase						(self					)  ->     Tuple:


							'''simple docstring'''



							return (
							    AutoImageProcessor.from_pretrained('''microsoft/swin-tiny-patch4-window7-224'''					)
							    if is_vision_available()
							    else None
							)






			@slow
			def     lowerCamelCase						(self					)  ->     List[str]:


							'''simple docstring'''



							snake_case_		:					Union[str, Any]			    =						SwinForImageClassification.from_pretrained('''microsoft/swin-tiny-patch4-window7-224'''					).to(__magic_name__					)
							snake_case_		:					int			    =						self.default_image_processor

							snake_case_		:					str			    =						Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''					)
							snake_case_		:					Any			    =						image_processor(images=__magic_name__      ,							return_tensors='''pt'''					).to(__magic_name__					)

							# forward pass
							with torch.no_grad():
											snake_case_		:					List[str]			    =						model(**__magic_name__					)

							# verify the logits
							snake_case_		:					Optional[int]			    =						torch.Size((1, 1000)					)
							self.assertEqual(outputs.logits.shape      ,							__magic_name__					)
							snake_case_		:					Any			    =						torch.tensor([-0.0_948, -0.6_454, -0.0_921]					).to(__magic_name__					)
							self.assertTrue(torch.allclose(outputs.logits[0, :3]      ,							__magic_name__      ,							atol=1e-4					)					)




@require_torch
class       __lowerCAmelCase (    unittest.TestCase,  _a  ):
			lowerCamelCase_  :  List[str]     =   (SwinBackbone,) if is_torch_available() else ()
			lowerCamelCase_  :  Dict     =   SwinConfig






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


							'''simple docstring'''



							snake_case_		:					Any			    =						SwinModelTester(self					)







from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowerCAmelCase_												=       {'''configuration_dinat''': ['''DINAT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''DinatConfig''']}


try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	lowerCAmelCase_												=       [
	    '''DINAT_PRETRAINED_MODEL_ARCHIVE_LIST''',
	    '''DinatForImageClassification''',
	    '''DinatModel''',
	    '''DinatPreTrainedModel''',
	    '''DinatBackbone''',
	]

if TYPE_CHECKING:
	from .configuration_dinat import DINAT_PRETRAINED_CONFIG_ARCHIVE_MAP, DinatConfig

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_dinat import (
		    DINAT_PRETRAINED_MODEL_ARCHIVE_LIST,
		    DinatBackbone,
		    DinatForImageClassification,
		    DinatModel,
		    DinatPreTrainedModel,
		)

else:
	import sys

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