code: 
  
  
  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 		_SCREAMING_SNAKE_CASE    :
  
  
       def __init__(     self       ,				A_       ,				A_=13       ,				A_=64       ,				A_=4       ,				A_=3       ,				A_=16       ,				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.0_2       ,				A_=1e-5       ,				A_=True       ,				A_=None       ,				A_=True       ,				A_=10       ,				A_=["stage1", "stage2"]       ,				A_=[1, 2]       ,				):
         _UpperCAmelCase		:       Dict       =    parent
         _UpperCAmelCase		:       Optional[Any]       =    batch_size
         _UpperCAmelCase		:       Union[str, Any]       =    image_size
         _UpperCAmelCase		:       List[Any]       =    patch_size
         _UpperCAmelCase		:       str       =    num_channels
         _UpperCAmelCase		:       int       =    embed_dim
         _UpperCAmelCase		:       List[Any]       =    depths
         _UpperCAmelCase		:       Optional[Any]       =    num_heads
         _UpperCAmelCase		:       Optional[Any]       =    kernel_size
         _UpperCAmelCase		:       Optional[Any]       =    mlp_ratio
         _UpperCAmelCase		:       Any       =    qkv_bias
         _UpperCAmelCase		:       Dict       =    hidden_dropout_prob
         _UpperCAmelCase		:       List[Any]       =    attention_probs_dropout_prob
         _UpperCAmelCase		:       Dict       =    drop_path_rate
         _UpperCAmelCase		:       Dict       =    hidden_act
         _UpperCAmelCase		:       int       =    patch_norm
         _UpperCAmelCase		:       Optional[int]       =    layer_norm_eps
         _UpperCAmelCase		:       Tuple       =    initializer_range
         _UpperCAmelCase		:       Dict       =    is_training
         _UpperCAmelCase		:       str       =    scope
         _UpperCAmelCase		:       str       =    use_labels
         _UpperCAmelCase		:       Union[str, Any]       =    num_labels
         _UpperCAmelCase		:       Union[str, Any]       =    out_features
         _UpperCAmelCase		:       Tuple       =    out_indices
  
  
       def 					__snake_case(     self						):
         _UpperCAmelCase		:       Tuple       =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)
  
         _UpperCAmelCase		:       List[Any]       =    None
         if self.use_labels:
           _UpperCAmelCase		:       int       =    ids_tensor([self.batch_size]       ,				self.num_labels						)
  
         _UpperCAmelCase		:       Optional[int]       =    self.get_config()
  
         return config, pixel_values, labels
  
  
       def 					__snake_case(     self						):
         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 					__snake_case(     self       ,				A_       ,				A_       ,				A_						):
         _UpperCAmelCase		:       Dict       =    NatModel(config=A_						)
         model.to(A_						)
         model.eval()
         _UpperCAmelCase		:       List[str]       =    model(A_						)
  
         _UpperCAmelCase		:       Optional[Any]       =    (config.image_size // config.patch_size) // (2 ** (len(config.depths						) - 1))
         _UpperCAmelCase		:       Dict       =    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 					__snake_case(     self       ,				A_       ,				A_       ,				A_						):
         _UpperCAmelCase		:       Tuple       =    NatForImageClassification(A_						)
         model.to(A_						)
         model.eval()
         _UpperCAmelCase		:       Any       =    model(A_       ,				labels=A_						)
         self.parent.assertEqual(result.logits.shape       ,				(self.batch_size, self.num_labels)						)
  
         # test greyscale images
         _UpperCAmelCase		:       Tuple       =    1
         _UpperCAmelCase		:       Tuple       =    NatForImageClassification(A_						)
         model.to(A_						)
         model.eval()
  
         _UpperCAmelCase		:       int       =    floats_tensor([self.batch_size, 1, self.image_size, self.image_size]						)
         _UpperCAmelCase		:       int       =    model(A_						)
         self.parent.assertEqual(result.logits.shape       ,				(self.batch_size, self.num_labels)						)
  
  
       def 					__snake_case(     self       ,				A_       ,				A_       ,				A_						):
         _UpperCAmelCase		:       Optional[Any]       =    NatBackbone(config=A_						)
         model.to(A_						)
         model.eval()
         _UpperCAmelCase		:       Union[str, Any]       =    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
         _UpperCAmelCase		:       List[str]       =    None
         _UpperCAmelCase		:       Dict       =    NatBackbone(config=A_						)
         model.to(A_						)
         model.eval()
         _UpperCAmelCase		:       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 					__snake_case(     self						):
         _UpperCAmelCase		:       List[Any]       =    self.prepare_config_and_inputs()
         _UpperCAmelCase,_UpperCAmelCase,_UpperCAmelCase		:       List[str]       =    config_and_inputs
         _UpperCAmelCase		:       Union[str, Any]       =    {"""pixel_values""": pixel_values}
         return config, inputs_dict
  
  
  @require_natten
  @require_torch
  class 		_SCREAMING_SNAKE_CASE    (	A       ,  A       ,  unittest.TestCase    ):
       __SCREAMING_SNAKE_CASE    				=						(
           (
               NatModel,
               NatForImageClassification,
               NatBackbone,
           )
           if is_torch_available()
           else ()
       )
       __SCREAMING_SNAKE_CASE    				=						(
           {'''feature-extraction''': NatModel, '''image-classification''': NatForImageClassification}
           if is_torch_available()
           else {}
       )
       __SCREAMING_SNAKE_CASE    				=						False
  
       __SCREAMING_SNAKE_CASE    				=						False
       __SCREAMING_SNAKE_CASE    				=						False
       __SCREAMING_SNAKE_CASE    				=						False
       __SCREAMING_SNAKE_CASE    				=						False
  
  
       def 					__snake_case(     self						):
         _UpperCAmelCase		:       int       =    NatModelTester(self						)
         _UpperCAmelCase		:       Any       =    ConfigTester(self       ,				config_class=A_       ,				embed_dim=37						)
  
  
       def 					__snake_case(     self						):
         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 					__snake_case(     self						):
         return
  
  
       def 					__snake_case(     self						):
         _UpperCAmelCase		:       Optional[Any]       =    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*A_						)
  
  
       def 					__snake_case(     self						):
         _UpperCAmelCase		:       Any       =    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*A_						)
  
  
       def 					__snake_case(     self						):
         _UpperCAmelCase		:       Optional[int]       =    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 					__snake_case(     self						):
         pass
  
  
       @unittest.skip(reason="""Nat does not use feedforward chunking"""						)
       def 					__snake_case(     self						):
         pass
  
  
       def 					__snake_case(     self						):
         _UpperCAmelCase,_UpperCAmelCase		:       Optional[Any]       =    self.model_tester.prepare_config_and_inputs_for_common()
  
         for model_class in self.all_model_classes:
           _UpperCAmelCase		:       Any       =    model_class(A_						)
           self.assertIsInstance(model.get_input_embeddings()       ,				(nn.Module)						)
           _UpperCAmelCase		:       List[str]       =    model.get_output_embeddings()
           self.assertTrue(x is None or isinstance(A_       ,				nn.Linear						)						)
  
  
       def 					__snake_case(     self						):
         _UpperCAmelCase,_UpperCAmelCase		:       List[Any]       =    self.model_tester.prepare_config_and_inputs_for_common()
  
         for model_class in self.all_model_classes:
           _UpperCAmelCase		:       Union[str, Any]       =    model_class(A_						)
           _UpperCAmelCase		:       Optional[Any]       =    inspect.signature(model.forward						)
           # signature.parameters is an OrderedDict => so arg_names order is deterministic
           _UpperCAmelCase		:       Tuple       =    [*signature.parameters.keys()]
  
           _UpperCAmelCase		:       Union[str, Any]       =    ["""pixel_values"""]
           self.assertListEqual(arg_names[:1]       ,				A_						)
  
  
       def 					__snake_case(     self						):
         self.skipTest("""Nat's attention operation is handled entirely by NATTEN."""						)
  
  
       def 					__snake_case(     self       ,				A_       ,				A_       ,				A_       ,				A_						):
         _UpperCAmelCase		:       Tuple       =    model_class(A_						)
         model.to(A_						)
         model.eval()
  
         with torch.no_grad():
           _UpperCAmelCase		:       List[Any]       =    model(**self._prepare_for_class(A_       ,				A_						)						)
  
         _UpperCAmelCase		:       List[Any]       =    outputs.hidden_states
  
         _UpperCAmelCase		:       List[str]       =    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
         _UpperCAmelCase		:       int       =    (
             config.patch_size
             if isinstance(config.patch_size       ,				collections.abc.Iterable						)
             else (config.patch_size, config.patch_size)
         )
  
         _UpperCAmelCase		:       Optional[int]       =    image_size[0] // patch_size[0]
         _UpperCAmelCase		:       List[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__ != "NatBackbone":
           _UpperCAmelCase		:       Optional[Any]       =    outputs.reshaped_hidden_states
           self.assertEqual(len(A_						)       ,				A_						)
  
           _UpperCAmelCase,_UpperCAmelCase,_UpperCAmelCase,_UpperCAmelCase		:       Tuple       =    reshaped_hidden_states[0].shape
           _UpperCAmelCase		:       Dict       =    (
               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 					__snake_case(     self						):
         _UpperCAmelCase,_UpperCAmelCase		:       Union[str, Any]       =    self.model_tester.prepare_config_and_inputs_for_common()
  
         _UpperCAmelCase		:       List[str]       =    (
             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		:       Optional[int]       =    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"]
           _UpperCAmelCase		:       str       =    True
  
           self.check_hidden_states_output(A_       ,				A_       ,				A_       ,				A_						)
  
  
       @slow
       def 					__snake_case(     self						):
         for model_name in NAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           _UpperCAmelCase		:       int       =    NatModel.from_pretrained(A_						)
           self.assertIsNotNone(A_						)
  
  
  
  
       def 					__snake_case(     self						):
         _UpperCAmelCase,_UpperCAmelCase		:       Any       =    self.model_tester.prepare_config_and_inputs_for_common()
  
         _UpperCAmelCase		:       Dict       =    _config_zero_init(A_						)
         for model_class in self.all_model_classes:
           _UpperCAmelCase		:       Tuple       =    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 		_SCREAMING_SNAKE_CASE    (	unittest.TestCase    ):
  
  
       @cached_property
       def 					__snake_case(     self						):
         return AutoImageProcessor.from_pretrained("""shi-labs/nat-mini-in1k-224"""						) if is_vision_available() else None
  
  
  
  
       @slow
       def 					__snake_case(     self						):
         _UpperCAmelCase		:       Optional[int]       =    NatForImageClassification.from_pretrained("""shi-labs/nat-mini-in1k-224"""						).to(A_						)
         _UpperCAmelCase		:       Optional[Any]       =    self.default_image_processor
  
         _UpperCAmelCase		:       List[str]       =    Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""						)
         _UpperCAmelCase		:       int       =    image_processor(images=A_       ,				return_tensors="""pt"""						).to(A_						)
  
         # forward pass
         with torch.no_grad():
           _UpperCAmelCase		:       Dict       =    model(**A_						)
  
         # verify the logits
         _UpperCAmelCase		:       List[Any]       =    torch.Size((1, 10_00)						)
         self.assertEqual(outputs.logits.shape       ,				A_						)
         _UpperCAmelCase		:       str       =    torch.tensor([0.3_8_0_5, -0.8_6_7_6, -0.3_9_1_2]						).to(A_						)
         self.assertTrue(torch.allclose(outputs.logits[0, :3]       ,				A_       ,				atol=1e-4						)						)
  
  
  @require_torch
  @require_natten
  class 		_SCREAMING_SNAKE_CASE    (	unittest.TestCase       ,  A    ):
       __SCREAMING_SNAKE_CASE    				=						(NatBackbone,) if is_torch_available() else ()
       __SCREAMING_SNAKE_CASE    				=						NatConfig
  
  
       def 					__snake_case(     self						):
         _UpperCAmelCase		:       Any       =    NatModelTester(self						)
  
  
  
  
  
  
style_context: 
  
  
  from typing import TYPE_CHECKING
  
  from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available
  
  
  SCREAMING_SNAKE_CASE__				:    List[str]         =    {
      'configuration_flaubert': ['FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'FlaubertConfig', 'FlaubertOnnxConfig'],
      'tokenization_flaubert': ['FlaubertTokenizer'],
  }
  
  try:
   if not is_torch_available():
    raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
   pass
  else:
   SCREAMING_SNAKE_CASE__				:    int         =    [
       'FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
       'FlaubertForMultipleChoice',
       'FlaubertForQuestionAnswering',
       'FlaubertForQuestionAnsweringSimple',
       'FlaubertForSequenceClassification',
       'FlaubertForTokenClassification',
       'FlaubertModel',
       'FlaubertWithLMHeadModel',
       'FlaubertPreTrainedModel',
   ]
  
  try:
   if not is_tf_available():
    raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
   pass
  else:
   SCREAMING_SNAKE_CASE__				:    Dict         =    [
       'TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
       'TFFlaubertForMultipleChoice',
       'TFFlaubertForQuestionAnsweringSimple',
       'TFFlaubertForSequenceClassification',
       'TFFlaubertForTokenClassification',
       'TFFlaubertModel',
       'TFFlaubertPreTrainedModel',
       'TFFlaubertWithLMHeadModel',
   ]
  
  
  if TYPE_CHECKING:
   from .configuration_flaubert import FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, FlaubertConfig, FlaubertOnnxConfig
   from .tokenization_flaubert import FlaubertTokenizer
  
   try:
    if not is_torch_available():
     raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
    pass
   else:
    from .modeling_flaubert import (
        FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
        FlaubertForMultipleChoice,
        FlaubertForQuestionAnswering,
        FlaubertForQuestionAnsweringSimple,
        FlaubertForSequenceClassification,
        FlaubertForTokenClassification,
        FlaubertModel,
        FlaubertPreTrainedModel,
        FlaubertWithLMHeadModel,
    )
  
   try:
    if not is_tf_available():
     raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
    pass
   else:
    from .modeling_tf_flaubert import (
        TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFFlaubertForMultipleChoice,
        TFFlaubertForQuestionAnsweringSimple,
        TFFlaubertForSequenceClassification,
        TFFlaubertForTokenClassification,
        TFFlaubertModel,
        TFFlaubertPreTrainedModel,
        TFFlaubertWithLMHeadModel,
    )
  
  else:
   import sys
  
   SCREAMING_SNAKE_CASE__				:    List[Any]         =    _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
  
  
  
  
  
  