


import math

import torch
from torch import nn

from ..configuration_utils import ConfigMixin, register_to_config
from .attention_processor import Attention
from .embeddings import get_timestep_embedding
from .modeling_utils import ModelMixin







class        __lowercase       (							a_			,							a_  ):



		"""simple docstring"""

		@register_to_config
		def __init__( self		,      A = 1_28		,      A = 2_56		,      A = 2000.0		,      A = 7_68		,      A = 12		,      A = 12		,      A = 64		,      A = 20_48		,      A = 0.1		,      )  -> Tuple:







					'''simple docstring'''







					super().__init__()

					lowerCamelCase    		=  nn.Sequential(
					    nn.Linear(A		,      d_model * 4		,      bias=A	)		,      nn.SiLU()		,      nn.Linear(d_model * 4		,      d_model * 4		,      bias=A	)		,      nn.SiLU()		,      )

					lowerCamelCase    		=  nn.Embedding(A		,      A	)
					lowerCamelCase    		=  False

					lowerCamelCase    		=  nn.Linear(A		,      A		,      bias=A	)

					lowerCamelCase    		=  nn.Dropout(p=A	)

					lowerCamelCase    		=  nn.ModuleList()
					for lyr_num in range(A	):
								# FiLM conditional T5 decoder
								lowerCamelCase    		=  DecoderLayer(d_model=A		,      d_kv=A		,      num_heads=A		,      d_ff=A		,      dropout_rate=A	)
								self.decoders.append(A	)

					lowerCamelCase    		=  TaLayerNorm(A	)

					lowerCamelCase    		=  nn.Dropout(p=A	)
					lowerCamelCase    		=  nn.Linear(A		,      A		,      bias=A	)







		def 					__A   ( self		,      A		,      A	)  -> Union[str, Any]:







					'''simple docstring'''







					lowerCamelCase    		=  torch.mul(query_input.unsqueeze(-1	)		,      key_input.unsqueeze(-2	)	)
					return mask.unsqueeze(-3	)







		def 					__A   ( self		,      A		,      A		,      A	)  -> Optional[Any]:







					'''simple docstring'''







					lowerCamelCase		,		lowerCamelCase		,		lowerCamelCase    		=  decoder_input_tokens.shape
					assert decoder_noise_time.shape == (batch,)

					# decoder_noise_time is in [0, 1), so rescale to expected timing range.
					lowerCamelCase    		=  get_timestep_embedding(
					    decoder_noise_time * self.config.max_decoder_noise_time		,      embedding_dim=self.config.d_model		,      max_period=self.config.max_decoder_noise_time		,      ).to(dtype=self.dtype	)

					lowerCamelCase    		=  self.conditioning_emb(A	).unsqueeze(1	)

					assert conditioning_emb.shape == (batch, 1, self.config.d_model * 4)

					lowerCamelCase    		=  decoder_input_tokens.shape[1]

					# If we want to use relative positions for audio context, we can just offset
					# this sequence by the length of encodings_and_masks.
					lowerCamelCase    		=  torch.broadcast_to(
					    torch.arange(A		,      device=decoder_input_tokens.device	)		,      (batch, seq_length)		,      )

					lowerCamelCase    		=  self.position_encoding(A	)

					lowerCamelCase    		=  self.continuous_inputs_projection(A	)
					inputs += position_encodings
					lowerCamelCase    		=  self.dropout(A	)

					# decoder: No padding present.
					lowerCamelCase    		=  torch.ones(
					    decoder_input_tokens.shape[:2]		,      device=decoder_input_tokens.device		,      dtype=inputs.dtype	)

					# Translate encoding masks to encoder-decoder masks.
					lowerCamelCase    		=  [(x, self.encoder_decoder_mask(A		,      A	)) for x, y in encodings_and_masks]

					# cross attend style: concat encodings
					lowerCamelCase    		=  torch.cat([x[0] for x in encodings_and_encdec_masks]		,      dim=1	)
					lowerCamelCase    		=  torch.cat([x[1] for x in encodings_and_encdec_masks]		,      dim=-1	)

					for lyr in self.decoders:
								lowerCamelCase    		=  lyr(
								    A		,      conditioning_emb=A		,      encoder_hidden_states=A		,      encoder_attention_mask=A		,      )[0]

					lowerCamelCase    		=  self.decoder_norm(A	)
					lowerCamelCase    		=  self.post_dropout(A	)

					lowerCamelCase    		=  self.spec_out(A	)
					return spec_out







