





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



      """simple docstring"""






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






        '''simple docstring'''






        __snake_case				:			Any            =    parent
        __snake_case				:			Any            =    batch_size
        __snake_case				:			Tuple            =    image_size
        __snake_case				:			Optional[int]            =    patch_size
        __snake_case				:			Tuple            =    num_channels
        __snake_case				:			str            =    embed_dim
        __snake_case				:			List[str]            =    depths
        __snake_case				:			Dict            =    num_heads
        __snake_case				:			Tuple            =    kernel_size
        __snake_case				:			List[Any]            =    dilations
        __snake_case				:			Any            =    mlp_ratio
        __snake_case				:			Tuple            =    qkv_bias
        __snake_case				:			Any            =    hidden_dropout_prob
        __snake_case				:			Optional[Any]            =    attention_probs_dropout_prob
        __snake_case				:			Union[str, Any]            =    drop_path_rate
        __snake_case				:			Union[str, Any]            =    hidden_act
        __snake_case				:			Any            =    patch_norm
        __snake_case				:			Optional[Any]            =    layer_norm_eps
        __snake_case				:			Optional[int]            =    initializer_range
        __snake_case				:			Union[str, Any]            =    is_training
        __snake_case				:			Optional[Any]            =    scope
        __snake_case				:			List[Any]            =    use_labels
        __snake_case				:			Dict            =    num_labels
        __snake_case				:			Optional[Any]            =    out_features
        __snake_case				:			Dict            =    out_indices







      def   UpperCAmelCase						(	self				)    ->				Tuple:






        '''simple docstring'''






        __snake_case				:			int            =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)

        __snake_case				:			List[str]            =    None
        if self.use_labels:
          __snake_case				:			Dict            =    ids_tensor([self.batch_size]			,  self.num_labels				)

        __snake_case				:			Dict            =    self.get_config()

        return config, pixel_values, labels







      def   UpperCAmelCase						(	self				)    ->				str:






        '''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   UpperCAmelCase						(	self			,  UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase				)    ->				List[Any]:






        '''simple docstring'''






        __snake_case				:			List[Any]            =    DinatModel(config=UpperCAmelCase				)
        model.to(UpperCAmelCase				)
        model.eval()
        __snake_case				:			Dict            =    model(UpperCAmelCase				)

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






        '''simple docstring'''






        __snake_case				:			Optional[int]            =    DinatForImageClassification(UpperCAmelCase				)
        model.to(UpperCAmelCase				)
        model.eval()
        __snake_case				:			Any            =    model(UpperCAmelCase			,  labels=UpperCAmelCase				)
        self.parent.assertEqual(result.logits.shape			,  (self.batch_size, self.num_labels)				)

        # test greyscale images
        __snake_case				:			str            =    1
        __snake_case				:			Optional[int]            =    DinatForImageClassification(UpperCAmelCase				)
        model.to(UpperCAmelCase				)
        model.eval()

        __snake_case				:			List[Any]            =    floats_tensor([self.batch_size, 1, self.image_size, self.image_size]				)
        __snake_case				:			List[str]            =    model(UpperCAmelCase				)
        self.parent.assertEqual(result.logits.shape			,  (self.batch_size, self.num_labels)				)







      def   UpperCAmelCase						(	self			,  UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase				)    ->				Optional[int]:






        '''simple docstring'''






        __snake_case				:			Optional[Any]            =    DinatBackbone(config=UpperCAmelCase				)
        model.to(UpperCAmelCase				)
        model.eval()
        __snake_case				:			List[Any]            =    model(UpperCAmelCase				)

        # 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				:			Optional[Any]            =    None
        __snake_case				:			Tuple            =    DinatBackbone(config=UpperCAmelCase				)
        model.to(UpperCAmelCase				)
        model.eval()
        __snake_case				:			str            =    model(UpperCAmelCase				)

        # 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   UpperCAmelCase						(	self				)    ->				Optional[int]:






        '''simple docstring'''






        __snake_case				:			List[Any]            =    self.prepare_config_and_inputs()
        __snake_case				:			str            =    config_and_inputs
        __snake_case				:			Optional[Any]            =    {"pixel_values": pixel_values}
        return config, inputs_dict




@require_natten
@require_torch
class 			_lowerCamelCase	(      a	,				a	,				unittest.TestCase      ):



      """simple docstring"""






      UpperCAmelCase_  : List[str]				      =(
          (
              DinatModel,
              DinatForImageClassification,
              DinatBackbone,
          )
          if is_torch_available()
          else ()
      )
      UpperCAmelCase_  : Union[str, Any]				      =(
          {"feature-extraction": DinatModel, "image-classification": DinatForImageClassification}
          if is_torch_available()
          else {}
      )
      UpperCAmelCase_  : Tuple				      =False

      UpperCAmelCase_  : List[str]				      =False
      UpperCAmelCase_  : Any				      =False
      UpperCAmelCase_  : Any				      =False
      UpperCAmelCase_  : Dict				      =False







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






        '''simple docstring'''






        __snake_case				:			Dict            =    DinatModelTester(self				)
        __snake_case				:			List[Any]            =    ConfigTester(self			,  config_class=UpperCAmelCase			,  embed_dim=37				)







      def   UpperCAmelCase						(	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   UpperCAmelCase						(	self				)    ->				List[Any]:






        '''simple docstring'''






        return







      def   UpperCAmelCase						(	self				)    ->				int:






        '''simple docstring'''






        __snake_case				:			int            =    self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*UpperCAmelCase				)







      def   UpperCAmelCase						(	self				)    ->				Any:






        '''simple docstring'''






        __snake_case				:			str            =    self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*UpperCAmelCase				)







      def   UpperCAmelCase						(	self				)    ->				Dict:






        '''simple docstring'''






        __snake_case				:			Union[str, Any]            =    self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_backbone(*UpperCAmelCase				)







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






        '''simple docstring'''






        pass







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






        '''simple docstring'''






        pass







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






        '''simple docstring'''






        __snake_case				:			List[Any]            =    self.model_tester.prepare_config_and_inputs_for_common()

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







      def   UpperCAmelCase						(	self				)    ->				Tuple:






        '''simple docstring'''






        __snake_case				:			Dict            =    self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
          __snake_case				:			List[str]            =    model_class(UpperCAmelCase				)
          __snake_case				:			int            =    inspect.signature(model.forward				)
          # signature.parameters is an OrderedDict => so arg_names order is deterministic
          __snake_case				:			Dict            =    [*signature.parameters.keys()]

          __snake_case				:			str            =    ["pixel_values"]
          self.assertListEqual(arg_names[:1]			,  UpperCAmelCase				)







      def   UpperCAmelCase						(	self				)    ->				Dict:






        '''simple docstring'''






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







      def   UpperCAmelCase						(	self			,  UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase				)    ->				str:






        '''simple docstring'''






        __snake_case				:			Union[str, Any]            =    model_class(UpperCAmelCase				)
        model.to(UpperCAmelCase				)
        model.eval()

        with torch.no_grad():
          __snake_case				:			Optional[int]            =    model(**self._prepare_for_class(UpperCAmelCase			,  UpperCAmelCase				)				)

        __snake_case				:			int            =    outputs.hidden_states

        __snake_case				:			Tuple            =    getattr(
            self.model_tester			,  "expected_num_hidden_layers"			,  len(self.model_tester.depths				) + 1				)
        self.assertEqual(len(UpperCAmelCase				)			,  UpperCAmelCase				)

        # Dinat has a different seq_length
        __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]
        __snake_case				:			Any            =    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":
          __snake_case				:			List[str]            =    outputs.reshaped_hidden_states
          self.assertEqual(len(UpperCAmelCase				)			,  UpperCAmelCase				)

          __snake_case				:			int            =    reshaped_hidden_states[0].shape
          __snake_case				:			List[str]            =    (
              reshaped_hidden_states[0].view(UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase				).permute(0			,  2			,  3			,  1				)
          )
          self.assertListEqual(
              list(reshaped_hidden_states.shape[-3:]				)			,  [height, width, self.model_tester.embed_dim]			,  )







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






        '''simple docstring'''






        __snake_case				:			Dict            =    self.model_tester.prepare_config_and_inputs_for_common()

        __snake_case				:			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:
          __snake_case				:			List[str]            =    True
          self.check_hidden_states_output(UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase				)

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

          self.check_hidden_states_output(UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase				)







      @slow
      def   UpperCAmelCase						(	self				)    ->				List[Any]:






        '''simple docstring'''






        for model_name in DINAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          __snake_case				:			List[str]            =    DinatModel.from_pretrained(UpperCAmelCase				)
          self.assertIsNotNone(UpperCAmelCase				)







      def   UpperCAmelCase						(	self				)    ->				Any:






        '''simple docstring'''






        __snake_case				:			List[Any]            =    self.model_tester.prepare_config_and_inputs_for_common()

        __snake_case				:			List[str]            =    _config_zero_init(UpperCAmelCase				)
        for model_class in self.all_model_classes:
          __snake_case				:			Any            =    model_class(config=UpperCAmelCase				)
          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 			_lowerCamelCase	(      unittest.TestCase      ):



      """simple docstring"""






      @cached_property
      def   UpperCAmelCase						(	self				)    ->				int:






        '''simple docstring'''






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







      @slow
      def   UpperCAmelCase						(	self				)    ->				List[Any]:






        '''simple docstring'''






        __snake_case				:			List[Any]            =    DinatForImageClassification.from_pretrained("shi-labs/dinat-mini-in1k-224"				).to(UpperCAmelCase				)
        __snake_case				:			List[str]            =    self.default_image_processor

        __snake_case				:			List[str]            =    Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"				)
        __snake_case				:			str            =    image_processor(images=UpperCAmelCase			,  return_tensors="pt"				).to(UpperCAmelCase				)

        # forward pass
        with torch.no_grad():
          __snake_case				:			Tuple            =    model(**UpperCAmelCase				)

        # verify the logits
        __snake_case				:			Dict            =    torch.Size((1, 1000)				)
        self.assertEqual(outputs.logits.shape			,  UpperCAmelCase				)
        __snake_case				:			Optional[Any]            =    torch.tensor([-0.1_545, -0.7_667, 0.4_642]				).to(UpperCAmelCase				)
        self.assertTrue(torch.allclose(outputs.logits[0, :3]			,  UpperCAmelCase			,  atol=1E-4				)				)




@require_torch
@require_natten
class 			_lowerCamelCase	(      unittest.TestCase	,				a      ):



      """simple docstring"""






      UpperCAmelCase_  : Dict				      =(DinatBackbone,) if is_torch_available() else ()
      UpperCAmelCase_  : Union[str, Any]				      =DinatConfig







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






        '''simple docstring'''






        __snake_case				:			Optional[Any]            =    DinatModelTester(self				)








def  lowerCAmelCase__(		lowercase    :      int = 10**6			)	->      int:

  if n <= 0:
    raise ValueError("Please enter an integer greater than 0"			)

  __snake_case				:			List[Any]            =    list(range(n + 1			)			)
  for number in range(2				,       n + 1			):
    if phi[number] == number:
      phi[number] -= 1
      for multiple in range(number * 2				,       n + 1				,       lowercase			):
        __snake_case				:			Optional[int]            =    (phi[multiple] // number) * (number - 1)

  __snake_case				:			List[Any]            =    1
  for number in range(1				,       n + 1			):
    if (answer / phi[answer]) < (number / phi[number]):
      __snake_case				:			List[str]            =    number

  return answer


if __name__ == "__main__":
     print(solution())

