
"""simple docstring"""


import collections
import inspect
import unittest

from transformers import NatConfig
from transformers.testing_utils import require_natten, require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

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


if is_torch_available():
		import torch
		from torch import nn

		from transformers import NatBackbone, NatForImageClassification, NatModel
		from transformers.models.nat.modeling_nat import NAT_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
		from PIL import Image

		from transformers import AutoImageProcessor







class 			lowerCAmelCase_			:



						'''simple docstring'''


						def __init__(	self       : Union[str, Any]					,A_       : Optional[Any]					,A_       : Dict=13					,A_       : int=64					,A_       : Union[str, Any]=4					,A_       : Any=3					,A_       : Optional[int]=16					,A_       : int=[1, 2, 1]					,A_       : Tuple=[2, 4, 8]					,A_       : Union[str, Any]=3					,A_       : str=2.0					,A_       : Any=True					,A_       : List[Any]=0.0					,A_       : Any=0.0					,A_       : List[Any]=0.1					,A_       : int="gelu"					,A_       : int=True					,A_       : Optional[int]=0.02					,A_       : Optional[Any]=1e-5					,A_       : Union[str, Any]=True					,A_       : List[Any]=None					,A_       : Union[str, Any]=True					,A_       : str=10					,A_       : int=["stage1", "stage2"]					,A_       : List[Any]=[1, 2]					,)       ->				Union[str, Any]:
							A  				=				parent
							A  				=				batch_size
							A  				=				image_size
							A  				=				patch_size
							A  				=				num_channels
							A  				=				embed_dim
							A  				=				depths
							A  				=				num_heads
							A  				=				kernel_size
							A  				=				mlp_ratio
							A  				=				qkv_bias
							A  				=				hidden_dropout_prob
							A  				=				attention_probs_dropout_prob
							A  				=				drop_path_rate
							A  				=				hidden_act
							A  				=				patch_norm
							A  				=				layer_norm_eps
							A  				=				initializer_range
							A  				=				is_training
							A  				=				scope
							A  				=				use_labels
							A  				=				num_labels
							A  				=				out_features
							A  				=				out_indices


						def   _SCREAMING_SNAKE_CASE (	self       : Tuple )       ->				Tuple:
							A  				=				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

							A  				=				None
							if self.use_labels:
								A  				=				ids_tensor([self.batch_size]					,self.num_labels )

							A  				=				self.get_config()

							return config, pixel_values, labels


						def   _SCREAMING_SNAKE_CASE (	self       : List[Any] )       ->				Union[str, Any]:
							return NatConfig(
							    num_labels=self.num_labels					,image_size=self.image_size					,patch_size=self.patch_size					,num_channels=self.num_channels					,embed_dim=self.embed_dim					,depths=self.depths					,num_heads=self.num_heads					,kernel_size=self.kernel_size					,mlp_ratio=self.mlp_ratio					,qkv_bias=self.qkv_bias					,hidden_dropout_prob=self.hidden_dropout_prob					,attention_probs_dropout_prob=self.attention_probs_dropout_prob					,drop_path_rate=self.drop_path_rate					,hidden_act=self.hidden_act					,patch_norm=self.patch_norm					,layer_norm_eps=self.layer_norm_eps					,initializer_range=self.initializer_range					,out_features=self.out_features					,out_indices=self.out_indices					,)


						def   _SCREAMING_SNAKE_CASE (	self       : str					,A_       : Tuple					,A_       : List[str]					,A_       : Any )       ->				Optional[int]:
							A  				=				NatModel(config=A_ )
							model.to(A_ )
							model.eval()
							A  				=				model(A_ )

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

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


						def   _SCREAMING_SNAKE_CASE (	self       : int					,A_       : Union[str, Any]					,A_       : Union[str, Any]					,A_       : Dict )       ->				str:
							A  				=				NatForImageClassification(A_ )
							model.to(A_ )
							model.eval()
							A  				=				model(A_					,labels=A_ )
							self.parent.assertEqual(result.logits.shape					,(self.batch_size, self.num_labels) )

							# test greyscale images
							A  				=				1
							A  				=				NatForImageClassification(A_ )
							model.to(A_ )
							model.eval()

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


						def   _SCREAMING_SNAKE_CASE (	self       : Optional[int]					,A_       : str					,A_       : Dict					,A_       : Optional[Any] )       ->				Optional[int]:
							A  				=				NatBackbone(config=A_ )
							model.to(A_ )
							model.eval()
							A  				=				model(A_ )

							# verify hidden states
							self.parent.assertEqual(len(result.feature_maps )					,len(config.out_features ) )
							self.parent.assertListEqual(list(result.feature_maps[0].shape )					,[self.batch_size, model.channels[0], 16, 16] )

							# verify channels
							self.parent.assertEqual(len(model.channels )					,len(config.out_features ) )

							# verify backbone works with out_features=None
							A  				=				None
							A  				=				NatBackbone(config=A_ )
							model.to(A_ )
							model.eval()
							A  				=				model(A_ )

							# verify feature maps
							self.parent.assertEqual(len(result.feature_maps )					,1 )
							self.parent.assertListEqual(list(result.feature_maps[0].shape )					,[self.batch_size, model.channels[-1], 4, 4] )

							# verify channels
							self.parent.assertEqual(len(model.channels )					,1 )




						def   _SCREAMING_SNAKE_CASE (	self       : int )       ->				List[str]:
							A  				=				self.prepare_config_and_inputs()
							A				, A				, A  				=				config_and_inputs
							A  				=				{'pixel_values': pixel_values}
							return config, inputs_dict