class        __lowercase       (							nn.Module  ):



		"""simple docstring"""

		def __init__( self		,      A		,      A		,      A		,      A		,      A		,      A=1e-6	)  -> Union[str, Any]:







					'''simple docstring'''







					super().__init__()
					lowerCamelCase    		=  nn.ModuleList()

					# cond self attention: layer 0
					self.layer.append(
					    TaLayerSelfAttentionCond(d_model=A		,      d_kv=A		,      num_heads=A		,      dropout_rate=A	)	)

					# cross attention: layer 1
					self.layer.append(
					    TaLayerCrossAttention(
					        d_model=A		,      d_kv=A		,      num_heads=A		,      dropout_rate=A		,      layer_norm_epsilon=A		,      )	)

					# Film Cond MLP + dropout: last layer
					self.layer.append(
					    TaLayerFFCond(d_model=A		,      d_ff=A		,      dropout_rate=A		,      layer_norm_epsilon=A	)	)







		def 					__A   ( self		,      A		,      A=None		,      A=None		,      A=None		,      A=None		,      A=None		,      )  -> Dict:







					'''simple docstring'''







					lowerCamelCase    		=  self.layer[0](
					    A		,      conditioning_emb=A		,      attention_mask=A		,      )

					if encoder_hidden_states is not None:
								lowerCamelCase    		=  torch.where(encoder_attention_mask > 0		,      0		,      -1e1_0	).to(
								    encoder_hidden_states.dtype	)

								lowerCamelCase    		=  self.layer[1](
								    A		,      key_value_states=A		,      attention_mask=A		,      )

					# Apply Film Conditional Feed Forward layer
					lowerCamelCase    		=  self.layer[-1](A		,      A	)

					return (hidden_states,)







class        __lowercase       (							nn.Module  ):



		"""simple docstring"""

		def __init__( self		,      A		,      A		,      A		,      A	)  -> Tuple:







					'''simple docstring'''







					super().__init__()
					lowerCamelCase    		=  TaLayerNorm(A	)
					lowerCamelCase    		=  TaFiLMLayer(in_features=d_model * 4		,      out_features=A	)
					lowerCamelCase    		=  Attention(query_dim=A		,      heads=A		,      dim_head=A		,      out_bias=A		,      scale_qk=A	)
					lowerCamelCase    		=  nn.Dropout(A	)







		def 					__A   ( self		,      A		,      A=None		,      A=None		,      )  -> Any:







					'''simple docstring'''







					lowerCamelCase    		=  self.layer_norm(A	)

					if conditioning_emb is not None:
								lowerCamelCase    		=  self.FiLMLayer(A		,      A	)

					# Self-attention block
					lowerCamelCase    		=  self.attention(A	)

					lowerCamelCase    		=  hidden_states + self.dropout(A	)

					return hidden_states







class        __lowercase       (							nn.Module  ):



		"""simple docstring"""

		def __init__( self		,      A		,      A		,      A		,      A		,      A	)  -> Dict:







					'''simple docstring'''







					super().__init__()
					lowerCamelCase    		=  Attention(query_dim=A		,      heads=A		,      dim_head=A		,      out_bias=A		,      scale_qk=A	)
					lowerCamelCase    		=  TaLayerNorm(A		,      eps=A	)
					lowerCamelCase    		=  nn.Dropout(A	)







		def 					__A   ( self		,      A		,      A=None		,      A=None		,      )  -> Optional[Any]:







					'''simple docstring'''







					lowerCamelCase    		=  self.layer_norm(A	)
					lowerCamelCase    		=  self.attention(
					    A		,      encoder_hidden_states=A		,      attention_mask=attention_mask.squeeze(1	)		,      )
					lowerCamelCase    		=  hidden_states + self.dropout(A	)
					return layer_output







