




'''simple docstring'''







import collections
import inspect
import unittest

from transformers import NatConfig
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 NatBackbone, NatForImageClassification, NatModel
    from transformers.models.nat.modeling_nat import NAT_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
    from PIL import Image

    from transformers import AutoImageProcessor

class   _snake_case:






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






    """simple docstring"""


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






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






    """simple docstring"""


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

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

    A__         =    self.get_config()

    return config, pixel_values, labels






 def 	_UpperCamelCase   (self					:     Dict						)					->      List[Any]:






    """simple docstring"""


    return NatConfig(
        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						,		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					:     Optional[Any]						,		a					:     Tuple						,		a					:     Any						,		a					:     List[str]						)					->      int:






    """simple docstring"""


    A__         =    NatModel(config=a						)
    model.to(a						)
    model.eval()
    A__         =    model(a						)

    A__         =    A__         =    (config.image_size // config.patch_size) // (2 ** (len(config.depths						) - 1))
    A__         =    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					:     Tuple						,		a					:     Union[str, Any]						,		a					:     List[Any]						,		a					:     Tuple						)					->      Any:






    """simple docstring"""


    A__         =    NatForImageClassification(a						)
    model.to(a						)
    model.eval()
    A__         =    model(a						,		labels=a						)
    self.parent.assertEqual(result.logits.shape						,		(self.batch_size, self.num_labels)						)

    # test greyscale images
    A__         =    1
    A__         =    NatForImageClassification(a						)
    model.to(a						)
    model.eval()

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






 def 	_UpperCamelCase   (self					:     Any						,		a					:     int						,		a					:     int						,		a					:     Dict						)					->      int:






    """simple docstring"""


    A__         =    NatBackbone(config=a						)
    model.to(a						)
    model.eval()
    A__         =    model(a						)

    # 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
    A__         =    None
    A__         =    NatBackbone(config=a						)
    model.to(a						)
    model.eval()
    A__         =    model(a						)

    # 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[Any]						)					->      str:






    """simple docstring"""


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