@require_natten
@require_torch
class 			lowerCAmelCase_			( _lowercase						,   _lowercase						,   unittest.TestCase      ):



						'''simple docstring'''


						_lowerCamelCase:      Optional[Any] =      (
						    (
						        NatModel,
						        NatForImageClassification,
						        NatBackbone,
						    )
						    if is_torch_available()
						    else ()
						)
						_lowerCamelCase:      Dict =      (
						    {'''feature-extraction''': NatModel, '''image-classification''': NatForImageClassification}
						    if is_torch_available()
						    else {}
						)
						_lowerCamelCase:      Optional[int] =      False

						_lowerCamelCase:      int =      False
						_lowerCamelCase:      Optional[int] =      False
						_lowerCamelCase:      Tuple =      False
						_lowerCamelCase:      Union[str, Any] =      False


						def   _SCREAMING_SNAKE_CASE (	self       : List[Any] )       ->				Any:
							A  				=				NatModelTester(self )
							A  				=				ConfigTester(self					,config_class=A_					,embed_dim=37 )


						def   _SCREAMING_SNAKE_CASE (	self       : Any )       ->				Any:
							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   _SCREAMING_SNAKE_CASE (	self       : Any )       ->				str:
							return


						def   _SCREAMING_SNAKE_CASE (	self       : Optional[Any] )       ->				Union[str, Any]:
							A  				=				self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*A_ )


						def   _SCREAMING_SNAKE_CASE (	self       : List[str] )       ->				Dict:
							A  				=				self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*A_ )


						def   _SCREAMING_SNAKE_CASE (	self       : int )       ->				Optional[Any]:
							A  				=				self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_backbone(*A_ )


						@unittest.skip(reason='Nat does not use inputs_embeds' )
						def   _SCREAMING_SNAKE_CASE (	self       : List[Any] )       ->				int:
							pass


						@unittest.skip(reason='Nat does not use feedforward chunking' )
						def   _SCREAMING_SNAKE_CASE (	self       : Union[str, Any] )       ->				List[Any]:
							pass


						def   _SCREAMING_SNAKE_CASE (	self       : List[str] )       ->				Union[str, Any]:
							A				, A  				=				self.model_tester.prepare_config_and_inputs_for_common()

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


						def   _SCREAMING_SNAKE_CASE (	self       : List[str] )       ->				Tuple:
							A				, A  				=				self.model_tester.prepare_config_and_inputs_for_common()

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

								A  				=				['pixel_values']
								self.assertListEqual(arg_names[:1]					,A_ )


						def   _SCREAMING_SNAKE_CASE (	self       : List[Any] )       ->				int:
							self.skipTest('Nat\'s attention operation is handled entirely by NATTEN.' )


						def   _SCREAMING_SNAKE_CASE (	self       : List[str]					,A_       : Any					,A_       : str					,A_       : Dict					,A_       : Any )       ->				str:
							A  				=				model_class(A_ )
							model.to(A_ )
							model.eval()

							with torch.no_grad():
								A  				=				model(**self._prepare_for_class(A_					,A_ ) )

							A  				=				outputs.hidden_states

							A  				=				getattr(
							    self.model_tester					,'expected_num_hidden_layers'					,len(self.model_tester.depths ) + 1 )
							self.assertEqual(len(A_ )					,A_ )

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

							A  				=				image_size[0] // patch_size[0]
							A  				=				image_size[1] // patch_size[1]

							self.assertListEqual(
							    list(hidden_states[0].shape[-3:] )					,[height, width, self.model_tester.embed_dim]					,)

							if model_class.__name__ != "NatBackbone":
								A  				=				outputs.reshaped_hidden_states
								self.assertEqual(len(A_ )					,A_ )

								A				, A				, A				, A  				=				reshaped_hidden_states[0].shape
								A  				=				(
								    reshaped_hidden_states[0].view(A_					,A_					,A_					,A_ ).permute(0					,2					,3					,1 )
								)
								self.assertListEqual(
								    list(reshaped_hidden_states.shape[-3:] )					,[height, width, self.model_tester.embed_dim]					,)


						def   _SCREAMING_SNAKE_CASE (	self       : Tuple )       ->				List[str]:
							A				, A  				=				self.model_tester.prepare_config_and_inputs_for_common()

							A  				=				(
							    self.model_tester.image_size
							    if isinstance(self.model_tester.image_size					,collections.abc.Iterable )
							    else (self.model_tester.image_size, self.model_tester.image_size)
							)

							for model_class in self.all_model_classes:
								A  				=				True
								self.check_hidden_states_output(A_					,A_					,A_					,A_ )

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

								self.check_hidden_states_output(A_					,A_					,A_					,A_ )


						@slow
						def   _SCREAMING_SNAKE_CASE (	self       : Optional[Any] )       ->				Tuple:
							for model_name in NAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
								A  				=				NatModel.from_pretrained(A_ )
								self.assertIsNotNone(A_ )




						def   _SCREAMING_SNAKE_CASE (	self       : List[str] )       ->				List[Any]:
							A				, A  				=				self.model_tester.prepare_config_and_inputs_for_common()

							A  				=				_config_zero_init(A_ )
							for model_class in self.all_model_classes:
								A  				=				model_class(config=A_ )
								for name, param in model.named_parameters():
									if "embeddings" not in name and param.requires_grad:
										self.assertIn(
										    ((param.data.mean() * 1e9).round() / 1e9).item()					,[0.0, 1.0]					,msg=F'Parameter {name} of model {model_class} seems not properly initialized'					,)