class        __lowercase       (							nn.Module  ):



		"""simple docstring"""

		def __init__( self		,      A		,      A		,      A		,      A	)  -> Any:







					'''simple docstring'''







					super().__init__()
					lowerCamelCase    		=  TaDenseGatedActDense(d_model=A		,      d_ff=A		,      dropout_rate=A	)
					lowerCamelCase    		=  TaFiLMLayer(in_features=d_model * 4		,      out_features=A	)
					lowerCamelCase    		=  TaLayerNorm(A		,      eps=A	)
					lowerCamelCase    		=  nn.Dropout(A	)







		def 					__A   ( self		,      A		,      A=None	)  -> List[Any]:







					'''simple docstring'''







					lowerCamelCase    		=  self.layer_norm(A	)
					if conditioning_emb is not None:
								lowerCamelCase    		=  self.film(A		,      A	)

					lowerCamelCase    		=  self.DenseReluDense(A	)
					lowerCamelCase    		=  hidden_states + self.dropout(A	)
					return hidden_states







class        __lowercase       (							nn.Module  ):



		"""simple docstring"""

		def __init__( self		,      A		,      A		,      A	)  -> List[str]:







					'''simple docstring'''







					super().__init__()
					lowerCamelCase    		=  nn.Linear(A		,      A		,      bias=A	)
					lowerCamelCase    		=  nn.Linear(A		,      A		,      bias=A	)
					lowerCamelCase    		=  nn.Linear(A		,      A		,      bias=A	)
					lowerCamelCase    		=  nn.Dropout(A	)
					lowerCamelCase    		=  NewGELUActivation()







		def 					__A   ( self		,      A	)  -> Tuple:







					'''simple docstring'''







					lowerCamelCase    		=  self.act(self.wi_a(A	)	)
					lowerCamelCase    		=  self.wi_a(A	)
					lowerCamelCase    		=  hidden_gelu * hidden_linear
					lowerCamelCase    		=  self.dropout(A	)

					lowerCamelCase    		=  self.wo(A	)
					return hidden_states







class        __lowercase       (							nn.Module  ):



		"""simple docstring"""

		def __init__( self		,      A		,      A=1e-6	)  -> str:







					'''simple docstring'''







					super().__init__()
					lowerCamelCase    		=  nn.Parameter(torch.ones(A	)	)
					lowerCamelCase    		=  eps







		def 					__A   ( self		,      A	)  -> List[str]:







					'''simple docstring'''







					lowerCamelCase    		=  hidden_states.to(torch.floataa	).pow(2	).mean(-1		,      keepdim=A	)
					lowerCamelCase    		=  hidden_states * torch.rsqrt(variance + self.variance_epsilon	)

					# convert into half-precision if necessary
					if self.weight.dtype in [torch.floataa, torch.bfloataa]:
								lowerCamelCase    		=  hidden_states.to(self.weight.dtype	)

					return self.weight * hidden_states







class        __lowercase       (							nn.Module  ):



		"""simple docstring"""

		def 					__A   ( self		,      A	)  -> torch.Tensor:







					'''simple docstring'''







					return 0.5 * input * (1.0 + torch.tanh(math.sqrt(2.0 / math.pi	) * (input + 0.044715 * torch.pow(A		,      3.0	))	))







class        __lowercase       (							nn.Module  ):



		"""simple docstring"""

		def __init__( self		,      A		,      A	)  -> Optional[Any]:







					'''simple docstring'''







					super().__init__()
					lowerCamelCase    		=  nn.Linear(A		,      out_features * 2		,      bias=A	)







		def 					__A   ( self		,      A		,      A	)  -> Dict:







					'''simple docstring'''







					lowerCamelCase    		=  self.scale_bias(A	)
					lowerCamelCase		,		lowerCamelCase    		=  torch.chunk(A		,      2		,      -1	)
					lowerCamelCase    		=  x * (1 + scale) + shift
					return x





