code: 
  '''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 						lowercase     :
  
  
  
  
  
  
        def __init__(self ,  a__ ,  a__=1_3 ,  a__=6_4 ,  a__=4 ,  a__=3 ,  a__=1_6 ,  a__=[1, 2, 1] ,  a__=[2, 4, 8] ,  a__=3 ,  a__=2.0 ,  a__=True ,  a__=0.0 ,  a__=0.0 ,  a__=0.1 ,  a__="gelu" ,  a__=True ,  a__=0.02 ,  a__=1E-5 ,  a__=True ,  a__=None ,  a__=True ,  a__=1_0 ,  a__=["stage1", "stage2"] ,  a__=[1, 2] ,  )       ->   str:
           SCREAMING_SNAKE_CASE__			:				Optional[int]       						= parent
           SCREAMING_SNAKE_CASE__			:				str       						= batch_size
           SCREAMING_SNAKE_CASE__			:				int       						= image_size
           SCREAMING_SNAKE_CASE__			:				Dict       						= patch_size
           SCREAMING_SNAKE_CASE__			:				Tuple       						= num_channels
           SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= embed_dim
           SCREAMING_SNAKE_CASE__			:				str       						= depths
           SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= num_heads
           SCREAMING_SNAKE_CASE__			:				str       						= kernel_size
           SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= mlp_ratio
           SCREAMING_SNAKE_CASE__			:				Tuple       						= qkv_bias
           SCREAMING_SNAKE_CASE__			:				Any       						= hidden_dropout_prob
           SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= attention_probs_dropout_prob
           SCREAMING_SNAKE_CASE__			:				Any       						= drop_path_rate
           SCREAMING_SNAKE_CASE__			:				Any       						= hidden_act
           SCREAMING_SNAKE_CASE__			:				List[Any]       						= patch_norm
           SCREAMING_SNAKE_CASE__			:				int       						= layer_norm_eps
           SCREAMING_SNAKE_CASE__			:				str       						= initializer_range
           SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= is_training
           SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= scope
           SCREAMING_SNAKE_CASE__			:				str       						= use_labels
           SCREAMING_SNAKE_CASE__			:				str       						= num_labels
           SCREAMING_SNAKE_CASE__			:				int       						= out_features
           SCREAMING_SNAKE_CASE__			:				int       						= out_indices
  
  
  
  
  
  
        def    A__(self					)       ->   Optional[Any]:
           SCREAMING_SNAKE_CASE__			:				Dict       						= floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)
  
           SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= None
           if self.use_labels:
              SCREAMING_SNAKE_CASE__			:				Optional[int]       						= ids_tensor([self.batch_size] ,  self.num_labels					)
  
           SCREAMING_SNAKE_CASE__			:				str       						= self.get_config()
  
           return config, pixel_values, labels
  
  
  
  
  
  
        def    A__(self					)       ->   List[Any]:
           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    A__(self ,  a__ ,  a__ ,  a__					)       ->   List[str]:
           SCREAMING_SNAKE_CASE__			:				int       						= NatModel(config=a__					)
           model.to(a__					)
           model.eval()
           SCREAMING_SNAKE_CASE__			:				Dict       						= model(a__					)
  
           SCREAMING_SNAKE_CASE__			:				str       						= (config.image_size // config.patch_size) // (2 ** (len(config.depths					) - 1))
           SCREAMING_SNAKE_CASE__			:				List[str]       						= 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 ,  a__ ,  a__ ,  a__					)       ->   List[str]:
           SCREAMING_SNAKE_CASE__			:				List[Any]       						= NatForImageClassification(a__					)
           model.to(a__					)
           model.eval()
           SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= model(a__ ,  labels=a__					)
           self.parent.assertEqual(result.logits.shape ,  (self.batch_size, self.num_labels)					)
  
           # test greyscale images
           SCREAMING_SNAKE_CASE__			:				int       						= 1
           SCREAMING_SNAKE_CASE__			:				Tuple       						= NatForImageClassification(a__					)
           model.to(a__					)
           model.eval()
  
           SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= floats_tensor([self.batch_size, 1, self.image_size, self.image_size]					)
           SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= model(a__					)
           self.parent.assertEqual(result.logits.shape ,  (self.batch_size, self.num_labels)					)
  
  
  
  
  
  
        def    A__(self ,  a__ ,  a__ ,  a__					)       ->   Tuple:
           SCREAMING_SNAKE_CASE__			:				List[str]       						= NatBackbone(config=a__					)
           model.to(a__					)
           model.eval()
           SCREAMING_SNAKE_CASE__			:				Optional[int]       						= 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], 1_6, 1_6]					)
  
           # verify channels
           self.parent.assertEqual(len(model.channels					) ,  len(config.out_features					)					)
  
           # verify backbone works with out_features=None
           SCREAMING_SNAKE_CASE__			:				Tuple       						= None
           SCREAMING_SNAKE_CASE__			:				Tuple       						= NatBackbone(config=a__					)
           model.to(a__					)
           model.eval()
           SCREAMING_SNAKE_CASE__			:				Tuple       						= 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    A__(self					)       ->   str:
           SCREAMING_SNAKE_CASE__			:				str       						= self.prepare_config_and_inputs()
           SCREAMING_SNAKE_CASE__						,				SCREAMING_SNAKE_CASE__						,				SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= config_and_inputs
           SCREAMING_SNAKE_CASE__			:				str       						= {'''pixel_values''': pixel_values}
           return config, inputs_dict
  
  
  
  
  
  
  @require_natten
  @require_torch
  class 						lowercase     (   UpperCAmelCase_				,			UpperCAmelCase_				,			unittest.TestCase):
        __lowercase 		=  (
            (
                NatModel,
                NatForImageClassification,
                NatBackbone,
            )
            if is_torch_available()
            else ()
        )
        __lowercase 		=  (
            {'''feature-extraction''': NatModel, '''image-classification''': NatForImageClassification}
            if is_torch_available()
            else {}
        )
        __lowercase 		=  False
  
        __lowercase 		=  False
        __lowercase 		=  False
        __lowercase 		=  False
        __lowercase 		=  False
  
  
  
  
  
  
        def    A__(self					)       ->   Dict:
           SCREAMING_SNAKE_CASE__			:				Tuple       						= NatModelTester(self					)
           SCREAMING_SNAKE_CASE__			:				str       						= ConfigTester(self ,  config_class=a__ ,  embed_dim=3_7					)
  
  
  
  
  
  
        def    A__(self					)       ->   Tuple:
           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					)       ->   Tuple:
           return
  
  
  
  
  
  
        def    A__(self					)       ->   Tuple:
           SCREAMING_SNAKE_CASE__			:				List[str]       						= self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*a__					)
  
  
  
  
  
  
        def    A__(self					)       ->   str:
           SCREAMING_SNAKE_CASE__			:				Dict       						= self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_image_classification(*a__					)
  
  
  
  
  
  
        def    A__(self					)       ->   List[str]:
           SCREAMING_SNAKE_CASE__			:				List[str]       						= 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    A__(self					)       ->   Tuple:
           pass
  
  
  
  
  
  
        @unittest.skip(reason='''Nat does not use feedforward chunking'''					)
        def    A__(self					)       ->   str:
           pass
  
  
  
  
  
  
        def    A__(self					)       ->   Any:
           SCREAMING_SNAKE_CASE__						,				SCREAMING_SNAKE_CASE__			:				int       						= self.model_tester.prepare_config_and_inputs_for_common()
  
           for model_class in self.all_model_classes:
              SCREAMING_SNAKE_CASE__			:				List[str]       						= model_class(a__					)
              self.assertIsInstance(model.get_input_embeddings() ,  (nn.Module)					)
              SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= model.get_output_embeddings()
              self.assertTrue(x is None or isinstance(a__ ,  nn.Linear					)					)
  
  
  
  
  
  
        def    A__(self					)       ->   Optional[int]:
           SCREAMING_SNAKE_CASE__						,				SCREAMING_SNAKE_CASE__			:				Any       						= self.model_tester.prepare_config_and_inputs_for_common()
  
           for model_class in self.all_model_classes:
              SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= model_class(a__					)
              SCREAMING_SNAKE_CASE__			:				Optional[int]       						= inspect.signature(model.forward					)
              # signature.parameters is an OrderedDict => so arg_names order is deterministic
              SCREAMING_SNAKE_CASE__			:				Tuple       						= [*signature.parameters.keys()]
  
              SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= ['''pixel_values''']
              self.assertListEqual(arg_names[:1] ,  a__					)
  
  
  
  
  
  
        def    A__(self					)       ->   Tuple:
           self.skipTest('''Nat\'s attention operation is handled entirely by NATTEN.'''					)
  
  
  
  
  
  
        def    A__(self ,  a__ ,  a__ ,  a__ ,  a__					)       ->   Dict:
           SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= model_class(a__					)
           model.to(a__					)
           model.eval()
  
           with torch.no_grad():
              SCREAMING_SNAKE_CASE__			:				Dict       						= model(**self._prepare_for_class(a__ ,  a__					)					)
  
           SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= outputs.hidden_states
  
           SCREAMING_SNAKE_CASE__			:				Tuple       						= 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
           SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= (
               config.patch_size
               if isinstance(config.patch_size ,  collections.abc.Iterable					)
               else (config.patch_size, config.patch_size)
           )
  
           SCREAMING_SNAKE_CASE__			:				List[Any]       						= image_size[0] // patch_size[0]
           SCREAMING_SNAKE_CASE__			:				str       						= 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":
              SCREAMING_SNAKE_CASE__			:				Tuple       						= outputs.reshaped_hidden_states
              self.assertEqual(len(a__					) ,  a__					)
  
              SCREAMING_SNAKE_CASE__						,				SCREAMING_SNAKE_CASE__						,				SCREAMING_SNAKE_CASE__						,				SCREAMING_SNAKE_CASE__			:				List[Any]       						= reshaped_hidden_states[0].shape
              SCREAMING_SNAKE_CASE__			:				str       						= (
                  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    A__(self					)       ->   str:
           SCREAMING_SNAKE_CASE__						,				SCREAMING_SNAKE_CASE__			:				List[Any]       						= self.model_tester.prepare_config_and_inputs_for_common()
  
           SCREAMING_SNAKE_CASE__			:				List[Any]       						= (
               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:
              SCREAMING_SNAKE_CASE__			:				str       						= 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"]
              SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= True
  
              self.check_hidden_states_output(a__ ,  a__ ,  a__ ,  a__					)
  
  
  
  
  
  
        @slow
        def    A__(self					)       ->   Union[str, Any]:
           for model_name in NAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= NatModel.from_pretrained(a__					)
              self.assertIsNotNone(a__					)
  
  
  
  
  
  
        def    A__(self					)       ->   Optional[Any]:
           SCREAMING_SNAKE_CASE__						,				SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= self.model_tester.prepare_config_and_inputs_for_common()
  
           SCREAMING_SNAKE_CASE__			:				Optional[int]       						= _config_zero_init(a__					)
           for model_class in self.all_model_classes:
              SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= 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 						lowercase     (   unittest.TestCase):
  
  
  
  
  
  
        @cached_property
        def    A__(self					)       ->   Tuple:
           return AutoImageProcessor.from_pretrained('''shi-labs/nat-mini-in1k-224'''					) if is_vision_available() else None
  
  
  
  
  
  
        @slow
        def    A__(self					)       ->   Optional[int]:
           SCREAMING_SNAKE_CASE__			:				Tuple       						= NatForImageClassification.from_pretrained('''shi-labs/nat-mini-in1k-224'''					).to(a__					)
           SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= self.default_image_processor
  
           SCREAMING_SNAKE_CASE__			:				str       						= Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''					)
           SCREAMING_SNAKE_CASE__			:				str       						= image_processor(images=a__ ,  return_tensors='''pt'''					).to(a__					)
  
           # forward pass
           with torch.no_grad():
              SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= model(**a__					)
  
           # verify the logits
           SCREAMING_SNAKE_CASE__			:				Any       						= torch.Size((1, 1_0_0_0)					)
           self.assertEqual(outputs.logits.shape ,  a__					)
           SCREAMING_SNAKE_CASE__			:				int       						= torch.tensor([0.38_05, -0.86_76, -0.39_12]					).to(a__					)
           self.assertTrue(torch.allclose(outputs.logits[0, :3] ,  a__ ,  atol=1E-4					)					)
  
  
  
  
  
  
  @require_torch
  @require_natten
  class 						lowercase     (   unittest.TestCase				,			UpperCAmelCase_):
        __lowercase 		=  (NatBackbone,) if is_torch_available() else ()
        __lowercase 		=  NatConfig
  
  
  
  
  
  
        def    A__(self					)       ->   int:
           SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= NatModelTester(self					)
  
  
style_context: 
  
  
  
  
  '''simple docstring'''
  
  
  
  
  
  # Copyright 2023 The HuggingFace Team. All rights reserved.
  #
  # Licensed under the Apache License, Version 2.0 (the "License");
  # you may not use this file except in compliance with the License.
  # You may obtain a copy of the License at
  #
  #     http://www.apache.org/licenses/LICENSE-2.0
  #
  # Unless required by applicable law or agreed to in writing, software
  # distributed under the License is distributed on an "AS IS" BASIS,
  # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  # See the License for the specific language governing permissions and
  # limitations under the License.
  from typing import TYPE_CHECKING
  
  # rely on isort to merge the imports
  from ...utils import (
      OptionalDependencyNotAvailable,
      _LazyModule,
      is_torch_available,
  )
  
  
  lowercase__			=	{
      '''configuration_convnextv2''': [
          '''CONVNEXTV2_PRETRAINED_CONFIG_ARCHIVE_MAP''',
          '''ConvNextV2Config''',
      ]
  }
  
  try:
         if not is_torch_available():
                raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
         pass
  else:
         lowercase__			=	[
             '''CONVNEXTV2_PRETRAINED_MODEL_ARCHIVE_LIST''',
             '''ConvNextV2ForImageClassification''',
             '''ConvNextV2Model''',
             '''ConvNextV2PreTrainedModel''',
             '''ConvNextV2Backbone''',
         ]
  
  
  if TYPE_CHECKING:
         from .configuration_convnextva import (
             CONVNEXTV2_PRETRAINED_CONFIG_ARCHIVE_MAP,
             ConvNextVaConfig,
         )
  
         try:
                if not is_torch_available():
                       raise OptionalDependencyNotAvailable()
         except OptionalDependencyNotAvailable:
                pass
         else:
                from .modeling_convnextva import (
                    CONVNEXTV2_PRETRAINED_MODEL_ARCHIVE_LIST,
                    ConvNextVaBackbone,
                    ConvNextVaForImageClassification,
                    ConvNextVaModel,
                    ConvNextVaPreTrainedModel,
                )
  
  else:
         import sys
  
         lowercase__			=	_LazyModule(__name__, globals()['''__file__'''], _import_structure)
  
  