@require_natten
@require_vision
@require_torch
class 			lowerCAmelCase_			( unittest.TestCase      ):



						'''simple docstring'''


						@cached_property
						def   _SCREAMING_SNAKE_CASE (	self       : int )       ->				int:
							return AutoImageProcessor.from_pretrained('shi-labs/nat-mini-in1k-224' ) if is_vision_available() else None




						@slow
						def   _SCREAMING_SNAKE_CASE (	self       : Optional[Any] )       ->				Union[str, Any]:
							A  				=				NatForImageClassification.from_pretrained('shi-labs/nat-mini-in1k-224' ).to(A_ )
							A  				=				self.default_image_processor

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

							# forward pass
							with torch.no_grad():
								A  				=				model(**A_ )

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







@require_torch
@require_natten
class 			lowerCAmelCase_			( unittest.TestCase						,   _lowercase      ):



						'''simple docstring'''


						_lowerCamelCase:      List[str] =      (NatBackbone,) if is_torch_available() else ()
						_lowerCamelCase:      Tuple =      NatConfig


						def   _SCREAMING_SNAKE_CASE (	self       : Tuple )       ->				List[str]:
							A  				=				NatModelTester(self )

"""simple docstring"""


import itertools
import random
import unittest

import numpy as np

from transformers import EncodecFeatureExtractor
from transformers.testing_utils import require_torch
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_torch_available():
		import torch


_lowercase											=			random.Random()






def  _snake_case			(						snake_case__				:       List[str]		, snake_case__				:       Union[str, Any]=1.0		, snake_case__				:       int=None		, snake_case__				:       Dict=None       ):
	if rng is None:
		A  				=				global_rng

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

	return values