import itertools
import random
import unittest

import numpy as np

from transformers import is_speech_available
from transformers.testing_utils import require_torch, require_torchaudio

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_speech_available():
		from transformers import SpeechaTextFeatureExtractor

UpperCAmelCase   :    Any     =		random.Random()






def 	__lowerCamelCase						(							lowerCamelCase__		:						int  ,							lowerCamelCase__		:						Union[str, Any]=1.0  ,							lowerCamelCase__		:						Union[str, Any]=None  ,							lowerCamelCase__		:						int=None      ):





			'''simple docstring'''




			if rng is None:
						lowerCamelCase    		=  global_rng

			lowerCamelCase    		=  []
			for batch_idx in range(shape[0]      ):
						values.append([]      )
						for _ in range(shape[1]      ):
									values[-1].append(rng.random() * scale      )

			return values







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



		"""simple docstring"""

		def __init__( self		,      A		,      A=7		,      A=4_00		,      A=20_00		,      A=24		,      A=24		,      A=0.0		,      A=1_60_00		,      A=True		,      A=True		,      )  -> str:







					'''simple docstring'''







					lowerCamelCase    		=  parent
					lowerCamelCase    		=  batch_size
					lowerCamelCase    		=  min_seq_length
					lowerCamelCase    		=  max_seq_length
					lowerCamelCase    		=  (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
					lowerCamelCase    		=  feature_size
					lowerCamelCase    		=  num_mel_bins
					lowerCamelCase    		=  padding_value
					lowerCamelCase    		=  sampling_rate
					lowerCamelCase    		=  return_attention_mask
					lowerCamelCase    		=  do_normalize







		def 					__A   ( self	)  -> List[str]:







					'''simple docstring'''







					return {
					    "feature_size": self.feature_size,
					    "num_mel_bins": self.num_mel_bins,
					    "padding_value": self.padding_value,
					    "sampling_rate": self.sampling_rate,
					    "return_attention_mask": self.return_attention_mask,
					    "do_normalize": self.do_normalize,
					}







		def 					__A   ( self		,      A=False		,      A=False	)  -> Tuple:







					'''simple docstring'''







					def _flatten(A	):
								return list(itertools.chain(*A	)	)

					if equal_length:
								lowerCamelCase    		=  [floats_list((self.max_seq_length, self.feature_size)	) for _ in range(self.batch_size	)]
					else:
								# make sure that inputs increase in size
								lowerCamelCase    		=  [
								    floats_list((x, self.feature_size)	)
								    for x in range(self.min_seq_length		,      self.max_seq_length		,      self.seq_length_diff	)
								]
					if numpify:
								lowerCamelCase    		=  [np.asarray(A	) for x in speech_inputs]
					return speech_inputs







@require_torch
@require_torchaudio
class        __lowercase       (							a_			,							unittest.TestCase  ):



		"""simple docstring"""

		UpperCamelCase     :					str			       =		SpeechaTextFeatureExtractor if is_speech_available() else None







		def 					__A   ( self	)  -> int:







					'''simple docstring'''







					lowerCamelCase    		=  SpeechaTextFeatureExtractionTester(self	)







		def 					__A   ( self		,      A	)  -> List[Any]:







					'''simple docstring'''







					self.assertTrue(np.all(np.mean(A		,      axis=0	) < 1e-3	)	)
					self.assertTrue(np.all(np.abs(np.var(A		,      axis=0	) - 1	) < 1e-3	)	)







		def 					__A   ( self	)  -> Optional[int]:







					'''simple docstring'''







					lowerCamelCase    		=  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()	)
					# create three inputs of length 800, 1000, and 1200
					lowerCamelCase    		=  [floats_list((1, x)	)[0] for x in range(8_00		,      14_00		,      2_00	)]
					lowerCamelCase    		=  [np.asarray(A	) for speech_input in speech_inputs]

					# Test feature size
					lowerCamelCase    		=  feature_extractor(A		,      padding=A		,      return_tensors="""np"""	).input_features
					self.assertTrue(input_features.ndim == 3	)
					self.assertTrue(input_features.shape[-1] == feature_extractor.feature_size	)

					# Test not batched input
					lowerCamelCase    		=  feature_extractor(speech_inputs[0]		,      return_tensors="""np"""	).input_features
					lowerCamelCase    		=  feature_extractor(np_speech_inputs[0]		,      return_tensors="""np"""	).input_features
					self.assertTrue(np.allclose(A		,      A		,      atol=1e-3	)	)

					# Test batched
					lowerCamelCase    		=  feature_extractor(A		,      return_tensors="""np"""	).input_features
					lowerCamelCase    		=  feature_extractor(A		,      return_tensors="""np"""	).input_features
					for enc_seq_a, enc_seq_a in zip(A		,      A	):
								self.assertTrue(np.allclose(A		,      A		,      atol=1e-3	)	)

					# Test 2-D numpy arrays are batched.
					lowerCamelCase    		=  [floats_list((1, x)	)[0] for x in (8_00, 8_00, 8_00)]
					lowerCamelCase    		=  np.asarray(A	)
					lowerCamelCase    		=  feature_extractor(A		,      return_tensors="""np"""	).input_features
					lowerCamelCase    		=  feature_extractor(A		,      return_tensors="""np"""	).input_features
					for enc_seq_a, enc_seq_a in zip(A		,      A	):
								self.assertTrue(np.allclose(A		,      A		,      atol=1e-3	)	)







		def 					__A   ( self	)  -> Optional[Any]:







					'''simple docstring'''







					lowerCamelCase    		=  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()	)
					lowerCamelCase    		=  [floats_list((1, x)	)[0] for x in range(8_00		,      14_00		,      2_00	)]

					lowerCamelCase    		=  ["""longest""", """max_length""", """do_not_pad"""]
					lowerCamelCase    		=  [None, 16, None]
					for max_length, padding in zip(A		,      A	):
								lowerCamelCase    		=  feature_extractor(
								    A		,      padding=A		,      max_length=A		,      return_attention_mask=A	)
								lowerCamelCase    		=  inputs.input_features
								lowerCamelCase    		=  inputs.attention_mask
								lowerCamelCase    		=  [np.sum(A	) for x in attention_mask]

								self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]]	)
								self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]]	)
								self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]]	)







		def 					__A   ( self	)  -> List[Any]:







					'''simple docstring'''







					lowerCamelCase    		=  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()	)
					lowerCamelCase    		=  [floats_list((1, x)	)[0] for x in range(8_00		,      14_00		,      2_00	)]

					lowerCamelCase    		=  ["""longest""", """max_length""", """do_not_pad"""]
					lowerCamelCase    		=  [None, 16, None]
					for max_length, padding in zip(A		,      A	):
								lowerCamelCase    		=  feature_extractor(
								    A		,      max_length=A		,      padding=A		,      return_tensors="""np"""		,      return_attention_mask=A	)
								lowerCamelCase    		=  inputs.input_features
								lowerCamelCase    		=  inputs.attention_mask
								lowerCamelCase    		=  [np.sum(A	) for x in attention_mask]

								self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]]	)
								self.assertTrue(input_features[0][fbank_feat_lengths[0] :].sum() < 1e-6	)
								self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]]	)
								self.assertTrue(input_features[0][fbank_feat_lengths[1] :].sum() < 1e-6	)
								self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]]	)







		def 					__A   ( self	)  -> int:







					'''simple docstring'''







					lowerCamelCase    		=  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()	)
					lowerCamelCase    		=  [floats_list((1, x)	)[0] for x in range(8_00		,      14_00		,      2_00	)]
					lowerCamelCase    		=  feature_extractor(
					    A		,      padding="""max_length"""		,      max_length=4		,      truncation=A		,      return_tensors="""np"""		,      return_attention_mask=A		,      )
					lowerCamelCase    		=  inputs.input_features
					lowerCamelCase    		=  inputs.attention_mask
					lowerCamelCase    		=  np.sum(attention_mask == 1		,      axis=1	)

					self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]	)
					self._check_zero_mean_unit_variance(input_features[1]	)
					self._check_zero_mean_unit_variance(input_features[2]	)







		def 					__A   ( self	)  -> List[Any]:







					'''simple docstring'''







					lowerCamelCase    		=  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()	)
					lowerCamelCase    		=  [floats_list((1, x)	)[0] for x in range(8_00		,      14_00		,      2_00	)]
					lowerCamelCase    		=  feature_extractor(
					    A		,      padding="""longest"""		,      max_length=4		,      truncation=A		,      return_tensors="""np"""		,      return_attention_mask=A		,      )
					lowerCamelCase    		=  inputs.input_features
					lowerCamelCase    		=  inputs.attention_mask
					lowerCamelCase    		=  np.sum(attention_mask == 1		,      axis=1	)

					self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]	)
					self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]]	)
					self._check_zero_mean_unit_variance(input_features[2]	)

					# make sure that if max_length < longest -> then pad to max_length
					self.assertEqual(input_features.shape		,      (3, 4, 24)	)

					lowerCamelCase    		=  [floats_list((1, x)	)[0] for x in range(8_00		,      14_00		,      2_00	)]
					lowerCamelCase    		=  feature_extractor(
					    A		,      padding="""longest"""		,      max_length=16		,      truncation=A		,      return_tensors="""np"""		,      return_attention_mask=A		,      )
					lowerCamelCase    		=  inputs.input_features
					lowerCamelCase    		=  inputs.attention_mask
					lowerCamelCase    		=  np.sum(attention_mask == 1		,      axis=1	)

					self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]	)
					self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]]	)
					self._check_zero_mean_unit_variance(input_features[2]	)

					# make sure that if max_length < longest -> then pad to max_length
					self.assertEqual(input_features.shape		,      (3, 6, 24)	)







		def 					__A   ( self	)  -> Optional[int]:







					'''simple docstring'''







					import torch

					lowerCamelCase    		=  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()	)
					lowerCamelCase    		=  np.random.rand(1_00		,      32	).astype(np.floataa	)
					lowerCamelCase    		=  np_speech_inputs.tolist()

					for inputs in [py_speech_inputs, np_speech_inputs]:
								lowerCamelCase    		=  feature_extractor.pad([{"""input_features""": inputs}]		,      return_tensors="""np"""	)
								self.assertTrue(np_processed.input_features.dtype == np.floataa	)
								lowerCamelCase    		=  feature_extractor.pad([{"""input_features""": inputs}]		,      return_tensors="""pt"""	)
								self.assertTrue(pt_processed.input_features.dtype == torch.floataa	)







		def 					__A   ( self		,      A	)  -> Any:







					'''simple docstring'''







					from datasets import load_dataset

					lowerCamelCase    		=  load_dataset("""hf-internal-testing/librispeech_asr_dummy"""		,      """clean"""		,      split="""validation"""	)
					# automatic decoding with librispeech
					lowerCamelCase    		=  ds.sort("""id"""	).select(range(A	)	)[:num_samples]["""audio"""]

					return [x["array"] for x in speech_samples]







		def 					__A   ( self	)  -> Any:







					'''simple docstring'''







					lowerCamelCase    		=  np.array([
					    -1.5745, -1.7713, -1.7020, -1.6069, -1.2250, -1.1105, -0.9072, -0.8241,
					    -1.2310, -0.8098, -0.3320, -0.4101, -0.7985, -0.4996, -0.8213, -0.9128,
					    -1.0420, -1.1286, -1.0440, -0.7999, -0.8405, -1.2275, -1.5443, -1.4625,
					]	)
					# fmt: on

					lowerCamelCase    		=  self._load_datasamples(1	)
					lowerCamelCase    		=  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()	)
					lowerCamelCase    		=  feature_extractor(A		,      return_tensors="""pt"""	).input_features
					self.assertEquals(input_features.shape		,      (1, 5_84, 24)	)
					self.assertTrue(np.allclose(input_features[0, 0, :30]		,      A		,      atol=1e-4	)	)

