






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 				__UpperCAmelCase		:







			def __init__(     self:  Optional[int]				,     UpperCAmelCase_:  int				,     UpperCAmelCase_:  List[str]=13				,     UpperCAmelCase_:  Dict=2				,     UpperCAmelCase_:  Any=24				,     UpperCAmelCase_:  Dict=16				,     UpperCAmelCase_:  Any=True				,     UpperCAmelCase_:  int=True				,     UpperCAmelCase_:  str=32				,     UpperCAmelCase_:  List[Any]=5				,     UpperCAmelCase_:  Optional[Any]=4				,     UpperCAmelCase_:  List[str]=37				,     UpperCAmelCase_:  List[Any]="gelu"				,     UpperCAmelCase_:  Any=0.1				,     UpperCAmelCase_:  Optional[Any]=0.1				,     UpperCAmelCase_:  str=10				,     UpperCAmelCase_:  int=0.02				,     UpperCAmelCase_:  List[str]=None				,     UpperCAmelCase_:  List[str]=2				,     UpperCAmelCase_:  Optional[Any]=2				,     ):







									'''simple docstring'''




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

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







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







									'''simple docstring'''




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

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

									_SCREAMING_SNAKE_CASE     				=  self.get_config()

									return config, input_values, labels







			def 							UpperCamelCase				(     self:  List[str]					):







									'''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=_lowerCAmelCase				,     initializer_range=self.initializer_range				,     frequency_stride=self.frequency_stride				,     time_stride=self.time_stride				,     )







			def 							UpperCamelCase				(     self:  int				,     UpperCAmelCase_:  List[str]				,     UpperCAmelCase_:  Optional[Any]				,     UpperCAmelCase_:  str					):







									'''simple docstring'''




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







			def 							UpperCamelCase				(     self:  List[str]					):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE     				=  self.prepare_config_and_inputs()
									(
									    (
									    _SCREAMING_SNAKE_CASE			
									)				,					(
									    _SCREAMING_SNAKE_CASE			
									)				,					(
									    _SCREAMING_SNAKE_CASE			
									)				,								
									)     				=  config_and_inputs
									_SCREAMING_SNAKE_CASE     				=  {"""input_values""": input_values}
									return config, inputs_dict



@require_torch
class 				__UpperCAmelCase		(UpperCamelCase_	,UpperCamelCase_	,unittest.TestCase   ):
			__snake_case    :				int									=							(
			    (
			        ASTModel,
			        ASTForAudioClassification,
			    )
			    if is_torch_available()
			    else ()
			)
			__snake_case    :				List[str]									=							(
			    {"audio-classification": ASTForAudioClassification, "feature-extraction": ASTModel}
			    if is_torch_available()
			    else {}
			)
			__snake_case    :				Tuple									=							False
			__snake_case    :				Dict									=							False
			__snake_case    :				str									=							False
			__snake_case    :				List[Any]									=							False







			def 							UpperCamelCase				(     self:  Optional[int]				,     UpperCAmelCase_:  Tuple				,     UpperCAmelCase_:  Dict				,     UpperCAmelCase_:  Tuple				,     UpperCAmelCase_:  Dict				,     UpperCAmelCase_:  Dict					):







									'''simple docstring'''




									if pipeline_test_casse_name == "AudioClassificationPipelineTests":
															return True

									return False







			def 							UpperCamelCase				(     self:  Dict					):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE     				=  ASTModelTester(self					)
									_SCREAMING_SNAKE_CASE     				=  ConfigTester(self				,     config_class=_lowerCAmelCase				,     has_text_modality=_lowerCAmelCase				,     hidden_size=37					)







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







									'''simple docstring'''




									self.config_tester.run_common_tests()







			@unittest.skip(reason="""AST does not use inputs_embeds"""					)
			def 							UpperCamelCase				(     self:  Optional[Any]					):







									'''simple docstring'''




									pass







			def 							UpperCamelCase				(     self:  Dict					):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE				,					_SCREAMING_SNAKE_CASE     				=  self.model_tester.prepare_config_and_inputs_for_common()

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







			def 							UpperCamelCase				(     self:  int					):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE				,					_SCREAMING_SNAKE_CASE     				=  self.model_tester.prepare_config_and_inputs_for_common()

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

															_SCREAMING_SNAKE_CASE     				=  ["""input_values"""]
															self.assertListEqual(arg_names[:1]				,     _lowerCAmelCase					)







			def 							UpperCamelCase				(     self:  Dict					):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE     				=  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*_lowerCAmelCase					)







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







									'''simple docstring'''




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

def 	__lowerCamelCase      (		)							->  Dict:






						"""simple docstring"""





						_SCREAMING_SNAKE_CASE     				=  hf_hub_download(
						    repo_id="""nielsr/audio-spectogram-transformer-checkpoint"""	,filename="""sample_audio.flac"""	,repo_type="""dataset"""		)

						_SCREAMING_SNAKE_CASE				,					_SCREAMING_SNAKE_CASE     				=  torchaudio.load(_lowerCAmelCase		)

						return audio, sampling_rate




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







			@cached_property
			def 							UpperCamelCase				(     self:  Tuple					):







									'''simple docstring'''




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







			@slow
			def 							UpperCamelCase				(     self:  List[Any]					):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE     				=  self.default_feature_extractor
									_SCREAMING_SNAKE_CASE     				=  ASTForAudioClassification.from_pretrained("""MIT/ast-finetuned-audioset-10-10-0.4593"""					).to(_lowerCAmelCase					)

									_SCREAMING_SNAKE_CASE     				=  self.default_feature_extractor
									_SCREAMING_SNAKE_CASE				,					_SCREAMING_SNAKE_CASE     				=  prepare_audio()
									_SCREAMING_SNAKE_CASE     				=  audio.squeeze().numpy()
									_SCREAMING_SNAKE_CASE     				=  feature_extractor(_lowerCAmelCase				,     sampling_rate=_lowerCAmelCase				,     return_tensors="""pt"""					).to(_lowerCAmelCase					)

									# forward pass
									with torch.no_grad():
															_SCREAMING_SNAKE_CASE     				=  model(**_lowerCAmelCase					)

									# verify the logits
									_SCREAMING_SNAKE_CASE     				=  torch.Size((1, 527)					)
									self.assertEqual(outputs.logits.shape				,     _lowerCAmelCase					)

									_SCREAMING_SNAKE_CASE     				=  torch.tensor([-0.87_60, -7.00_42, -8.66_02]					).to(_lowerCAmelCase					)

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









from __future__ import annotations

import unittest

from transformers import EsmConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
		import numpy
		import tensorflow as tf

		from transformers.models.esm.modeling_tf_esm import (
		    TF_ESM_PRETRAINED_MODEL_ARCHIVE_LIST,
		    TFEsmForMaskedLM,
		    TFEsmForSequenceClassification,
		    TFEsmForTokenClassification,
		    TFEsmModel,
		)



class 				__UpperCAmelCase		:







			def __init__(     self:  Tuple				,     UpperCAmelCase_:  Tuple				,     ):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE     				=  parent
									_SCREAMING_SNAKE_CASE     				=  13
									_SCREAMING_SNAKE_CASE     				=  7
									_SCREAMING_SNAKE_CASE     				=  True
									_SCREAMING_SNAKE_CASE     				=  True
									_SCREAMING_SNAKE_CASE     				=  True
									_SCREAMING_SNAKE_CASE     				=  99
									_SCREAMING_SNAKE_CASE     				=  32
									_SCREAMING_SNAKE_CASE     				=  2
									_SCREAMING_SNAKE_CASE     				=  4
									_SCREAMING_SNAKE_CASE     				=  37
									_SCREAMING_SNAKE_CASE     				=  """gelu"""
									_SCREAMING_SNAKE_CASE     				=  0.1
									_SCREAMING_SNAKE_CASE     				=  0.1
									_SCREAMING_SNAKE_CASE     				=  512
									_SCREAMING_SNAKE_CASE     				=  16
									_SCREAMING_SNAKE_CASE     				=  2
									_SCREAMING_SNAKE_CASE     				=  0.02
									_SCREAMING_SNAKE_CASE     				=  3
									_SCREAMING_SNAKE_CASE     				=  4
									_SCREAMING_SNAKE_CASE     				=  None







			def 							UpperCamelCase				(     self:  List[str]					):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE     				=  ids_tensor([self.batch_size, self.seq_length]				,     self.vocab_size					)

									_SCREAMING_SNAKE_CASE     				=  None
									if self.use_input_mask:
															_SCREAMING_SNAKE_CASE     				=  random_attention_mask([self.batch_size, self.seq_length]					)

									_SCREAMING_SNAKE_CASE     				=  None
									_SCREAMING_SNAKE_CASE     				=  None
									_SCREAMING_SNAKE_CASE     				=  None
									if self.use_labels:
															_SCREAMING_SNAKE_CASE     				=  ids_tensor([self.batch_size]				,     self.type_sequence_label_size					)
															_SCREAMING_SNAKE_CASE     				=  ids_tensor([self.batch_size, self.seq_length]				,     self.num_labels					)
															_SCREAMING_SNAKE_CASE     				=  ids_tensor([self.batch_size]				,     self.num_choices					)

									_SCREAMING_SNAKE_CASE     				=  EsmConfig(
									    vocab_size=self.vocab_size				,     hidden_size=self.hidden_size				,     num_hidden_layers=self.num_hidden_layers				,     pad_token_id=1				,     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				,     max_position_embeddings=self.max_position_embeddings				,     type_vocab_size=self.type_vocab_size				,     initializer_range=self.initializer_range				,     )

									return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels







			def 							UpperCamelCase				(     self:  Tuple					):







									'''simple docstring'''




									(
									    (
									    _SCREAMING_SNAKE_CASE
									)				,					(
									    _SCREAMING_SNAKE_CASE
									)				,					(
									    _SCREAMING_SNAKE_CASE
									)				,					(
									    _SCREAMING_SNAKE_CASE
									)				,					(
									    _SCREAMING_SNAKE_CASE
									)				,					(
									    _SCREAMING_SNAKE_CASE
									)				,					
									)     				=  self.prepare_config_and_inputs()

									_SCREAMING_SNAKE_CASE     				=  True
									_SCREAMING_SNAKE_CASE     				=  floats_tensor([self.batch_size, self.seq_length, self.hidden_size]					)
									_SCREAMING_SNAKE_CASE     				=  ids_tensor([self.batch_size, self.seq_length]				,     vocab_size=2					)

									return (
									    config,
									    input_ids,
									    input_mask,
									    sequence_labels,
									    token_labels,
									    choice_labels,
									    encoder_hidden_states,
									    encoder_attention_mask,
									)







			def 							UpperCamelCase				(     self:  int				,     UpperCAmelCase_:  Dict				,     UpperCAmelCase_:  List[Any]				,     UpperCAmelCase_:  Optional[int]				,     UpperCAmelCase_:  Dict				,     UpperCAmelCase_:  Dict				,     UpperCAmelCase_:  Dict					):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE     				=  TFEsmModel(config=UpperCAmelCase_					)
									_SCREAMING_SNAKE_CASE     				=  {"""input_ids""": input_ids, """attention_mask""": input_mask}
									_SCREAMING_SNAKE_CASE     				=  model(UpperCAmelCase_					)

									_SCREAMING_SNAKE_CASE     				=  [input_ids, input_mask]
									_SCREAMING_SNAKE_CASE     				=  model(UpperCAmelCase_					)

									_SCREAMING_SNAKE_CASE     				=  model(UpperCAmelCase_					)

									self.parent.assertEqual(result.last_hidden_state.shape				,     (self.batch_size, self.seq_length, self.hidden_size)					)







			def 							UpperCamelCase				(     self:  Optional[Any]				,     UpperCAmelCase_:  Tuple				,     UpperCAmelCase_:  Dict				,     UpperCAmelCase_:  Union[str, Any]				,     UpperCAmelCase_:  Union[str, Any]				,     UpperCAmelCase_:  Union[str, Any]				,     UpperCAmelCase_:  Tuple				,     UpperCAmelCase_:  Any				,     UpperCAmelCase_:  List[str]				,     ):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE     				=  True

									_SCREAMING_SNAKE_CASE     				=  TFEsmModel(config=UpperCAmelCase_					)
									_SCREAMING_SNAKE_CASE     				=  {
									    """input_ids""": input_ids,
									    """attention_mask""": input_mask,
									    """encoder_hidden_states""": encoder_hidden_states,
									    """encoder_attention_mask""": encoder_attention_mask,
									}
									_SCREAMING_SNAKE_CASE     				=  model(UpperCAmelCase_					)

									_SCREAMING_SNAKE_CASE     				=  [input_ids, input_mask]
									_SCREAMING_SNAKE_CASE     				=  model(UpperCAmelCase_				,     encoder_hidden_states=UpperCAmelCase_					)

									# Also check the case where encoder outputs are not passed
									_SCREAMING_SNAKE_CASE     				=  model(UpperCAmelCase_				,     attention_mask=UpperCAmelCase_					)

									self.parent.assertEqual(result.last_hidden_state.shape				,     (self.batch_size, self.seq_length, self.hidden_size)					)







			def 							UpperCamelCase				(     self:  Dict				,     UpperCAmelCase_:  List[Any]				,     UpperCAmelCase_:  List[Any]				,     UpperCAmelCase_:  Optional[int]				,     UpperCAmelCase_:  List[str]				,     UpperCAmelCase_:  str				,     UpperCAmelCase_:  List[str]					):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE     				=  TFEsmForMaskedLM(config=UpperCAmelCase_					)
									_SCREAMING_SNAKE_CASE     				=  model([input_ids, input_mask]					)
									self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.seq_length, self.vocab_size)					)







			def 							UpperCamelCase				(     self:  List[Any]				,     UpperCAmelCase_:  Tuple				,     UpperCAmelCase_:  str				,     UpperCAmelCase_:  Optional[int]				,     UpperCAmelCase_:  Union[str, Any]				,     UpperCAmelCase_:  int				,     UpperCAmelCase_:  Any					):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE     				=  self.num_labels
									_SCREAMING_SNAKE_CASE     				=  TFEsmForTokenClassification(config=UpperCAmelCase_					)
									_SCREAMING_SNAKE_CASE     				=  {"""input_ids""": input_ids, """attention_mask""": input_mask}
									_SCREAMING_SNAKE_CASE     				=  model(UpperCAmelCase_					)
									self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.seq_length, self.num_labels)					)







			def 							UpperCamelCase				(     self:  Dict					):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE     				=  self.prepare_config_and_inputs()
									(
									    (
									    _SCREAMING_SNAKE_CASE
									)				,					(
									    _SCREAMING_SNAKE_CASE
									)				,					(
									    _SCREAMING_SNAKE_CASE
									)				,					(
									    _SCREAMING_SNAKE_CASE
									)				,					(
									    _SCREAMING_SNAKE_CASE
									)				,					(
									    _SCREAMING_SNAKE_CASE
									)				,					
									)     				=  config_and_inputs
									_SCREAMING_SNAKE_CASE     				=  {"""input_ids""": input_ids, """attention_mask""": input_mask}
									return config, inputs_dict



@require_tf
class 				__UpperCAmelCase		(_UpperCAmelCase	,_UpperCAmelCase	,unittest.TestCase   ):
			__snake_case    :				List[Any]									=							(
			    (
			        TFEsmModel,
			        TFEsmForMaskedLM,
			        TFEsmForSequenceClassification,
			        TFEsmForTokenClassification,
			    )
			    if is_tf_available()
			    else ()
			)
			__snake_case    :				Tuple									=							(
			    {
			        "feature-extraction": TFEsmModel,
			        "fill-mask": TFEsmForMaskedLM,
			        "text-classification": TFEsmForSequenceClassification,
			        "token-classification": TFEsmForTokenClassification,
			        "zero-shot": TFEsmForSequenceClassification,
			    }
			    if is_tf_available()
			    else {}
			)
			__snake_case    :				List[str]									=							False
			__snake_case    :				Union[str, Any]									=							False







			def 							UpperCamelCase				(     self:  Optional[int]					):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE     				=  TFEsmModelTester(self					)
									_SCREAMING_SNAKE_CASE     				=  ConfigTester(self				,     config_class=UpperCAmelCase_				,     hidden_size=37					)







			def 							UpperCamelCase				(     self:  List[Any]					):







									'''simple docstring'''




									self.config_tester.run_common_tests()







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







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE     				=  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*UpperCAmelCase_					)







			def 							UpperCamelCase				(     self:  Tuple					):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE     				=  self.model_tester.prepare_config_and_inputs_for_decoder()
									self.model_tester.create_and_check_model_as_decoder(*UpperCAmelCase_					)







			def 							UpperCamelCase				(     self:  str					):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE     				=  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_masked_lm(*UpperCAmelCase_					)







			def 							UpperCamelCase				(     self:  Optional[Any]					):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE     				=  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_token_classification(*UpperCAmelCase_					)







			@slow
			def 							UpperCamelCase				(     self:  Tuple					):







									'''simple docstring'''




									for model_name in TF_ESM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															_SCREAMING_SNAKE_CASE     				=  TFEsmModel.from_pretrained(UpperCAmelCase_					)
															self.assertIsNotNone(UpperCAmelCase_					)







			@unittest.skip("""Protein models do not support embedding resizing."""					)
			def 							UpperCamelCase				(     self:  Dict					):







									'''simple docstring'''




									pass







			@unittest.skip("""Protein models do not support embedding resizing."""					)
			def 							UpperCamelCase				(     self:  Optional[Any]					):







									'''simple docstring'''




									pass







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







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE				,					_SCREAMING_SNAKE_CASE     				=  self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
															_SCREAMING_SNAKE_CASE     				=  model_class(UpperCAmelCase_					)
															assert isinstance(model.get_input_embeddings()				,     tf.keras.layers.Layer					)
															if model_class is TFEsmForMaskedLM:
																					# Output embedding test differs from the main test because they're a matrix, not a layer
																					_SCREAMING_SNAKE_CASE     				=  model.get_bias()
																					assert isinstance(UpperCAmelCase_				,     UpperCAmelCase_					)
																					for k, v in name.items():
																											assert isinstance(UpperCAmelCase_				,     tf.Variable					)
															else:
																					_SCREAMING_SNAKE_CASE     				=  model.get_output_embeddings()
																					assert x is None
																					_SCREAMING_SNAKE_CASE     				=  model.get_bias()
																					assert name is None



@require_tf
class 				__UpperCAmelCase		(unittest.TestCase   ):







			@slow
			def 							UpperCamelCase				(     self:  Any					):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE     				=  TFEsmForMaskedLM.from_pretrained("""facebook/esm2_t6_8M_UR50D"""					)

									_SCREAMING_SNAKE_CASE     				=  tf.constant([[0, 1, 2, 3, 4, 5]]					)
									_SCREAMING_SNAKE_CASE     				=  model(UpperCAmelCase_					)[0]
									_SCREAMING_SNAKE_CASE     				=  [1, 6, 33]
									self.assertEqual(list(output.numpy().shape					)				,     UpperCAmelCase_					)
									# compare the actual values for a slice.
									_SCREAMING_SNAKE_CASE     				=  tf.constant(
									    [
									        [
									            [8.92_15_18, -10.58_98_14, -6.4_67_13_07],
									            [-6.3_96_71_56, -13.91_13_77, -1.1_21_19_15],
									            [-7.78_12_47, -13.95_15_57, -3.74_05_92],
									        ]
									    ]					)
									self.assertTrue(numpy.allclose(output[:, :3, :3].numpy()				,     expected_slice.numpy()				,     atol=1E-2					)					)







			@slow
			def 							UpperCamelCase				(     self:  str					):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE     				=  TFEsmModel.from_pretrained("""facebook/esm2_t6_8M_UR50D"""					)

									_SCREAMING_SNAKE_CASE     				=  tf.constant([[0, 6, 4, 13, 5, 4, 16, 12, 11, 7, 2]]					)
									_SCREAMING_SNAKE_CASE     				=  model(UpperCAmelCase_					)[0]
									# compare the actual values for a slice.
									_SCREAMING_SNAKE_CASE     				=  tf.constant(
									    [
									        [
									            [0.14_44_30_92, 0.54_12_53_27, 0.3_24_77_39],
									            [0.30_34_04_84, 0.00_52_66_76, 0.31_07_77_22],
									            [0.32_27_80_43, -0.24_98_70_96, 0.3_41_46_28],
									        ]
									    ]					)
									self.assertTrue(numpy.allclose(output[:, :3, :3].numpy()				,     expected_slice.numpy()				,     atol=1E-4					)					)