@require_torch
class 			lowerCAmelCase_			( unittest.TestCase      ):



						'''simple docstring'''


						def __init__(	self       : int					,A_       : str					,A_       : List[str]=7					,A_       : Tuple=400					,A_       : Union[str, Any]=2000					,A_       : Optional[Any]=1					,A_       : Optional[int]=0.0					,A_       : str=2_4000					,A_       : Optional[int]=True					,)       ->				Dict:
							A  				=				parent
							A  				=				batch_size
							A  				=				min_seq_length
							A  				=				max_seq_length
							A  				=				(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
							A  				=				feature_size
							A  				=				padding_value
							A  				=				sampling_rate
							A  				=				return_attention_mask


						def   _SCREAMING_SNAKE_CASE (	self       : Optional[Any] )       ->				Optional[int]:
							return {
							    "feature_size": self.feature_size,
							    "padding_value": self.padding_value,
							    "sampling_rate": self.sampling_rate,
							    "return_attention_mask": self.return_attention_mask,
							}




						def   _SCREAMING_SNAKE_CASE (	self       : Dict					,A_       : List[str]=False					,A_       : str=False )       ->				Optional[Any]:
							def _flatten(A_       : int ):
								return list(itertools.chain(*A_ ) )

							if equal_length:
								A  				=				floats_list((self.batch_size, self.max_seq_length) )
							else:
								# make sure that inputs increase in size
								A  				=				[
								    _flatten(floats_list((x, self.feature_size) ) )
								    for x in range(self.min_seq_length					,self.max_seq_length					,self.seq_length_diff )
								]

							if numpify:
								A  				=				[np.asarray(A_ ) for x in audio_inputs]

							return audio_inputs







@require_torch
class 			lowerCAmelCase_			( _lowercase						,   unittest.TestCase      ):



						'''simple docstring'''


						_lowerCamelCase:      Union[str, Any] =      EncodecFeatureExtractor


						def   _SCREAMING_SNAKE_CASE (	self       : List[str] )       ->				List[Any]:
							A  				=				EnCodecFeatureExtractionTester(self )


						def   _SCREAMING_SNAKE_CASE (	self       : Tuple )       ->				str:
							# Tests that all call wrap to encode_plus and batch_encode_plus
							A  				=				self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
							# create three inputs of length 800, 1000, and 1200
							A  				=				[floats_list((1, x) )[0] for x in range(800					,1400					,200 )]
							A  				=				[np.asarray(A_ ) for audio_input in audio_inputs]

							# Test not batched input
							A  				=				feat_extract(audio_inputs[0]					,return_tensors='np' ).input_values
							A  				=				feat_extract(np_audio_inputs[0]					,return_tensors='np' ).input_values
							self.assertTrue(np.allclose(A_					,A_					,atol=1e-3 ) )

							# Test batched
							A  				=				feat_extract(A_					,padding=A_					,return_tensors='np' ).input_values
							A  				=				feat_extract(A_					,padding=A_					,return_tensors='np' ).input_values
							for enc_seq_a, enc_seq_a in zip(A_					,A_ ):
								self.assertTrue(np.allclose(A_					,A_					,atol=1e-3 ) )


						def   _SCREAMING_SNAKE_CASE (	self       : Tuple )       ->				Dict:
							A  				=				self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
							A  				=				np.random.rand(100 ).astype(np.floataa )
							A  				=				np_audio_inputs.tolist()

							for inputs in [py_audio_inputs, np_audio_inputs]:
								A  				=				feature_extractor.pad([{'input_values': inputs}]					,return_tensors='np' )
								self.assertTrue(np_processed.input_values.dtype == np.floataa )
								A  				=				feature_extractor.pad([{'input_values': inputs}]					,return_tensors='pt' )
								self.assertTrue(pt_processed.input_values.dtype == torch.floataa )


						def   _SCREAMING_SNAKE_CASE (	self       : Optional[int]					,A_       : int )       ->				List[Any]:
							from datasets import load_dataset

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

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


						def   _SCREAMING_SNAKE_CASE (	self       : List[Any] )       ->				Optional[int]:
							# fmt: off
							A  				=				torch.tensor(
							    [2.3_804e-03, 2.0_752e-03, 1.9_836e-03, 2.1_057e-03, 1.6_174e-03,
							     3.0_518e-04, 9.1_553e-05, 3.3_569e-04, 9.7_656e-04, 1.8_311e-03,
							     2.0_142e-03, 2.1_057e-03, 1.7_395e-03, 4.5_776e-04, -3.9_673e-04,
							     4.5_776e-04, 1.0_071e-03, 9.1_553e-05, 4.8_828e-04, 1.1_597e-03,
							     7.3_242e-04, 9.4_604e-04, 1.8_005e-03, 1.8_311e-03, 8.8_501e-04,
							     4.2_725e-04, 4.8_828e-04, 7.3_242e-04, 1.0_986e-03, 2.1_057e-03] )
							# fmt: on
							A  				=				self._load_datasamples(1 )
							A  				=				EncodecFeatureExtractor()
							A  				=				feature_extractor(A_					,return_tensors='pt' ).input_values
							self.assertEquals(input_values.shape					,(1, 1, 9_3680) )
							self.assertTrue(torch.allclose(input_values[0, 0, :30]					,A_					,atol=1e-6 ) )


						def   _SCREAMING_SNAKE_CASE (	self       : Union[str, Any] )       ->				List[Any]:
							# fmt: off
							A  				=				torch.tensor(
							    [2.3_804e-03, 2.0_752e-03, 1.9_836e-03, 2.1_057e-03, 1.6_174e-03,
							     3.0_518e-04, 9.1_553e-05, 3.3_569e-04, 9.7_656e-04, 1.8_311e-03,
							     2.0_142e-03, 2.1_057e-03, 1.7_395e-03, 4.5_776e-04, -3.9_673e-04,
							     4.5_776e-04, 1.0_071e-03, 9.1_553e-05, 4.8_828e-04, 1.1_597e-03,
							     7.3_242e-04, 9.4_604e-04, 1.8_005e-03, 1.8_311e-03, 8.8_501e-04,
							     4.2_725e-04, 4.8_828e-04, 7.3_242e-04, 1.0_986e-03, 2.1_057e-03] )
							# fmt: on
							A  				=				self._load_datasamples(1 )
							A  				=				[np.tile(input_audio[0][None]					,reps=(2, 1) )]
							input_audio[0][1] *= 0.5
							A  				=				EncodecFeatureExtractor(feature_size=2 )
							A  				=				feature_extractor(A_					,return_tensors='pt' ).input_values
							self.assertEquals(input_values.shape					,(1, 2, 9_3680) )
							self.assertTrue(torch.allclose(input_values[0, 0, :30]					,A_					,atol=1e-6 ) )
							self.assertTrue(torch.allclose(input_values[0, 1, :30]					,EXPECTED_INPUT_VALUES * 0.5					,atol=1e-6 ) )




						def   _SCREAMING_SNAKE_CASE (	self       : Dict )       ->				List[str]:
							A  				=				self._load_datasamples(2 )
							# would be easier if the stride was like
							A  				=				EncodecFeatureExtractor(feature_size=1					,chunk_length_s=1					,overlap=0.01 )

							# pad and trunc raise an error ?
							with self.assertRaisesRegex(
							    A_					,'^Both padding and truncation were set. Make sure you only set one.$'					,):
								A  				=				feature_extractor(
								    A_					,padding='max_length'					,truncation=A_					,return_tensors='pt' ).input_values

							# truncate to chunk
							A  				=				feature_extractor(A_					,truncation=A_					,return_tensors='pt' ).input_values
							self.assertEquals(truncated_outputs.shape					,(2, 1, 7_1520) )  # 2 chunks

							# force truncate to max_length
							A  				=				feature_extractor(
							    A_					,truncation=A_					,max_length=4_8000					,return_tensors='pt' ).input_values
							self.assertEquals(truncated_outputs.shape					,(2, 1, 4_8000) )

							# pad to chunk
							A  				=				feature_extractor(A_					,padding=A_					,return_tensors='pt' ).input_values
							self.assertEquals(padded_outputs.shape					,(2, 1, 9_5280) )

							# pad to chunk
							A  				=				feature_extractor(A_					,return_tensors='pt' ).input_values
							self.assertEquals(truncated_outputs.shape					,(2, 1, 9_5280) )

							# force pad to max length
							A  				=				feature_extractor(
							    A_					,padding='max_length'					,max_length=10_0000					,return_tensors='pt' ).input_values
							self.assertEquals(truncated_outputs.shape					,(2, 1, 10_0000) )

							# force no pad
							with self.assertRaisesRegex(
							    A_					,'^Unable to create tensor, you should probably activate padding with \'padding=True\' to have batched tensors with the same length.$'					,):
								A  				=				feature_extractor(A_					,padding=A_					,return_tensors='pt' ).input_values

							A  				=				feature_extractor(input_audio[0]					,padding=A_					,return_tensors='pt' ).input_values
							self.assertEquals(truncated_outputs.shape					,(1, 1, 9_3680) )

							# no pad if no chunk_length_s
							A  				=				None
							with self.assertRaisesRegex(
							    A_					,'^Unable to create tensor, you should probably activate padding with \'padding=True\' to have batched tensors with the same length.$'					,):
								A  				=				feature_extractor(A_					,padding=A_					,return_tensors='pt' ).input_values

							A  				=				feature_extractor(input_audio[0]					,padding=A_					,return_tensors='pt' ).input_values
							self.assertEquals(truncated_outputs.shape					,(1, 1, 9_3680) )

							# no pad if no overlap
							A  				=				2
							A  				=				None
							with self.assertRaisesRegex(
							    A_					,'^Unable to create tensor, you should probably activate padding with \'padding=True\' to have batched tensors with the same length.$'					,):
								A  				=				feature_extractor(A_					,padding=A_					,return_tensors='pt' ).input_values

							A  				=				feature_extractor(input_audio[0]					,padding=A_					,return_tensors='pt' ).input_values
							self.assertEquals(truncated_outputs.shape					,(1, 1, 9_3680) )