

'''simple docstring'''





from dataclasses import dataclass
from typing import Dict, Optional, Tuple, Union

import torch
import torch.nn as nn

from ..configuration_utils import ConfigMixin, register_to_config
from ..utils import BaseOutput, apply_forward_hook
from .attention_processor import AttentionProcessor, AttnProcessor
from .modeling_utils import ModelMixin
from .vae import Decoder, DecoderOutput, DiagonalGaussianDistribution, Encoder
@dataclass
class        A  (	a_ ):
						__UpperCAmelCase				:	"DiagonalGaussianDistribution"



class        A  (	a_  ,    a_ ):
						__UpperCAmelCase				:	Union[str, Any]   =   True





						@register_to_config
						def __init__(	self	,    snake_case_ = 3	,    snake_case_ = 3	,    snake_case_ = ("DownEncoderBlock2D",)	,    snake_case_ = ("UpDecoderBlock2D",)	,    snake_case_ = (6_4,)	,    snake_case_ = 1	,    snake_case_ = "silu"	,    snake_case_ = 4	,    snake_case_ = 3_2	,    snake_case_ = 3_2	,    snake_case_ = 0.18_215	,    )			->							List[Any]:
										super().__init__()

										# pass init params to Encoder
										_a        =   Encoder(
										    in_channels=snake_case_	,    out_channels=snake_case_	,    down_block_types=snake_case_	,    block_out_channels=snake_case_	,    layers_per_block=snake_case_	,    act_fn=snake_case_	,    norm_num_groups=snake_case_	,    double_z=snake_case_	,    )

										# pass init params to Decoder
										_a        =   Decoder(
										    in_channels=snake_case_	,    out_channels=snake_case_	,    up_block_types=snake_case_	,    block_out_channels=snake_case_	,    layers_per_block=snake_case_	,    norm_num_groups=snake_case_	,    act_fn=snake_case_	,    )

										_a        =   nn.Convad(2 * latent_channels	,    2 * latent_channels	,    1			)
										_a        =   nn.Convad(snake_case_	,    snake_case_	,    1			)

										_a        =   False
										_a        =   False

										# only relevant if vae tiling is enabled
										_a        =   self.config.sample_size
										_a        =   (
										    self.config.sample_size[0]
										    if isinstance(self.config.sample_size	,    (list, tuple)			)
										    else self.config.sample_size
										)
										_a        =   int(sample_size / (2 ** (len(self.config.block_out_channels			) - 1))			)
										_a        =   0.25





						def __lowerCAmelCase   (	self	,    snake_case_	,    snake_case_=False			)			->							List[str]:







										if isinstance(snake_case_	,    (Encoder, Decoder)			):
														_a        =   value





						def __lowerCAmelCase   (	self	,    snake_case_ = True			)			->							List[Any]:
										_a        =   use_tiling





						def __lowerCAmelCase   (	self			)			->							str:
										self.enable_tiling(snake_case_			)





						def __lowerCAmelCase   (	self			)			->							Dict:
										_a        =   True





						def __lowerCAmelCase   (	self			)			->							Tuple:
										_a        =   False





						@property
						# Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.attn_processors
						def __lowerCAmelCase   (	self			)			->							Dict[str, AttentionProcessor]:
										_a        =   {}

										def fn_recursive_add_processors(snake_case_	,    snake_case_	,    snake_case_			):
														if hasattr(snake_case_	,    "set_processor"			):
																		_a        =   module.processor

														for sub_name, child in module.named_children():
																		fn_recursive_add_processors(F'''{name}.{sub_name}'''	,    snake_case_	,    snake_case_			)

														return processors

										for name, module in self.named_children():
														fn_recursive_add_processors(snake_case_	,    snake_case_	,    snake_case_			)

										return processors





						def __lowerCAmelCase   (	self	,    snake_case_			)			->							Dict:
										_a        =   len(self.attn_processors.keys()			)

										if isinstance(snake_case_	,    snake_case_			) and len(snake_case_			) != count:
														raise ValueError(
														    F'''A dict of processors was passed, but the number of processors {len(snake_case_			)} does not match the'''
														    F''' number of attention layers: {count}. Please make sure to pass {count} processor classes.'''			)

										def fn_recursive_attn_processor(snake_case_	,    snake_case_	,    snake_case_			):
														if hasattr(snake_case_	,    "set_processor"			):
																		if not isinstance(snake_case_	,    snake_case_			):
																						module.set_processor(snake_case_			)
																		else:
																						module.set_processor(processor.pop(F'''{name}.processor'''			)			)

														for sub_name, child in module.named_children():
																		fn_recursive_attn_processor(F'''{name}.{sub_name}'''	,    snake_case_	,    snake_case_			)

										for name, module in self.named_children():
														fn_recursive_attn_processor(snake_case_	,    snake_case_	,    snake_case_			)





						def __lowerCAmelCase   (	self			)			->							Tuple:
										self.set_attn_processor(AttnProcessor()			)





						@apply_forward_hook
						def __lowerCAmelCase   (	self	,    snake_case_	,    snake_case_ = True			)			->							AutoencoderKLOutput:







										if self.use_tiling and (x.shape[-1] > self.tile_sample_min_size or x.shape[-2] > self.tile_sample_min_size):
														return self.tiled_encode(snake_case_	,    return_dict=snake_case_			)

										if self.use_slicing and x.shape[0] > 1:
														_a        =   [self.encoder(snake_case_			) for x_slice in x.split(1			)]
														_a        =   torch.cat(snake_case_			)
										else:
														_a        =   self.encoder(snake_case_			)

										_a        =   self.quant_conv(snake_case_			)
										_a        =   DiagonalGaussianDistribution(snake_case_			)

										if not return_dict:
														return (posterior,)

										return AutoencoderKLOutput(latent_dist=snake_case_			)





						def __lowerCAmelCase   (	self	,    snake_case_	,    snake_case_ = True			)			->							Union[DecoderOutput, torch.FloatTensor]:







										if self.use_tiling and (z.shape[-1] > self.tile_latent_min_size or z.shape[-2] > self.tile_latent_min_size):
														return self.tiled_decode(snake_case_	,    return_dict=snake_case_			)

										_a        =   self.post_quant_conv(snake_case_			)
										_a        =   self.decoder(snake_case_			)

										if not return_dict:
														return (dec,)

										return DecoderOutput(sample=snake_case_			)





						@apply_forward_hook
						def __lowerCAmelCase   (	self	,    snake_case_	,    snake_case_ = True			)			->							Union[DecoderOutput, torch.FloatTensor]:







										if self.use_slicing and z.shape[0] > 1:
														_a        =   [self._decode(snake_case_			).sample for z_slice in z.split(1			)]
														_a        =   torch.cat(snake_case_			)
										else:
														_a        =   self._decode(snake_case_			).sample

										if not return_dict:
														return (decoded,)

										return DecoderOutput(sample=snake_case_			)





						def __lowerCAmelCase   (	self	,    snake_case_	,    snake_case_	,    snake_case_			)			->							Optional[int]:
										_a        =   min(a.shape[2]	,    b.shape[2]	,    snake_case_			)
										for y in range(snake_case_			):
														_a        =   a[:, :, -blend_extent + y, :] * (1 - y / blend_extent) + b[:, :, y, :] * (y / blend_extent)
										return b





						def __lowerCAmelCase   (	self	,    snake_case_	,    snake_case_	,    snake_case_			)			->							Tuple:
										_a        =   min(a.shape[3]	,    b.shape[3]	,    snake_case_			)
										for x in range(snake_case_			):
														_a        =   a[:, :, :, -blend_extent + x] * (1 - x / blend_extent) + b[:, :, :, x] * (x / blend_extent)
										return b





						def __lowerCAmelCase   (	self	,    snake_case_	,    snake_case_ = True			)			->							AutoencoderKLOutput:
										_a        =   int(self.tile_sample_min_size * (1 - self.tile_overlap_factor)			)
										_a        =   int(self.tile_latent_min_size * self.tile_overlap_factor			)
										_a        =   self.tile_latent_min_size - blend_extent

										# Split the image into 512x512 tiles and encode them separately.
										_a        =   []
										for i in range(0	,    x.shape[2]	,    snake_case_			):
														_a        =   []
														for j in range(0	,    x.shape[3]	,    snake_case_			):
																		_a        =   x[:, :, i : i + self.tile_sample_min_size, j : j + self.tile_sample_min_size]
																		_a        =   self.encoder(snake_case_			)
																		_a        =   self.quant_conv(snake_case_			)
																		row.append(snake_case_			)
														rows.append(snake_case_			)
										_a        =   []
										for i, row in enumerate(snake_case_			):
														_a        =   []
														for j, tile in enumerate(snake_case_			):
																		# blend the above tile and the left tile
																		# to the current tile and add the current tile to the result row
																		if i > 0:
																						_a        =   self.blend_v(rows[i - 1][j]	,    snake_case_	,    snake_case_			)
																		if j > 0:
																						_a        =   self.blend_h(row[j - 1]	,    snake_case_	,    snake_case_			)
																		result_row.append(tile[:, :, :row_limit, :row_limit]			)
														result_rows.append(torch.cat(snake_case_	,    dim=3			)			)

										_a        =   torch.cat(snake_case_	,    dim=2			)
										_a        =   DiagonalGaussianDistribution(snake_case_			)

										if not return_dict:
														return (posterior,)

										return AutoencoderKLOutput(latent_dist=snake_case_			)





						def __lowerCAmelCase   (	self	,    snake_case_	,    snake_case_ = True			)			->							Union[DecoderOutput, torch.FloatTensor]:
										_a        =   int(self.tile_latent_min_size * (1 - self.tile_overlap_factor)			)
										_a        =   int(self.tile_sample_min_size * self.tile_overlap_factor			)
										_a        =   self.tile_sample_min_size - blend_extent

										# Split z into overlapping 64x64 tiles and decode them separately.
										# The tiles have an overlap to avoid seams between tiles.
										_a        =   []
										for i in range(0	,    z.shape[2]	,    snake_case_			):
														_a        =   []
														for j in range(0	,    z.shape[3]	,    snake_case_			):
																		_a        =   z[:, :, i : i + self.tile_latent_min_size, j : j + self.tile_latent_min_size]
																		_a        =   self.post_quant_conv(snake_case_			)
																		_a        =   self.decoder(snake_case_			)
																		row.append(snake_case_			)
														rows.append(snake_case_			)
										_a        =   []
										for i, row in enumerate(snake_case_			):
														_a        =   []
														for j, tile in enumerate(snake_case_			):
																		# blend the above tile and the left tile
																		# to the current tile and add the current tile to the result row
																		if i > 0:
																						_a        =   self.blend_v(rows[i - 1][j]	,    snake_case_	,    snake_case_			)
																		if j > 0:
																						_a        =   self.blend_h(row[j - 1]	,    snake_case_	,    snake_case_			)
																		result_row.append(tile[:, :, :row_limit, :row_limit]			)
														result_rows.append(torch.cat(snake_case_	,    dim=3			)			)

										_a        =   torch.cat(snake_case_	,    dim=2			)
										if not return_dict:
														return (dec,)

										return DecoderOutput(sample=snake_case_			)





						def __lowerCAmelCase   (	self	,    snake_case_	,    snake_case_ = False	,    snake_case_ = True	,    snake_case_ = None	,    )			->							Union[DecoderOutput, torch.FloatTensor]:
										_a        =   sample
										_a        =   self.encode(snake_case_			).latent_dist
										if sample_posterior:
														_a        =   posterior.sample(generator=snake_case_			)
										else:
														_a        =   posterior.mode()
										_a        =   self.decode(snake_case_			).sample

										if not return_dict:
														return (dec,)

										return DecoderOutput(sample=snake_case_			)









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	)	)

