




'''simple docstring'''




import json
import os
import shutil
import tempfile
import unittest

from transformers import is_speech_available, is_torch_available
from transformers.models.speechta import SpeechTaTokenizer
from transformers.testing_utils import get_tests_dir, require_torch
from transformers.utils import FEATURE_EXTRACTOR_NAME


if is_speech_available() and is_torch_available():
							from transformers import SpeechTaFeatureExtractor, SpeechTaProcessor

							from .test_feature_extraction_speechta import floats_list


snake_case__          =						get_tests_dir("""fixtures/test_sentencepiece_bpe_char.model""")






@require_torch
class     UpperCamelCase_     (unittest.TestCase     ):







						"""simple docstring"""


						def       _a    (     self      :       Any    ):





											"""simple docstring"""







											A_ :     Optional[int] =							tempfile.mkdtemp()

											A_ :     Optional[int] =							SpeechTaTokenizer(_lowerCamelCase    )
											tokenizer.save_pretrained(self.tmpdirname    )

											A_ :     Dict =							{
											    '''feature_size''': 1,
											    '''padding_value''': 0.0,
											    '''sampling_rate''': 16000,
											    '''do_normalize''': False,
											    '''num_mel_bins''': 80,
											    '''hop_length''': 16,
											    '''win_length''': 64,
											    '''win_function''': '''hann_window''',
											    '''fmin''': 80,
											    '''fmax''': 7600,
											    '''mel_floor''': 1E-10,
											    '''reduction_factor''': 2,
											    '''return_attention_mask''': True,
											}

											A_ :     List[Any] =							os.path.join(self.tmpdirname							, _lowerCamelCase    )
											with open(self.feature_extraction_file							, '''w'''							, encoding='''utf-8'''    ) as fp:
																fp.write(json.dumps(_lowerCamelCase    ) + '''\n'''    )







						def       _a    (     self      :       List[str]							, **_lowerCamelCase      :       Optional[int]    ):





											"""simple docstring"""







											return SpeechTaTokenizer.from_pretrained(self.tmpdirname							, **_lowerCamelCase    )







						def       _a    (     self      :       int							, **_lowerCamelCase      :       int    ):





											"""simple docstring"""







											return SpeechTaFeatureExtractor.from_pretrained(self.tmpdirname							, **_lowerCamelCase    )







						def       _a    (     self      :       Optional[Any]    ):





											"""simple docstring"""







											shutil.rmtree(self.tmpdirname    )







						def       _a    (     self      :       int    ):





											"""simple docstring"""







											A_ :     Union[str, Any] =							self.get_tokenizer()
											A_ :     str =							self.get_feature_extractor()

											A_ :     List[Any] =							SpeechTaProcessor(tokenizer=_lowerCamelCase							, feature_extractor=_lowerCamelCase    )

											processor.save_pretrained(self.tmpdirname    )
											A_ :     Optional[int] =							SpeechTaProcessor.from_pretrained(self.tmpdirname    )

											self.assertEqual(processor.tokenizer.get_vocab()							, tokenizer.get_vocab()    )
											self.assertIsInstance(processor.tokenizer							, _lowerCamelCase    )

											self.assertEqual(processor.feature_extractor.to_json_string()							, feature_extractor.to_json_string()    )
											self.assertIsInstance(processor.feature_extractor							, _lowerCamelCase    )







						def       _a    (     self      :       Dict    ):





											"""simple docstring"""







											A_ :     Optional[int] =							SpeechTaProcessor(tokenizer=self.get_tokenizer()							, feature_extractor=self.get_feature_extractor()    )
											processor.save_pretrained(self.tmpdirname    )

											A_ :     Dict =							self.get_tokenizer(bos_token='''(BOS)'''							, eos_token='''(EOS)'''    )
											A_ :     int =							self.get_feature_extractor(do_normalize=_lowerCamelCase							, padding_value=1.0    )

											A_ :     Optional[Any] =							SpeechTaProcessor.from_pretrained(
											    self.tmpdirname							, bos_token='''(BOS)'''							, eos_token='''(EOS)'''							, do_normalize=_lowerCamelCase							, padding_value=1.0    )

											self.assertEqual(processor.tokenizer.get_vocab()							, tokenizer_add_kwargs.get_vocab()    )
											self.assertIsInstance(processor.tokenizer							, _lowerCamelCase    )

											self.assertEqual(processor.feature_extractor.to_json_string()							, feature_extractor_add_kwargs.to_json_string()    )
											self.assertIsInstance(processor.feature_extractor							, _lowerCamelCase    )







						def       _a    (     self      :       int    ):





											"""simple docstring"""







											A_ :     str =							self.get_feature_extractor()
											A_ :     Any =							self.get_tokenizer()

											A_ :     Tuple =							SpeechTaProcessor(tokenizer=_lowerCamelCase							, feature_extractor=_lowerCamelCase    )

											A_ :     int =							floats_list((3, 1000)    )

											A_ :     str =							feature_extractor(audio=_lowerCamelCase							, return_tensors='''np'''    )
											A_ :     Dict =							processor(audio=_lowerCamelCase							, return_tensors='''np'''    )

											for key in input_feat_extract.keys():
																self.assertAlmostEqual(input_feat_extract[key].sum()							, input_processor[key].sum()							, delta=1E-2    )







						def       _a    (     self      :       str    ):





											"""simple docstring"""







											A_ :     Tuple =							self.get_feature_extractor()
											A_ :     Optional[int] =							self.get_tokenizer()

											A_ :     Dict =							SpeechTaProcessor(tokenizer=_lowerCamelCase							, feature_extractor=_lowerCamelCase    )

											A_ :     Union[str, Any] =							floats_list((3, 1000)    )

											A_ :     str =							feature_extractor(audio_target=_lowerCamelCase							, return_tensors='''np'''    )
											A_ :     Tuple =							processor(audio_target=_lowerCamelCase							, return_tensors='''np'''    )

											for key in input_feat_extract.keys():
																self.assertAlmostEqual(input_feat_extract[key].sum()							, input_processor[key].sum()							, delta=1E-2    )







						def       _a    (     self      :       Optional[int]    ):





											"""simple docstring"""







											A_ :     int =							self.get_feature_extractor()
											A_ :     Union[str, Any] =							self.get_tokenizer()

											A_ :     Tuple =							SpeechTaProcessor(tokenizer=_lowerCamelCase							, feature_extractor=_lowerCamelCase    )

											A_ :     int =							'''This is a test string'''

											A_ :     List[str] =							processor(text=_lowerCamelCase    )
											A_ :     Optional[int] =							tokenizer(_lowerCamelCase    )

											for key in encoded_tok.keys():
																self.assertListEqual(encoded_tok[key]							, encoded_processor[key]    )







						def       _a    (     self      :       int    ):





											"""simple docstring"""







											A_ :     Optional[Any] =							self.get_feature_extractor()
											A_ :     List[Any] =							self.get_tokenizer()

											A_ :     Union[str, Any] =							SpeechTaProcessor(tokenizer=_lowerCamelCase							, feature_extractor=_lowerCamelCase    )

											A_ :     str =							'''This is a test string'''

											A_ :     str =							processor(text_target=_lowerCamelCase    )
											A_ :     Union[str, Any] =							tokenizer(_lowerCamelCase    )

											for key in encoded_tok.keys():
																self.assertListEqual(encoded_tok[key]							, encoded_processor[key]    )







						def       _a    (     self      :       List[Any]    ):





											"""simple docstring"""







											A_ :     Dict =							self.get_feature_extractor()
											A_ :     Dict =							self.get_tokenizer()

											A_ :     List[Any] =							SpeechTaProcessor(tokenizer=_lowerCamelCase							, feature_extractor=_lowerCamelCase    )

											A_ :     str =							[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

											A_ :     str =							processor.batch_decode(_lowerCamelCase    )
											A_ :     Tuple =							tokenizer.batch_decode(_lowerCamelCase    )

											self.assertListEqual(_lowerCamelCase							, _lowerCamelCase    )







						def       _a    (     self      :       Union[str, Any]    ):





											"""simple docstring"""







											A_ :     Optional[Any] =							self.get_feature_extractor()
											A_ :     Tuple =							self.get_tokenizer()

											A_ :     Dict =							SpeechTaProcessor(tokenizer=_lowerCamelCase							, feature_extractor=_lowerCamelCase    )

											self.assertListEqual(
											    processor.model_input_names							, feature_extractor.model_input_names							, msg='''`processor` and `feature_extractor` model input names do not match'''							, )









'''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     UpperCamelCase_     :







						"""simple docstring"""


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





											"""simple docstring"""







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







						def       _a    (     self      :       Dict    ):





											"""simple docstring"""







											A_ :     Dict =							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )

											A_ :     int =							None
											if self.use_labels:
																A_ :     Union[str, Any] =							ids_tensor([self.batch_size]							, self.num_labels    )

											A_ :     int =							self.get_config()

											return config, pixel_values, labels







						def       _a    (     self      :       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       _a    (     self      :       int							, _lowerCamelCase      :       str							, _lowerCamelCase      :       Dict							, _lowerCamelCase      :       Dict    ):





											"""simple docstring"""







											A_ :     str =							NatModel(config=_lowerCamelCase    )
											model.to(_lowerCamelCase    )
											model.eval()
											A_ :     Union[str, Any] =							model(_lowerCamelCase    )

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





											"""simple docstring"""







											A_ :     int =							NatForImageClassification(_lowerCamelCase    )
											model.to(_lowerCamelCase    )
											model.eval()
											A_ :     str =							model(_lowerCamelCase							, labels=_lowerCamelCase    )
											self.parent.assertEqual(result.logits.shape							, (self.batch_size, self.num_labels)    )

											# test greyscale images
											A_ :     str =							1
											A_ :     Dict =							NatForImageClassification(_lowerCamelCase    )
											model.to(_lowerCamelCase    )
											model.eval()

											A_ :     str =							floats_tensor([self.batch_size, 1, self.image_size, self.image_size]    )
											A_ :     Tuple =							model(_lowerCamelCase    )
											self.parent.assertEqual(result.logits.shape							, (self.batch_size, self.num_labels)    )







						def       _a    (     self      :       List[Any]							, _lowerCamelCase      :       List[str]							, _lowerCamelCase      :       Any							, _lowerCamelCase      :       Tuple    ):





											"""simple docstring"""







											A_ :     Union[str, Any] =							NatBackbone(config=_lowerCamelCase    )
											model.to(_lowerCamelCase    )
											model.eval()
											A_ :     Optional[int] =							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
											A_ :     Tuple =							None
											A_ :     List[Any] =							NatBackbone(config=_lowerCamelCase    )
											model.to(_lowerCamelCase    )
											model.eval()
											A_ :     Optional[int] =							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       _a    (     self      :       List[Any]    ):





											"""simple docstring"""







											A_ :     Optional[int] =							self.prepare_config_and_inputs()
											A_ ,A_ ,A_ :     Any =							config_and_inputs
											A_ :     Union[str, Any] =							{'''pixel_values''': pixel_values}
											return config, inputs_dict






@require_natten
@require_torch
class     UpperCamelCase_     (a__,      a__,      unittest.TestCase     ):







						"""simple docstring"""


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

						_lowerCAmelCase    						=					False
						_lowerCAmelCase    						=					False
						_lowerCAmelCase    						=					False
						_lowerCAmelCase    						=					False







						def       _a    (     self      :       Any    ):





											"""simple docstring"""







											A_ :     Tuple =							NatModelTester(self    )
											A_ :     Any =							ConfigTester(self							, config_class=_lowerCamelCase							, embed_dim=37    )







						def       _a    (     self      :       Union[str, Any]    ):





											"""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       _a    (     self      :       str    ):





											"""simple docstring"""







											return







						def       _a    (     self      :       Union[str, Any]    ):





											"""simple docstring"""







											A_ :     Union[str, Any] =							self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*_lowerCamelCase    )







						def       _a    (     self      :       Optional[int]    ):





											"""simple docstring"""







											A_ :     Dict =							self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_image_classification(*_lowerCamelCase    )







						def       _a    (     self      :       str    ):





											"""simple docstring"""







											A_ :     str =							self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_backbone(*_lowerCamelCase    )







						@unittest.skip(reason='''Nat does not use inputs_embeds'''    )
						def       _a    (     self      :       str    ):





											"""simple docstring"""







											pass







						@unittest.skip(reason='''Nat does not use feedforward chunking'''    )
						def       _a    (     self      :       Optional[Any]    ):





											"""simple docstring"""







											pass







						def       _a    (     self      :       Dict    ):





											"""simple docstring"""







											A_ ,A_ :     List[Any] =							self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																A_ :     List[str] =							model_class(_lowerCamelCase    )
																self.assertIsInstance(model.get_input_embeddings()							, (nn.Module)    )
																A_ :     str =							model.get_output_embeddings()
																self.assertTrue(x is None or isinstance(_lowerCamelCase							, nn.Linear    )    )







						def       _a    (     self      :       Union[str, Any]    ):





											"""simple docstring"""







											A_ ,A_ :     Tuple =							self.model_tester.prepare_config_and_inputs_for_common()

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

																A_ :     List[Any] =							['''pixel_values''']
																self.assertListEqual(arg_names[:1]							, _lowerCamelCase    )







						def       _a    (     self      :       Optional[int]    ):





											"""simple docstring"""







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







						def       _a    (     self      :       List[Any]							, _lowerCamelCase      :       Optional[int]							, _lowerCamelCase      :       Union[str, Any]							, _lowerCamelCase      :       Tuple							, _lowerCamelCase      :       List[str]    ):





											"""simple docstring"""







											A_ :     Tuple =							model_class(_lowerCamelCase    )
											model.to(_lowerCamelCase    )
											model.eval()

											with torch.no_grad():
																A_ :     List[str] =							model(**self._prepare_for_class(_lowerCamelCase							, _lowerCamelCase    )    )

											A_ :     List[Any] =							outputs.hidden_states

											A_ :     List[str] =							getattr(
											    self.model_tester							, '''expected_num_hidden_layers'''							, len(self.model_tester.depths    ) + 1    )
											self.assertEqual(len(_lowerCamelCase    )							, _lowerCamelCase    )

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

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

																A_ ,A_ ,A_ ,A_ :     Union[str, Any] =							reshaped_hidden_states[0].shape
																A_ :     Optional[Any] =							(
																    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       _a    (     self      :       str    ):





											"""simple docstring"""







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

											A_ :     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:
																A_ :     Tuple =							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"]
																A_ :     Dict =							True

																self.check_hidden_states_output(_lowerCamelCase							, _lowerCamelCase							, _lowerCamelCase							, _lowerCamelCase    )







						@slow
						def       _a    (     self      :       Tuple    ):





											"""simple docstring"""







											for model_name in NAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																A_ :     int =							NatModel.from_pretrained(_lowerCamelCase    )
																self.assertIsNotNone(_lowerCamelCase    )







						def       _a    (     self      :       List[str]    ):





											"""simple docstring"""







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

											A_ :     Tuple =							_config_zero_init(_lowerCamelCase    )
											for model_class in self.all_model_classes:
																A_ :     Union[str, 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     UpperCamelCase_     (unittest.TestCase     ):







						"""simple docstring"""


						@cached_property
						def       _a    (     self      :       List[str]    ):





											"""simple docstring"""







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







						@slow
						def       _a    (     self      :       Optional[Any]    ):





											"""simple docstring"""







											A_ :     Optional[Any] =							NatForImageClassification.from_pretrained('''shi-labs/nat-mini-in1k-224'''    ).to(_lowerCamelCase    )
											A_ :     List[Any] =							self.default_image_processor

											A_ :     Dict =							Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''    )
											A_ :     str =							image_processor(images=_lowerCamelCase							, return_tensors='''pt'''    ).to(_lowerCamelCase    )

											# forward pass
											with torch.no_grad():
																A_ :     Union[str, Any] =							model(**_lowerCamelCase    )

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






@require_torch
@require_natten
class     UpperCamelCase_     (unittest.TestCase,      a__     ):







						"""simple docstring"""


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







						def       _a    (     self      :       Optional[Any]    ):





											"""simple docstring"""







											A_ :     Union[str, Any] =							NatModelTester(self    )



