

import collections
import inspect
import unittest

from transformers import FocalNetConfig
from transformers.testing_utils import 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 (
		    FocalNetBackbone,
		    FocalNetForImageClassification,
		    FocalNetForMaskedImageModeling,
		    FocalNetModel,
		)
		from transformers.models.focalnet.modeling_focalnet import FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
		from PIL import Image

		from transformers import AutoImageProcessor


class SCREAMING_SNAKE_CASE	:






			"""simple docstring"""




			def __init__(     self			,					__UpperCamelCase			,					__UpperCamelCase=13			,					__UpperCamelCase=32			,					__UpperCamelCase=2			,					__UpperCamelCase=3			,					__UpperCamelCase=16			,					__UpperCamelCase=[32, 64, 1_28]			,					__UpperCamelCase=[1, 2, 1]			,					__UpperCamelCase=[2, 2, 4]			,					__UpperCamelCase=2			,					__UpperCamelCase=2.0			,					__UpperCamelCase=True			,					__UpperCamelCase=0.0			,					__UpperCamelCase=0.0			,					__UpperCamelCase=0.1			,					__UpperCamelCase="gelu"			,					__UpperCamelCase=False			,					__UpperCamelCase=True			,					__UpperCamelCase=0.02			,					__UpperCamelCase=1E-5			,					__UpperCamelCase=True			,					__UpperCamelCase=None			,					__UpperCamelCase=True			,					__UpperCamelCase=10			,					__UpperCamelCase=8			,					__UpperCamelCase=["stage1", "stage2"]			,					__UpperCamelCase=[1, 2]			,					):

				"""simple docstring"""


				snake_case_   		=			parent
				snake_case_   		=			batch_size
				snake_case_   		=			image_size
				snake_case_   		=			patch_size
				snake_case_   		=			num_channels
				snake_case_   		=			embed_dim
				snake_case_   		=			hidden_sizes
				snake_case_   		=			depths
				snake_case_   		=			num_heads
				snake_case_   		=			window_size
				snake_case_   		=			mlp_ratio
				snake_case_   		=			qkv_bias
				snake_case_   		=			hidden_dropout_prob
				snake_case_   		=			attention_probs_dropout_prob
				snake_case_   		=			drop_path_rate
				snake_case_   		=			hidden_act
				snake_case_   		=			use_absolute_embeddings
				snake_case_   		=			patch_norm
				snake_case_   		=			layer_norm_eps
				snake_case_   		=			initializer_range
				snake_case_   		=			is_training
				snake_case_   		=			scope
				snake_case_   		=			use_labels
				snake_case_   		=			type_sequence_label_size
				snake_case_   		=			encoder_stride
				snake_case_   		=			out_features
				snake_case_   		=			out_indices


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


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

				snake_case_   		=			None
				if self.use_labels:
					snake_case_   		=			ids_tensor([self.batch_size]			,					self.type_sequence_label_size				)

				snake_case_   		=			self.get_config()

				return config, pixel_values, labels


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				return FocalNetConfig(
				    image_size=self.image_size			,					patch_size=self.patch_size			,					num_channels=self.num_channels			,					embed_dim=self.embed_dim			,					hidden_sizes=self.hidden_sizes			,					depths=self.depths			,					num_heads=self.num_heads			,					window_size=self.window_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			,					use_absolute_embeddings=self.use_absolute_embeddings			,					path_norm=self.patch_norm			,					layer_norm_eps=self.layer_norm_eps			,					initializer_range=self.initializer_range			,					encoder_stride=self.encoder_stride			,					out_features=self.out_features			,					out_indices=self.out_indices			,					)


			def       __lowerCAmelCase			(     self			,					__UpperCamelCase			,					__UpperCamelCase			,					__UpperCamelCase				):

				"""simple docstring"""


				snake_case_   		=			FocalNetModel(config=__UpperCamelCase				)
				model.to(__UpperCamelCase				)
				model.eval()
				snake_case_   		=			model(__UpperCamelCase				)

				snake_case_   		=			((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths				) - 1))
				snake_case_   		=			int(config.embed_dim * 2 ** (len(config.depths				) - 1)				)

				self.parent.assertEqual(result.last_hidden_state.shape			,					(self.batch_size, expected_seq_len, expected_dim)				)


			def       __lowerCAmelCase			(     self			,					__UpperCamelCase			,					__UpperCamelCase			,					__UpperCamelCase				):

				"""simple docstring"""


				snake_case_   		=			FocalNetBackbone(config=__UpperCamelCase				)
				model.to(__UpperCamelCase				)
				model.eval()
				snake_case_   		=			model(__UpperCamelCase				)

				# verify feature maps
				self.parent.assertEqual(len(result.feature_maps				)			,					len(config.out_features				)				)
				self.parent.assertListEqual(list(result.feature_maps[0].shape				)			,					[self.batch_size, self.image_size, 8, 8]				)

				# verify channels
				self.parent.assertEqual(len(model.channels				)			,					len(config.out_features				)				)
				self.parent.assertListEqual(model.channels			,					config.hidden_sizes[:-1]				)

				# verify backbone works with out_features=None
				snake_case_   		=			None
				snake_case_   		=			FocalNetBackbone(config=__UpperCamelCase				)
				model.to(__UpperCamelCase				)
				model.eval()
				snake_case_   		=			model(__UpperCamelCase				)

				# verify feature maps
				self.parent.assertEqual(len(result.feature_maps				)			,					1				)
				self.parent.assertListEqual(list(result.feature_maps[0].shape				)			,					[self.batch_size, self.image_size * 2, 4, 4]				)

				# verify channels
				self.parent.assertEqual(len(model.channels				)			,					1				)
				self.parent.assertListEqual(model.channels			,					[config.hidden_sizes[-1]]				)


			def       __lowerCAmelCase			(     self			,					__UpperCamelCase			,					__UpperCamelCase			,					__UpperCamelCase				):

				"""simple docstring"""


				snake_case_   		=			FocalNetForMaskedImageModeling(config=__UpperCamelCase				)
				model.to(__UpperCamelCase				)
				model.eval()
				snake_case_   		=			model(__UpperCamelCase				)
				self.parent.assertEqual(
				    result.reconstruction.shape			,					(self.batch_size, self.num_channels, self.image_size, self.image_size)				)

				# test greyscale images
				snake_case_   		=			1
				snake_case_   		=			FocalNetForMaskedImageModeling(__UpperCamelCase				)
				model.to(__UpperCamelCase				)
				model.eval()

				snake_case_   		=			floats_tensor([self.batch_size, 1, self.image_size, self.image_size]				)
				snake_case_   		=			model(__UpperCamelCase				)
				self.parent.assertEqual(result.reconstruction.shape			,					(self.batch_size, 1, self.image_size, self.image_size)				)


			def       __lowerCAmelCase			(     self			,					__UpperCamelCase			,					__UpperCamelCase			,					__UpperCamelCase				):

				"""simple docstring"""


				snake_case_   		=			self.type_sequence_label_size
				snake_case_   		=			FocalNetForImageClassification(__UpperCamelCase				)
				model.to(__UpperCamelCase				)
				model.eval()
				snake_case_   		=			model(__UpperCamelCase			,					labels=__UpperCamelCase				)
				self.parent.assertEqual(result.logits.shape			,					(self.batch_size, self.type_sequence_label_size)				)

				# test greyscale images
				snake_case_   		=			1
				snake_case_   		=			FocalNetForImageClassification(__UpperCamelCase				)
				model.to(__UpperCamelCase				)
				model.eval()

				snake_case_   		=			floats_tensor([self.batch_size, 1, self.image_size, self.image_size]				)
				snake_case_   		=			model(__UpperCamelCase				)
				self.parent.assertEqual(result.logits.shape			,					(self.batch_size, self.type_sequence_label_size)				)







			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_   		=			self.prepare_config_and_inputs()

				snake_case_		,							snake_case_		,							snake_case_   		=			config_and_inputs
				snake_case_   		=			{'pixel_values': pixel_values}
				return config, inputs_dict







