






'''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        a__     :
     '''simple docstring'''







     def __init__(self     :						str					,					lowercase__     :						int					,					lowercase__     :						List[str]=13					,					lowercase__     :						List[Any]=64					,					lowercase__     :						int=4					,					lowercase__     :						int=3					,					lowercase__     :						Union[str, Any]=16					,					lowercase__     :						Union[str, Any]=[1, 2, 1]					,					lowercase__     :						List[str]=[2, 4, 8]					,					lowercase__     :						Optional[Any]=3					,					lowercase__     :						str=2.0					,					lowercase__     :						Optional[Any]=True					,					lowercase__     :						List[Any]=0.0					,					lowercase__     :						Optional[Any]=0.0					,					lowercase__     :						Optional[Any]=0.1					,					lowercase__     :						str="gelu"					,					lowercase__     :						Any=True					,					lowercase__     :						str=0.02					,					lowercase__     :						Optional[int]=1e-5					,					lowercase__     :						List[str]=True					,					lowercase__     :						Optional[int]=None					,					lowercase__     :						Optional[int]=True					,					lowercase__     :						Optional[Any]=10					,					lowercase__     :						str=["stage1", "stage2"]					,					lowercase__     :						str=[1, 2]					,					)	->							List[str]:
           __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     :						Union[str, Any]       )	->							Tuple:
           __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     :						List[Any]       )	->							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      _UpperCamelCase (self     :						List[Any]					,					lowercase__     :						Union[str, Any]					,					lowercase__     :						List[Any]					,					lowercase__     :						int       )	->							List[Any]:
           __A		 =   NatModel(config=lowercase__       )
           model.to(lowercase__       )
           model.eval()
           __A		 =   model(lowercase__       )

           __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     :						List[str]					,					lowercase__     :						Dict					,					lowercase__     :						Dict					,					lowercase__     :						Dict       )	->							Union[str, Any]:
           __A		 =   NatForImageClassification(lowercase__       )
           model.to(lowercase__       )
           model.eval()
           __A		 =   model(lowercase__					,					labels=lowercase__       )
           self.parent.assertEqual(result.logits.shape					,					(self.batch_size, self.num_labels)       )

           # test greyscale images
           __A		 =   1
           __A		 =   NatForImageClassification(lowercase__       )
           model.to(lowercase__       )
           model.eval()

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






     def      _UpperCamelCase (self     :						Tuple					,					lowercase__     :						Optional[Any]					,					lowercase__     :						str					,					lowercase__     :						Any       )	->							Union[str, Any]:
           __A		 =   NatBackbone(config=lowercase__       )
           model.to(lowercase__       )
           model.eval()
           __A		 =   model(lowercase__       )

           # 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=lowercase__       )
           model.to(lowercase__       )
           model.eval()
           __A		 =   model(lowercase__       )

           # 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     :						Union[str, Any]       )	->							Union[str, Any]:
           __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        a__     (      lowerCamelCase			,    lowerCamelCase			,    unittest.TestCase    ):
     '''simple docstring'''







     _snake_case							   =	(
         (
             NatModel,
             NatForImageClassification,
             NatBackbone,
         )
         if is_torch_available()
         else ()
     )
     _snake_case							   =	(
         {'feature-extraction': NatModel, 'image-classification': NatForImageClassification}
         if is_torch_available()
         else {}
     )
     _snake_case							   =	False

     _snake_case							   =	False
     _snake_case							   =	False
     _snake_case							   =	False
     _snake_case							   =	False






     def      _UpperCamelCase (self     :						Any       )	->							Optional[int]:
           __A		 =   NatModelTester(self       )
           __A		 =   ConfigTester(self					,					config_class=lowercase__					,					embed_dim=37       )






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






     def      _UpperCamelCase (self     :						Dict       )	->							str:
           __A		 =   self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*lowercase__       )






     def      _UpperCamelCase (self     :						Optional[Any]       )	->							str:
           __A		 =   self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_image_classification(*lowercase__       )






     def      _UpperCamelCase (self     :						List[str]       )	->							Optional[int]:
           __A		 =   self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_backbone(*lowercase__       )






     @unittest.skip(reason="Nat does not use inputs_embeds"       )
     def      _UpperCamelCase (self     :						Optional[int]       )	->							Union[str, Any]:
           pass






     @unittest.skip(reason="Nat does not use feedforward chunking"       )
     def      _UpperCamelCase (self     :						Any       )	->							str:
           pass






     def      _UpperCamelCase (self     :						Dict       )	->							int:
           __A ,					__A		 =   self.model_tester.prepare_config_and_inputs_for_common()

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






     def      _UpperCamelCase (self     :						Tuple       )	->							List[str]:
           __A ,					__A		 =   self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
                 __A		 =   model_class(lowercase__       )
                 __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]					,					lowercase__       )






     def      _UpperCamelCase (self     :						Optional[Any]       )	->							int:
           self.skipTest("Nat's attention operation is handled entirely by NATTEN."       )






     def      _UpperCamelCase (self     :						List[Any]					,					lowercase__     :						Optional[int]					,					lowercase__     :						Optional[int]					,					lowercase__     :						Optional[int]					,					lowercase__     :						int       )	->							List[str]:
           __A		 =   model_class(lowercase__       )
           model.to(lowercase__       )
           model.eval()

           with torch.no_grad():
                 __A		 =   model(**self._prepare_for_class(lowercase__					,					lowercase__       )       )

           __A		 =   outputs.hidden_states

           __A		 =   getattr(
               self.model_tester					,					"expected_num_hidden_layers"					,					len(self.model_tester.depths       ) + 1       )
           self.assertEqual(len(lowercase__       )					,					lowercase__       )

           # 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(lowercase__       )					,					lowercase__       )

                 __A ,					__A ,					__A ,					__A		 =   reshaped_hidden_states[0].shape
                 __A		 =   (
                     reshaped_hidden_states[0].view(lowercase__					,					lowercase__					,					lowercase__					,					lowercase__       ).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]       )	->							List[Any]:
           __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(lowercase__					,					lowercase__					,					lowercase__					,					lowercase__       )

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

                 self.check_hidden_states_output(lowercase__					,					lowercase__					,					lowercase__					,					lowercase__       )






     @slow
     def      _UpperCamelCase (self     :						int       )	->							List[str]:
           for model_name in NAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 __A		 =   NatModel.from_pretrained(lowercase__       )
                 self.assertIsNotNone(lowercase__       )






     def      _UpperCamelCase (self     :						Union[str, Any]       )	->							Optional[Any]:
           __A ,					__A		 =   self.model_tester.prepare_config_and_inputs_for_common()

           __A		 =   _config_zero_init(lowercase__       )
           for model_class in self.all_model_classes:
                 __A		 =   model_class(config=lowercase__       )
                 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        a__     (      unittest.TestCase    ):
     '''simple docstring'''







     @cached_property
     def      _UpperCamelCase (self     :						List[Any]       )	->							Dict:
           return AutoImageProcessor.from_pretrained("shi-labs/nat-mini-in1k-224"       ) if is_vision_available() else None






     @slow
     def      _UpperCamelCase (self     :						Dict       )	->							Optional[Any]:
           __A		 =   NatForImageClassification.from_pretrained("shi-labs/nat-mini-in1k-224"       ).to(lowercase__       )
           __A		 =   self.default_image_processor

           __A		 =   Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"       )
           __A		 =   image_processor(images=lowercase__					,					return_tensors="pt"       ).to(lowercase__       )

           # forward pass
           with torch.no_grad():
                 __A		 =   model(**lowercase__       )

           # verify the logits
           __A		 =   torch.Size((1, 1000)       )
           self.assertEqual(outputs.logits.shape					,					lowercase__       )
           __A		 =   torch.tensor([0.38_05, -0.86_76, -0.39_12]       ).to(lowercase__       )
           self.assertTrue(torch.allclose(outputs.logits[0, :3]					,					lowercase__					,					atol=1e-4       )       )







@require_torch
@require_natten
class        a__     (      unittest.TestCase			,    lowerCamelCase    ):
     '''simple docstring'''







     _snake_case							   =	(NatBackbone,) if is_torch_available() else ()
     _snake_case							   =	NatConfig






     def      _UpperCamelCase (self     :						Tuple       )	->							Optional[Any]:
           __A		 =   NatModelTester(self       )










'''simple docstring'''







from typing import List, Optional, Union

import numpy as np
import torch
import torchaudio.compliance.kaldi as ta_kaldi

from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import TensorType, logging


__A   :							int     	=						logging.get_logger(__name__)






class        a__     (      lowerCamelCase    ):
     '''simple docstring'''







     _snake_case							   =	['input_values', 'attention_mask']






     def __init__(self     :						Optional[int]					,					lowercase__     :						Tuple=1					,					lowercase__     :						Optional[int]=16000					,					lowercase__     :						Any=128					,					lowercase__     :						Optional[Any]=1024					,					lowercase__     :						int=0.0					,					lowercase__     :						List[str]=True					,					lowercase__     :						Dict=-4.2_67_73_93					,					lowercase__     :						Tuple=4.5_68_99_74					,					lowercase__     :						Optional[int]=False					,					**lowercase__     :						Optional[int]					,					)	->							Tuple:
           super().__init__(feature_size=lowercase__					,					sampling_rate=lowercase__					,					padding_value=lowercase__					,					**lowercase__       )
           __A		 =   num_mel_bins
           __A		 =   max_length
           __A		 =   do_normalize
           __A		 =   mean
           __A		 =   std
           __A		 =   return_attention_mask






     def      _UpperCamelCase (self     :						List[Any]					,					lowercase__     :						np.ndarray					,					lowercase__     :						int					,					)	->							np.ndarray:
           __A		 =   torch.from_numpy(lowercase__       ).unsqueeze(0       )
           __A		 =   ta_kaldi.fbank(
               lowercase__					,					htk_compat=lowercase__					,					sample_frequency=self.sampling_rate					,					use_energy=lowercase__					,					window_type="hanning"					,					num_mel_bins=self.num_mel_bins					,					dither=0.0					,					frame_shift=10					,					)

           __A		 =   fbank.shape[0]
           __A		 =   max_length - n_frames

           # pad or truncate, depending on difference
           if difference > 0:
                 __A		 =   torch.nn.ZeroPadad((0, 0, 0, difference)       )
                 __A		 =   pad_module(lowercase__       )
           elif difference < 0:
                 __A		 =   fbank[0:max_length, :]

           __A		 =   fbank.numpy()

           return fbank






     def      _UpperCamelCase (self     :						int					,					lowercase__     :						np.ndarray       )	->							np.ndarray:
           return (input_values - (self.mean)) / (self.std * 2)






     def __call__(self     :						str					,					lowercase__     :						Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]					,					lowercase__     :						Optional[int] = None					,					lowercase__     :						Optional[Union[str, TensorType]] = None					,					**lowercase__     :						List[Any]					,					)	->							BatchFeature:

           if sampling_rate is not None:
                 if sampling_rate != self.sampling_rate:
                       raise ValueError(
                           f"The model corresponding to this feature extractor: {self} was trained using a sampling rate of"
                           f" {self.sampling_rate}. Please make sure that the provided `raw_speech` input was sampled with"
                           f" {self.sampling_rate} and not {sampling_rate}."       )
           else:
                 logger.warning(
                     "It is strongly recommended to pass the `sampling_rate` argument to this function. "
                     "Failing to do so can result in silent errors that might be hard to debug."       )

           __A		 =   isinstance(lowercase__					,					np.ndarray       ) and len(raw_speech.shape       ) > 1
           if is_batched_numpy and len(raw_speech.shape       ) > 2:
                 raise ValueError(f"Only mono-channel audio is supported for input to {self}"       )
           __A		 =   is_batched_numpy or (
               isinstance(lowercase__					,					(list, tuple)       ) and (isinstance(raw_speech[0]					,					(np.ndarray, tuple, list)       ))
           )

           if is_batched:
                 __A		 =   [np.asarray(lowercase__					,					dtype=np.floataa       ) for speech in raw_speech]
           elif not is_batched and not isinstance(lowercase__					,					np.ndarray       ):
                 __A		 =   np.asarray(lowercase__					,					dtype=np.floataa       )
           elif isinstance(lowercase__					,					np.ndarray       ) and raw_speech.dtype is np.dtype(np.floataa       ):
                 __A		 =   raw_speech.astype(np.floataa       )

           # always return batch
           if not is_batched:
                 __A		 =   [raw_speech]

           # extract fbank features and pad/truncate to max_length
           __A		 =   [self._extract_fbank_features(lowercase__					,					max_length=self.max_length       ) for waveform in raw_speech]

           # convert into BatchFeature
           __A		 =   BatchFeature({"input_values": features}       )

           # make sure list is in array format
           __A		 =   padded_inputs.get("input_values"       )
           if isinstance(input_values[0]					,					lowercase__       ):
                 __A		 =   [np.asarray(lowercase__					,					dtype=np.floataa       ) for feature in input_values]

           # normalization
           if self.do_normalize:
                 __A		 =   [self.normalize(lowercase__       ) for feature in input_values]

           if return_tensors is not None:
                 __A		 =   padded_inputs.convert_to_tensors(lowercase__       )

           return padded_inputs


