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

							"""simple docstring"""






							def __init__(	self  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_=13  ,						SCREAMING_SNAKE_CASE_=64  ,						SCREAMING_SNAKE_CASE_=4  ,						SCREAMING_SNAKE_CASE_=3  ,						SCREAMING_SNAKE_CASE_=16  ,						SCREAMING_SNAKE_CASE_=[1, 2, 1]  ,						SCREAMING_SNAKE_CASE_=[2, 4, 8]  ,						SCREAMING_SNAKE_CASE_=3  ,						SCREAMING_SNAKE_CASE_=[[3], [1, 2], [1]]  ,						SCREAMING_SNAKE_CASE_=2.0  ,						SCREAMING_SNAKE_CASE_=True  ,						SCREAMING_SNAKE_CASE_=0.0  ,						SCREAMING_SNAKE_CASE_=0.0  ,						SCREAMING_SNAKE_CASE_=0.1  ,						SCREAMING_SNAKE_CASE_="gelu"  ,						SCREAMING_SNAKE_CASE_=True  ,						SCREAMING_SNAKE_CASE_=0.0_2  ,						SCREAMING_SNAKE_CASE_=1E-5  ,						SCREAMING_SNAKE_CASE_=True  ,						SCREAMING_SNAKE_CASE_=None  ,						SCREAMING_SNAKE_CASE_=True  ,						SCREAMING_SNAKE_CASE_=10  ,						SCREAMING_SNAKE_CASE_=["stage1", "stage2"]  ,						SCREAMING_SNAKE_CASE_=[1, 2]  ,						)-> Dict:





													'''simple docstring'''






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



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





													'''simple docstring'''






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

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

													__UpperCamelCase  	=      self.get_config()

													return config, pixel_values, labels



							def      A__		(	self      )-> Optional[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      A__		(	self  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_      )-> Optional[int]:





													'''simple docstring'''






													__UpperCamelCase  	=      DinatModel(config=SCREAMING_SNAKE_CASE_      )
													model.to(SCREAMING_SNAKE_CASE_      )
													model.eval()
													__UpperCamelCase  	=      model(SCREAMING_SNAKE_CASE_      )

													__UpperCamelCase  	=      __UpperCamelCase  	=      (config.image_size // config.patch_size) // (2 ** (len(config.depths      ) - 1))
													__UpperCamelCase  	=      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      A__		(	self  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_      )-> Optional[int]:





													'''simple docstring'''






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

													# test greyscale images
													__UpperCamelCase  	=      1
													__UpperCamelCase  	=      DinatForImageClassification(SCREAMING_SNAKE_CASE_      )
													model.to(SCREAMING_SNAKE_CASE_      )
													model.eval()

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



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





													'''simple docstring'''






													__UpperCamelCase  	=      DinatBackbone(config=SCREAMING_SNAKE_CASE_      )
													model.to(SCREAMING_SNAKE_CASE_      )
													model.eval()
													__UpperCamelCase  	=      model(SCREAMING_SNAKE_CASE_      )

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

													# 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      A__		(	self      )-> Dict:





													'''simple docstring'''






													__UpperCamelCase  	=      self.prepare_config_and_inputs()
													__UpperCamelCase	,				__UpperCamelCase	,				__UpperCamelCase  	=      config_and_inputs
													__UpperCamelCase  	=      {'''pixel_values''': pixel_values}
													return config, inputs_dict






@require_natten
@require_torch
class 							SCREAMING_SNAKE_CASE__     (				A__ ,		A__ ,		unittest.TestCase     ):

							"""simple docstring"""






							_snake_case  		=	(
							    (
							        DinatModel,
							        DinatForImageClassification,
							        DinatBackbone,
							    )
							    if is_torch_available()
							    else ()
							)
							_snake_case  		=	(
							    {'''feature-extraction''': DinatModel, '''image-classification''': DinatForImageClassification}
							    if is_torch_available()
							    else {}
							)
							_snake_case  		=	False

							_snake_case  		=	False
							_snake_case  		=	False
							_snake_case  		=	False
							_snake_case  		=	False



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





													'''simple docstring'''






													__UpperCamelCase  	=      DinatModelTester(self      )
													__UpperCamelCase  	=      ConfigTester(self  ,						config_class=SCREAMING_SNAKE_CASE_  ,						embed_dim=37      )



							def      A__		(	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      A__		(	self      )-> Dict:





													'''simple docstring'''






													return



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





													'''simple docstring'''






													__UpperCamelCase  	=      self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_      )



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





													'''simple docstring'''






													__UpperCamelCase  	=      self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE_      )



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





													'''simple docstring'''






													__UpperCamelCase  	=      self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_backbone(*SCREAMING_SNAKE_CASE_      )



							@unittest.skip(reason='''Dinat does not use inputs_embeds'''      )
							def      A__		(	self      )-> int:





													'''simple docstring'''






													pass



							@unittest.skip(reason='''Dinat does not use feedforward chunking'''      )
							def      A__		(	self      )-> Optional[int]:





													'''simple docstring'''






													pass



							def      A__		(	self      )-> Any:





													'''simple docstring'''






													__UpperCamelCase	,				__UpperCamelCase  	=      self.model_tester.prepare_config_and_inputs_for_common()

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



							def      A__		(	self      )-> int:





													'''simple docstring'''






													__UpperCamelCase	,				__UpperCamelCase  	=      self.model_tester.prepare_config_and_inputs_for_common()

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

																			__UpperCamelCase  	=      ['''pixel_values''']
																			self.assertListEqual(arg_names[:1]  ,						SCREAMING_SNAKE_CASE_      )



							def      A__		(	self      )-> Dict:





													'''simple docstring'''






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



							def      A__		(	self  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_      )-> Dict:





													'''simple docstring'''






													__UpperCamelCase  	=      model_class(SCREAMING_SNAKE_CASE_      )
													model.to(SCREAMING_SNAKE_CASE_      )
													model.eval()

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

													__UpperCamelCase  	=      outputs.hidden_states

													__UpperCamelCase  	=      getattr(
													    self.model_tester  ,						'''expected_num_hidden_layers'''  ,						len(self.model_tester.depths      ) + 1      )
													self.assertEqual(len(SCREAMING_SNAKE_CASE_      )  ,						SCREAMING_SNAKE_CASE_      )

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

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

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



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





													'''simple docstring'''






													__UpperCamelCase	,				__UpperCamelCase  	=      self.model_tester.prepare_config_and_inputs_for_common()

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

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

																			self.check_hidden_states_output(SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_      )



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





													'''simple docstring'''






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



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





													'''simple docstring'''






													__UpperCamelCase	,				__UpperCamelCase  	=      self.model_tester.prepare_config_and_inputs_for_common()

													__UpperCamelCase  	=      _config_zero_init(SCREAMING_SNAKE_CASE_      )
													for model_class in self.all_model_classes:
																			__UpperCamelCase  	=      model_class(config=SCREAMING_SNAKE_CASE_      )
																			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      A__		(	self      )-> Dict:





													'''simple docstring'''






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



							@slow
							def      A__		(	self      )-> Optional[Any]:





													'''simple docstring'''






													__UpperCamelCase  	=      DinatForImageClassification.from_pretrained('''shi-labs/dinat-mini-in1k-224'''      ).to(SCREAMING_SNAKE_CASE_      )
													__UpperCamelCase  	=      self.default_image_processor

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

													# forward pass
													with torch.no_grad():
																			__UpperCamelCase  	=      model(**SCREAMING_SNAKE_CASE_      )

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






@require_torch
@require_natten
class 							SCREAMING_SNAKE_CASE__     (				unittest.TestCase ,		A__     ):

							"""simple docstring"""






							_snake_case  		=	(DinatBackbone,) if is_torch_available() else ()
							_snake_case  		=	DinatConfig



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





													'''simple docstring'''






													__UpperCamelCase  	=      DinatModelTester(self      )






'''simple docstring'''







from collections import defaultdict







def   lowerCAmelCase(  a__    :  int = 5      ):







       '''simple docstring'''






       lowerCamelCase__				   =      defaultdict(a__      )
       lowerCamelCase__				   =      0

       while True:
              lowerCamelCase__				   =      get_digits(a__      )
              freqs[digits].append(a__      )

              if len(freqs[digits]      ) == max_base:
                     lowerCamelCase__				   =      freqs[digits][0] ** 3
                     return base

              num += 1







def   lowerCAmelCase(  a__    :  int      ):







       '''simple docstring'''






       return "".join(sorted(str(num**3      )      )      )


if __name__ == "__main__":
    print(f'{solution() = }')