@require_natten
@require_torch
class   _snake_case( snake_case_					,   snake_case_					,   unittest.TestCase			):
 __snake_case:       List[str]									=				(
     (
         NatModel,
         NatForImageClassification,
         NatBackbone,
     )
     if is_torch_available()
     else ()
 )
 __snake_case:       Any									=				(
     {'''feature-extraction''': NatModel, '''image-classification''': NatForImageClassification}
     if is_torch_available()
     else {}
 )
 __snake_case:       Optional[Any]									=				False

 __snake_case:       Optional[int]									=				False
 __snake_case:       Dict									=				False
 __snake_case:       Union[str, Any]									=				False
 __snake_case:       Any									=				False






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






    """simple docstring"""


    A__         =    NatModelTester(self						)
    A__         =    ConfigTester(self						,		config_class=a						,		embed_dim=37						)






 def 	_UpperCamelCase   (self					:     Optional[int]						)					->      Optional[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 	_UpperCamelCase   (self					:     List[str]						)					->      List[str]:






    """simple docstring"""


    return






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






    """simple docstring"""


    A__         =    self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_model(*a						)






 def 	_UpperCamelCase   (self					:     List[str]						)					->      Optional[int]:






    """simple docstring"""


    A__         =    self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_image_classification(*a						)






 def 	_UpperCamelCase   (self					:     Tuple						)					->      List[str]:






    """simple docstring"""


    A__         =    self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_backbone(*a						)






 @unittest.skip(reason='Nat does not use inputs_embeds'						)
 def 	_UpperCamelCase   (self					:     Any						)					->      int:






    """simple docstring"""


    pass






 @unittest.skip(reason='Nat does not use feedforward chunking'						)
 def 	_UpperCamelCase   (self					:     int						)					->      Tuple:






    """simple docstring"""


    pass






 def 	_UpperCamelCase   (self					:     Dict						)					->      str:






    """simple docstring"""


    A__     , A__         =    self.model_tester.prepare_config_and_inputs_for_common()

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






 def 	_UpperCamelCase   (self					:     Union[str, Any]						)					->      Optional[int]:






    """simple docstring"""


    A__     , A__         =    self.model_tester.prepare_config_and_inputs_for_common()

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

       A__         =    ['pixel_values']
       self.assertListEqual(arg_names[:1]						,		a						)






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






    """simple docstring"""


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






 def 	_UpperCamelCase   (self					:     Optional[Any]						,		a					:     str						,		a					:     Optional[int]						,		a					:     List[str]						,		a					:     Union[str, Any]						)					->      List[Any]:






    """simple docstring"""


    A__         =    model_class(a						)
    model.to(a						)
    model.eval()

    with torch.no_grad():
       A__         =    model(**self._prepare_for_class(a						,		a						)						)

    A__         =    outputs.hidden_states

    A__         =    getattr(
        self.model_tester						,		'expected_num_hidden_layers'						,		len(self.model_tester.depths						) + 1						)
    self.assertEqual(len(a						)						,		a						)

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

    A__         =    image_size[0] // patch_size[0]
    A__         =    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__ != "NatBackbone":
       A__         =    outputs.reshaped_hidden_states
       self.assertEqual(len(a						)						,		a						)

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






 def 	_UpperCamelCase   (self					:     Optional[int]						)					->      Dict:






    """simple docstring"""


    A__     , A__         =    self.model_tester.prepare_config_and_inputs_for_common()

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

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

       self.check_hidden_states_output(a						,		a						,		a						,		a						)






 @slow
 def 	_UpperCamelCase   (self					:     Optional[int]						)					->      List[Any]:






    """simple docstring"""


    for model_name in NAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       A__         =    NatModel.from_pretrained(a						)
       self.assertIsNotNone(a						)






 def 	_UpperCamelCase   (self					:     str						)					->      Optional[Any]:






    """simple docstring"""


    A__     , A__         =    self.model_tester.prepare_config_and_inputs_for_common()

    A__         =    _config_zero_init(a						)
    for model_class in self.all_model_classes:
       A__         =    model_class(config=a						)
       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   _snake_case( unittest.TestCase			):






 @cached_property
 def 	_UpperCamelCase   (self					:     str						)					->      Dict:






    """simple docstring"""


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






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






    """simple docstring"""


    A__         =    NatForImageClassification.from_pretrained('shi-labs/nat-mini-in1k-224'						).to(a						)
    A__         =    self.default_image_processor

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

    # forward pass
    with torch.no_grad():
       A__         =    model(**a						)

    # verify the logits
    A__         =    torch.Size((1, 10_00)						)
    self.assertEqual(outputs.logits.shape						,		a						)
    A__         =    torch.tensor([0.3805, -0.8676, -0.3912]						).to(a						)
    self.assertTrue(torch.allclose(outputs.logits[0, :3]						,		a						,		atol=1e-4						)						)




@require_torch
@require_natten
class   _snake_case( unittest.TestCase					,   snake_case_			):
 __snake_case:       str									=				(NatBackbone,) if is_torch_available() else ()
 __snake_case:       int									=				NatConfig






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






    """simple docstring"""


    A__         =    NatModelTester(self						)








'''simple docstring'''







def 	_A			(   UpperCAmelCase	):






   '''simple docstring'''







   if not isinstance(UpperCAmelCase			,UpperCAmelCase	) or not all(
       isinstance(UpperCAmelCase			,UpperCAmelCase	) and item >= 0 for item in citations	):
      raise ValueError('The citations should be a list of non negative integers.'	)

   citations.sort()
   A__         =    len(UpperCAmelCase	)

   for i in range(UpperCAmelCase	):
      if citations[len_citations - 1 - i] <= i:
         return i

   return len_citations


if __name__ == "__main__":
    import doctest

    doctest.testmod()