@require_torch
class SCREAMING_SNAKE_CASE	(		__snake_case				,    __snake_case				,    unittest.TestCase				):






			"""simple docstring"""




			__A    	=	(
			    (
			        FocalNetModel,
			        FocalNetForImageClassification,
			        FocalNetForMaskedImageModeling,
			        FocalNetBackbone,
			    )
			    if is_torch_available()
			    else ()
			)
			__A    	=	(
			    {"""feature-extraction""": FocalNetModel, """image-classification""": FocalNetForImageClassification}
			    if is_torch_available()
			    else {}
			)
			__A    	=	False

			__A    	=	False
			__A    	=	False
			__A    	=	False
			__A    	=	False


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_   		=			FocalNetModelTester(self				)
				snake_case_   		=			ConfigTester(self			,					config_class=__UpperCamelCase			,					embed_dim=37			,					has_text_modality=__UpperCamelCase				)


			def       __lowerCAmelCase			(     self				):

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

				"""simple docstring"""


				return


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_   		=			self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*__UpperCamelCase				)


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_   		=			self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_backbone(*__UpperCamelCase				)


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_   		=			self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_masked_image_modeling(*__UpperCamelCase				)


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_   		=			self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_image_classification(*__UpperCamelCase				)


			@unittest.skip(reason='FocalNet does not use inputs_embeds'				)
			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				pass


			@unittest.skip(reason='FocalNet does not use feedforward chunking'				)
			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				pass


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_		,							snake_case_   		=			self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes[:-1]:
					snake_case_   		=			model_class(__UpperCamelCase				)
					self.assertIsInstance(model.get_input_embeddings()			,					(nn.Module)				)
					snake_case_   		=			model.get_output_embeddings()
					self.assertTrue(x is None or isinstance(__UpperCamelCase			,					nn.Linear				)				)


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_		,							snake_case_   		=			self.model_tester.prepare_config_and_inputs_for_common()

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

					snake_case_   		=			['pixel_values']
					self.assertListEqual(arg_names[:1]			,					__UpperCamelCase				)


			def       __lowerCAmelCase			(     self			,					__UpperCamelCase			,					__UpperCamelCase			,					__UpperCamelCase			,					__UpperCamelCase				):

				"""simple docstring"""


				snake_case_   		=			model_class(__UpperCamelCase				)
				model.to(__UpperCamelCase				)
				model.eval()

				with torch.no_grad():
					snake_case_   		=			model(**self._prepare_for_class(__UpperCamelCase			,					__UpperCamelCase				)				)

				snake_case_   		=			outputs.hidden_states

				snake_case_   		=			getattr(
				    self.model_tester			,					'expected_num_hidden_layers'			,					len(self.model_tester.depths				) + 1				)
				self.assertEqual(len(__UpperCamelCase				)			,					__UpperCamelCase				)

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

				snake_case_   		=			(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

				self.assertListEqual(
				    list(hidden_states[0].shape[-2:]				)			,					[num_patches, self.model_tester.embed_dim]			,					)

				snake_case_   		=			outputs.reshaped_hidden_states
				self.assertEqual(len(__UpperCamelCase				)			,					__UpperCamelCase				)

				snake_case_		,							snake_case_		,							snake_case_		,							snake_case_   		=			reshaped_hidden_states[0].shape
				snake_case_   		=			(
				    reshaped_hidden_states[0].view(__UpperCamelCase			,					__UpperCamelCase			,					height * width				).permute(0			,					2			,					1				)
				)
				self.assertListEqual(
				    list(reshaped_hidden_states.shape[-2:]				)			,					[num_patches, self.model_tester.embed_dim]			,					)


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_		,							snake_case_   		=			self.model_tester.prepare_config_and_inputs_for_common()

				snake_case_   		=			(
				    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[:-1]:
					snake_case_   		=			True
					self.check_hidden_states_output(__UpperCamelCase			,					__UpperCamelCase			,					__UpperCamelCase			,					__UpperCamelCase				)

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

					self.check_hidden_states_output(__UpperCamelCase			,					__UpperCamelCase			,					__UpperCamelCase			,					__UpperCamelCase				)


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_		,							snake_case_   		=			self.model_tester.prepare_config_and_inputs_for_common()
				snake_case_   		=			3

				snake_case_   		=			(
				    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)
				)
				snake_case_   		=			(
				    config.patch_size
				    if isinstance(config.patch_size			,					collections.abc.Iterable				)
				    else (config.patch_size, config.patch_size)
				)

				snake_case_   		=			image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
				snake_case_   		=			image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

				for model_class in self.all_model_classes[:-1]:
					snake_case_   		=			True
					self.check_hidden_states_output(__UpperCamelCase			,					__UpperCamelCase			,					__UpperCamelCase			,					(padded_height, padded_width)				)

					# check that output_hidden_states also work using config
					del inputs_dict["output_hidden_states"]
					snake_case_   		=			True
					self.check_hidden_states_output(__UpperCamelCase			,					__UpperCamelCase			,					__UpperCamelCase			,					(padded_height, padded_width)				)


			@slow
			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				for model_name in FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					snake_case_   		=			FocalNetModel.from_pretrained(__UpperCamelCase				)
					self.assertIsNotNone(__UpperCamelCase				)







			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_		,							snake_case_   		=			self.model_tester.prepare_config_and_inputs_for_common()

				snake_case_   		=			_config_zero_init(__UpperCamelCase				)
				for model_class in self.all_model_classes:
					snake_case_   		=			model_class(config=__UpperCamelCase				)
					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_vision
@require_torch
class SCREAMING_SNAKE_CASE	(		unittest.TestCase				):






			"""simple docstring"""




			@cached_property
			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				return AutoImageProcessor.from_pretrained('microsoft/focalnet-tiny'				) if is_vision_available() else None







			@slow
			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_   		=			FocalNetForImageClassification.from_pretrained('microsoft/focalnet-tiny'				).to(__UpperCamelCase				)
				snake_case_   		=			self.default_image_processor

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

				# forward pass
				with torch.no_grad():
					snake_case_   		=			model(**__UpperCamelCase				)

				# verify the logits
				snake_case_   		=			torch.Size((1, 10_00)				)
				self.assertEqual(outputs.logits.shape			,					__UpperCamelCase				)
				snake_case_   		=			torch.tensor([0.2166, -0.4368, 0.2191]				).to(__UpperCamelCase				)
				self.assertTrue(torch.allclose(outputs.logits[0, :3]			,					__UpperCamelCase			,					atol=1E-4				)				)
				self.assertTrue(outputs.logits.argmax(dim=-1				).item()			,					2_81				)







@require_torch
class SCREAMING_SNAKE_CASE	(		__snake_case				,    unittest.TestCase				):






			"""simple docstring"""




			__A    	=	(FocalNetBackbone,) if is_torch_available() else ()
			__A    	=	FocalNetConfig

			__A    	=	False


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_   		=			FocalNetModelTester(self				)



import inspect
import unittest

from huggingface_hub import hf_hub_download

from transformers import ASTConfig
from transformers.testing_utils import require_torch, require_torchaudio, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_torchaudio_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
		import torch
		from torch import nn

		from transformers import ASTForAudioClassification, ASTModel
		from transformers.models.audio_spectrogram_transformer.modeling_audio_spectrogram_transformer import (
		    AUDIO_SPECTROGRAM_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
		)


if is_torchaudio_available():
		import torchaudio

		from transformers import ASTFeatureExtractor


class SCREAMING_SNAKE_CASE	:






			"""simple docstring"""




			def __init__(     self			,					__UpperCamelCase			,					__UpperCamelCase=13			,					__UpperCamelCase=2			,					__UpperCamelCase=24			,					__UpperCamelCase=16			,					__UpperCamelCase=True			,					__UpperCamelCase=True			,					__UpperCamelCase=32			,					__UpperCamelCase=5			,					__UpperCamelCase=4			,					__UpperCamelCase=37			,					__UpperCamelCase="gelu"			,					__UpperCamelCase=0.1			,					__UpperCamelCase=0.1			,					__UpperCamelCase=10			,					__UpperCamelCase=0.02			,					__UpperCamelCase=None			,					__UpperCamelCase=2			,					__UpperCamelCase=2			,					):

				"""simple docstring"""


				snake_case_   		=			parent
				snake_case_   		=			batch_size
				snake_case_   		=			patch_size
				snake_case_   		=			max_length
				snake_case_   		=			num_mel_bins
				snake_case_   		=			is_training
				snake_case_   		=			use_labels
				snake_case_   		=			hidden_size
				snake_case_   		=			num_hidden_layers
				snake_case_   		=			num_attention_heads
				snake_case_   		=			intermediate_size
				snake_case_   		=			hidden_act
				snake_case_   		=			hidden_dropout_prob
				snake_case_   		=			attention_probs_dropout_prob
				snake_case_   		=			type_sequence_label_size
				snake_case_   		=			initializer_range
				snake_case_   		=			scope
				snake_case_   		=			frequency_stride
				snake_case_   		=			time_stride

				# in AST, the seq length equals the number of patches + 2 (we add 2 for the [CLS] and distillation tokens)
				snake_case_   		=			(self.num_mel_bins - self.patch_size) // self.frequency_stride + 1
				snake_case_   		=			(self.max_length - self.patch_size) // self.time_stride + 1
				snake_case_   		=			frequency_out_dimension * time_out_dimension
				snake_case_   		=			num_patches + 2


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_   		=			floats_tensor([self.batch_size, self.max_length, self.num_mel_bins]				)

				snake_case_   		=			None
				if self.use_labels:
					snake_case_   		=			ids_tensor([self.batch_size]			,					self.type_sequence_label_size				)

				snake_case_   		=			self.get_config()

				return config, input_values, labels


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				return ASTConfig(
				    patch_size=self.patch_size			,					max_length=self.max_length			,					num_mel_bins=self.num_mel_bins			,					hidden_size=self.hidden_size			,					num_hidden_layers=self.num_hidden_layers			,					num_attention_heads=self.num_attention_heads			,					intermediate_size=self.intermediate_size			,					hidden_act=self.hidden_act			,					hidden_dropout_prob=self.hidden_dropout_prob			,					attention_probs_dropout_prob=self.attention_probs_dropout_prob			,					is_decoder=__UpperCamelCase			,					initializer_range=self.initializer_range			,					frequency_stride=self.frequency_stride			,					time_stride=self.time_stride			,					)


			def       __lowerCAmelCase			(     self			,					__UpperCamelCase			,					__UpperCamelCase			,					__UpperCamelCase				):

				"""simple docstring"""


				snake_case_   		=			ASTModel(config=__UpperCamelCase				)
				model.to(__UpperCamelCase				)
				model.eval()
				snake_case_   		=			model(__UpperCamelCase				)
				self.parent.assertEqual(result.last_hidden_state.shape			,					(self.batch_size, self.seq_length, self.hidden_size)				)







			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_   		=			self.prepare_config_and_inputs()
				(
				    (
				    snake_case_
				)		,							(
				    snake_case_
				)		,							(
				    snake_case_
				)		,							
				)   		=			config_and_inputs
				snake_case_   		=			{'input_values': input_values}
				return config, inputs_dict







@require_torch
class SCREAMING_SNAKE_CASE	(		__snake_case				,    __snake_case				,    unittest.TestCase				):






			"""simple docstring"""




			__A    	=	(
			    (
			        ASTModel,
			        ASTForAudioClassification,
			    )
			    if is_torch_available()
			    else ()
			)
			__A    	=	(
			    {"""audio-classification""": ASTForAudioClassification, """feature-extraction""": ASTModel}
			    if is_torch_available()
			    else {}
			)
			__A    	=	False
			__A    	=	False
			__A    	=	False
			__A    	=	False


			def       __lowerCAmelCase			(     self			,					__UpperCamelCase			,					__UpperCamelCase			,					__UpperCamelCase			,					__UpperCamelCase			,					__UpperCamelCase				):

				"""simple docstring"""


				if pipeline_test_casse_name == "AudioClassificationPipelineTests":
					return True

				return False


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_   		=			ASTModelTester(self				)
				snake_case_   		=			ConfigTester(self			,					config_class=__UpperCamelCase			,					has_text_modality=__UpperCamelCase			,					hidden_size=37				)


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				self.config_tester.run_common_tests()


			@unittest.skip(reason='AST does not use inputs_embeds'				)
			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				pass


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_		,							snake_case_   		=			self.model_tester.prepare_config_and_inputs_for_common()

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


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_		,							snake_case_   		=			self.model_tester.prepare_config_and_inputs_for_common()

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

					snake_case_   		=			['input_values']
					self.assertListEqual(arg_names[:1]			,					__UpperCamelCase				)


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_   		=			self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*__UpperCamelCase				)







			@slow
			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				for model_name in AUDIO_SPECTROGRAM_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					snake_case_   		=			ASTModel.from_pretrained(__UpperCamelCase				)
					self.assertIsNotNone(__UpperCamelCase				)







