




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



 '''simple docstring'''





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

  '''simple docstring'''







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






 def lowercase_      (self   ):

  '''simple docstring'''







  _UpperCamelCase      :	List[str]					      =  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

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

  _UpperCamelCase      :	Dict					      =  self.get_config()

  return config, pixel_values, labels






 def lowercase_      (self   ):

  '''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 lowercase_      (self					,     lowerCAmelCase__					,     lowerCAmelCase__					,     lowerCAmelCase__   ):

  '''simple docstring'''







  _UpperCamelCase      :	Tuple					      =  DinatModel(config=lowerCAmelCase__   )
  model.to(lowerCAmelCase__   )
  model.eval()
  _UpperCamelCase      :	Any					      =  model(lowerCAmelCase__   )

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

  '''simple docstring'''







  _UpperCamelCase      :	List[str]					      =  DinatForImageClassification(lowerCAmelCase__   )
  model.to(lowerCAmelCase__   )
  model.eval()
  _UpperCamelCase      :	List[str]					      =  model(lowerCAmelCase__					,     labels=lowerCAmelCase__   )
  self.parent.assertEqual(result.logits.shape					,     (self.batch_size, self.num_labels)   )

  # test greyscale images
  _UpperCamelCase      :	Optional[Any]					      =  1
  _UpperCamelCase      :	Any					      =  DinatForImageClassification(lowerCAmelCase__   )
  model.to(lowerCAmelCase__   )
  model.eval()

  _UpperCamelCase      :	Optional[int]					      =  floats_tensor([self.batch_size, 1, self.image_size, self.image_size]   )
  _UpperCamelCase      :	str					      =  model(lowerCAmelCase__   )
  self.parent.assertEqual(result.logits.shape					,     (self.batch_size, self.num_labels)   )






 def lowercase_      (self					,     lowerCAmelCase__					,     lowerCAmelCase__					,     lowerCAmelCase__   ):

  '''simple docstring'''







  _UpperCamelCase      :	Tuple					      =  DinatBackbone(config=lowerCAmelCase__   )
  model.to(lowerCAmelCase__   )
  model.eval()
  _UpperCamelCase      :	Optional[Any]					      =  model(lowerCAmelCase__   )

  # 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      :	Optional[Any]					      =  None
  _UpperCamelCase      :	Union[str, Any]					      =  DinatBackbone(config=lowerCAmelCase__   )
  model.to(lowerCAmelCase__   )
  model.eval()
  _UpperCamelCase      :	Union[str, Any]					      =  model(lowerCAmelCase__   )

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

  '''simple docstring'''







  _UpperCamelCase      :	Dict					      =  self.prepare_config_and_inputs()
  _UpperCamelCase      ,	_UpperCamelCase      ,	_UpperCamelCase      :	int					      =  config_and_inputs
  _UpperCamelCase      :	List[Any]					      =  {"pixel_values": pixel_values}
  return config, inputs_dict







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



 '''simple docstring'''





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

 __UpperCAmelCase		   =							False
 __UpperCAmelCase		   =							False
 __UpperCAmelCase		   =							False
 __UpperCAmelCase		   =							False






 def lowercase_      (self   ):

  '''simple docstring'''







  _UpperCamelCase      :	Any					      =  DinatModelTester(self   )
  _UpperCamelCase      :	Dict					      =  ConfigTester(self					,     config_class=lowerCAmelCase__					,     embed_dim=37   )






 def lowercase_      (self   ):

  '''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 lowercase_      (self   ):

  '''simple docstring'''







  return






 def lowercase_      (self   ):

  '''simple docstring'''







  _UpperCamelCase      :	List[str]					      =  self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_model(*lowerCAmelCase__   )






 def lowercase_      (self   ):

  '''simple docstring'''







  _UpperCamelCase      :	str					      =  self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase__   )






 def lowercase_      (self   ):

  '''simple docstring'''







  _UpperCamelCase      :	Any					      =  self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_backbone(*lowerCAmelCase__   )






 @unittest.skip(reason="Dinat does not use inputs_embeds"   )
 def lowercase_      (self   ):

  '''simple docstring'''







  pass






 @unittest.skip(reason="Dinat does not use feedforward chunking"   )
 def lowercase_      (self   ):

  '''simple docstring'''







  pass






 def lowercase_      (self   ):

  '''simple docstring'''







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

  for model_class in self.all_model_classes:
   _UpperCamelCase      :	Optional[int]					      =  model_class(lowerCAmelCase__   )
   self.assertIsInstance(model.get_input_embeddings()					,     (nn.Module)   )
   _UpperCamelCase      :	Tuple					      =  model.get_output_embeddings()
   self.assertTrue(x is None or isinstance(lowerCAmelCase__					,     nn.Linear   )   )






 def lowercase_      (self   ):

  '''simple docstring'''







  _UpperCamelCase      ,	_UpperCamelCase      :	Optional[Any]					      =  self.model_tester.prepare_config_and_inputs_for_common()

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

   _UpperCamelCase      :	List[Any]					      =  ["pixel_values"]
   self.assertListEqual(arg_names[:1]					,     lowerCAmelCase__   )






 def lowercase_      (self   ):

  '''simple docstring'''







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






 def lowercase_      (self					,     lowerCAmelCase__					,     lowerCAmelCase__					,     lowerCAmelCase__					,     lowerCAmelCase__   ):

  '''simple docstring'''







  _UpperCamelCase      :	Any					      =  model_class(lowerCAmelCase__   )
  model.to(lowerCAmelCase__   )
  model.eval()

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

  _UpperCamelCase      :	Union[str, Any]					      =  outputs.hidden_states

  _UpperCamelCase      :	Optional[Any]					      =  getattr(
      self.model_tester					,     "expected_num_hidden_layers"					,     len(self.model_tester.depths   ) + 1   )
  self.assertEqual(len(lowerCAmelCase__   )					,     lowerCAmelCase__   )

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

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

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






 def lowercase_      (self   ):

  '''simple docstring'''







  _UpperCamelCase      ,	_UpperCamelCase      :	Optional[Any]					      =  self.model_tester.prepare_config_and_inputs_for_common()

  _UpperCamelCase      :	int					      =  (
      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      :	Any					      =  True
   self.check_hidden_states_output(lowerCAmelCase__					,     lowerCAmelCase__					,     lowerCAmelCase__					,     lowerCAmelCase__   )

   # check that output_hidden_states also work using config
   del inputs_dict["output_hidden_states"]
   _UpperCamelCase      :	Any					      =  True

   self.check_hidden_states_output(lowerCAmelCase__					,     lowerCAmelCase__					,     lowerCAmelCase__					,     lowerCAmelCase__   )






 @slow
 def lowercase_      (self   ):

  '''simple docstring'''







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






 def lowercase_      (self   ):

  '''simple docstring'''







  _UpperCamelCase      ,	_UpperCamelCase      :	List[str]					      =  self.model_tester.prepare_config_and_inputs_for_common()

  _UpperCamelCase      :	List[str]					      =  _config_zero_init(lowerCAmelCase__   )
  for model_class in self.all_model_classes:
   _UpperCamelCase      :	Optional[Any]					      =  model_class(config=lowerCAmelCase__   )
   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 lowercase_      (self   ):

  '''simple docstring'''







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






 @slow
 def lowercase_      (self   ):

  '''simple docstring'''







  _UpperCamelCase      :	Optional[int]					      =  DinatForImageClassification.from_pretrained("shi-labs/dinat-mini-in1k-224"   ).to(lowerCAmelCase__   )
  _UpperCamelCase      :	Any					      =  self.default_image_processor

  _UpperCamelCase      :	Optional[int]					      =  Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"   )
  _UpperCamelCase      :	Optional[Any]					      =  image_processor(images=lowerCAmelCase__					,     return_tensors="pt"   ).to(lowerCAmelCase__   )

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

  # verify the logits
  _UpperCamelCase      :	Optional[Any]					      =  torch.Size((1, 10_00)   )
  self.assertEqual(outputs.logits.shape					,     lowerCAmelCase__   )
  _UpperCamelCase      :	List[str]					      =  torch.tensor([-0.1545, -0.7667, 0.4642]   ).to(lowerCAmelCase__   )
  self.assertTrue(torch.allclose(outputs.logits[0, :3]					,     lowerCAmelCase__					,     atol=1E-4   )   )







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



 '''simple docstring'''





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






 def lowercase_      (self   ):

  '''simple docstring'''







  _UpperCamelCase      :	List[str]					      =  DinatModelTester(self   )









"""simple docstring"""
import math






def 				__lowerCAmelCase					(					__lowerCAmelCase			:		Tuple						)    ->       Any:
 _UpperCamelCase      :	str					      =  0
 if n % 2 == 0:
  count += 1
  while n % 2 == 0:
   _UpperCamelCase      :	List[Any]					      =  int(n / 2						)
    # the n input value must be odd so that
    # we can skip one element (ie i += 2)

 _UpperCamelCase      :	Tuple					      =  3

 while i <= int(math.sqrt(__lowerCAmelCase						)						):
  if n % i == 0:
   count += 1
   while n % i == 0:
    _UpperCamelCase      :	Any					      =  int(n / i						)
  _UpperCamelCase      :	Optional[Any]					      =  i + 2

 # this condition checks the prime
 # number n is greater than 2

 if n > 2:
  count += 1
 return count


if __name__ == "__main__":
    _SCREAMING_SNAKE_CASE						 =     5_1_2_4_2_1_8_3
    print(f'The number of distinct prime factors is/are {exact_prime_factor_count(n)}')
    print(f'The value of log(log(n)) is {math.log(math.log(n)):.4f}')