def a():





	'''simple docstring'''
	snake_case_   		=			hf_hub_download(
	    repo_id='nielsr/audio-spectogram-transformer-checkpoint'      ,			filename='sample_audio.flac'      ,			repo_type='dataset'						)

	snake_case_		,							snake_case_   		=			torchaudio.load(lowercase__						)

	return audio, sampling_rate






@require_torch
@require_torchaudio
class SCREAMING_SNAKE_CASE	(		unittest.TestCase				):






			"""simple docstring"""




			@cached_property
			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				return (
				    ASTFeatureExtractor.from_pretrained('MIT/ast-finetuned-audioset-10-10-0.4593'				)
				    if is_torchaudio_available()
				    else None
				)







			@slow
			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_   		=			self.default_feature_extractor
				snake_case_   		=			ASTForAudioClassification.from_pretrained('MIT/ast-finetuned-audioset-10-10-0.4593'				).to(__UpperCamelCase				)

				snake_case_   		=			self.default_feature_extractor
				snake_case_		,							snake_case_   		=			prepare_audio()
				snake_case_   		=			audio.squeeze().numpy()
				snake_case_   		=			feature_extractor(__UpperCamelCase			,					sampling_rate=__UpperCamelCase			,					return_tensors='pt'				).to(__UpperCamelCase				)

				# forward pass
				with torch.no_grad():
					snake_case_   		=			model(**__UpperCamelCase				)

				# verify the logits
				snake_case_   		=			torch.Size((1, 5_27)				)
				self.assertEqual(outputs.logits.shape			,					__UpperCamelCase				)

				snake_case_   		=			torch.tensor([-0.8760, -7.0042, -8.6602]				).to(__UpperCamelCase				)

				self.assertTrue(torch.allclose(outputs.logits[0, :3]			,					__UpperCamelCase			,					atol=1E-4				)				)
