



'''simple docstring'''



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

lowerCAmelCase_     :       str								=						random.Random()
def 					UpperCAmelCase   (						A  :				int					,		A  :				List[str]=1.0					,		A  :				Any=None					,		A  :				int=None				):
							if rng is None:
														SCREAMING_SNAKE_CASE					:      str     					=			global_rng

							SCREAMING_SNAKE_CASE					:      Tuple     					=			[]
							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 	lowerCamelCase_							(					unittest.TestCase			):







						def __init__(  self   :      Union[str, Any]				,    lowerCAmelCase__   :      str				,    lowerCAmelCase__   :      Optional[int]=7				,    lowerCAmelCase__   :      Tuple=4_00				,    lowerCAmelCase__   :      Dict=20_00				,    lowerCAmelCase__   :      List[Any]=24				,    lowerCAmelCase__   :      Tuple=24				,    lowerCAmelCase__   :      Dict=0.0				,    lowerCAmelCase__   :      Tuple=1_60_00				,    lowerCAmelCase__   :      Optional[Any]=True				,    lowerCAmelCase__   :      Any=True				,    ):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			parent
													SCREAMING_SNAKE_CASE					:      Dict     					=			batch_size
													SCREAMING_SNAKE_CASE					:      Dict     					=			min_seq_length
													SCREAMING_SNAKE_CASE					:      Tuple     					=			max_seq_length
													SCREAMING_SNAKE_CASE					:      str     					=			(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			feature_size
													SCREAMING_SNAKE_CASE					:      List[str]     					=			num_mel_bins
													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			padding_value
													SCREAMING_SNAKE_CASE					:      Any     					=			sampling_rate
													SCREAMING_SNAKE_CASE					:      List[str]     					=			return_attention_mask
													SCREAMING_SNAKE_CASE					:      Dict     					=			do_normalize







						def 					__lowercase    (  self   :      Optional[Any]				):

													"""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 					__lowercase    (  self   :      List[str]				,    lowerCAmelCase__   :      Optional[int]=False				,    lowerCAmelCase__   :      Any=False				):

													"""simple docstring"""
													def _flatten(lowerCAmelCase__   :      Any				):
																				return list(itertools.chain(*lowerCAmelCase__				)				)

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


@require_torch
@require_torchaudio
class 	lowerCamelCase_							(					snake_case_    ,				unittest.TestCase			):
						_lowerCAmelCase     :   Dict	     =				SpeechaTextFeatureExtractor if is_speech_available() else None







						def 					__lowercase    (  self   :      Optional[int]				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			SpeechaTextFeatureExtractionTester(self				)







						def 					__lowercase    (  self   :      List[str]				,    lowerCAmelCase__   :      List[str]				):

													"""simple docstring"""
													self.assertTrue(np.all(np.mean(lowerCAmelCase__				,    axis=0				) < 1e-3				)				)
													self.assertTrue(np.all(np.abs(np.var(lowerCAmelCase__				,    axis=0				) - 1				) < 1e-3				)				)







						def 					__lowercase    (  self   :      List[str]				):

													"""simple docstring"""
													# Tests that all call wrap to encode_plus and batch_encode_plus
													SCREAMING_SNAKE_CASE					:      str     					=			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()				)
													# create three inputs of length 800, 1000, and 1200
													SCREAMING_SNAKE_CASE					:      int     					=			[floats_list((1, x)				)[0] for x in range(8_00				,    14_00				,    2_00				)]
													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			[np.asarray(lowerCAmelCase__				) for speech_input in speech_inputs]

													# Test feature size
													SCREAMING_SNAKE_CASE					:      str     					=			feature_extractor(lowerCAmelCase__				,    padding=lowerCAmelCase__				,    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
													SCREAMING_SNAKE_CASE					:      Dict     					=			feature_extractor(speech_inputs[0]				,    return_tensors='''np'''				).input_features
													SCREAMING_SNAKE_CASE					:      int     					=			feature_extractor(np_speech_inputs[0]				,    return_tensors='''np'''				).input_features
													self.assertTrue(np.allclose(lowerCAmelCase__				,    lowerCAmelCase__				,    atol=1e-3				)				)

													# Test batched
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			feature_extractor(lowerCAmelCase__				,    return_tensors='''np'''				).input_features
													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			feature_extractor(lowerCAmelCase__				,    return_tensors='''np'''				).input_features
													for enc_seq_a, enc_seq_a in zip(lowerCAmelCase__				,    lowerCAmelCase__				):
																				self.assertTrue(np.allclose(lowerCAmelCase__				,    lowerCAmelCase__				,    atol=1e-3				)				)

													# Test 2-D numpy arrays are batched.
													SCREAMING_SNAKE_CASE					:      Tuple     					=			[floats_list((1, x)				)[0] for x in (8_00, 8_00, 8_00)]
													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			np.asarray(lowerCAmelCase__				)
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			feature_extractor(lowerCAmelCase__				,    return_tensors='''np'''				).input_features
													SCREAMING_SNAKE_CASE					:      Dict     					=			feature_extractor(lowerCAmelCase__				,    return_tensors='''np'''				).input_features
													for enc_seq_a, enc_seq_a in zip(lowerCAmelCase__				,    lowerCAmelCase__				):
																				self.assertTrue(np.allclose(lowerCAmelCase__				,    lowerCAmelCase__				,    atol=1e-3				)				)







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

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Tuple     					=			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()				)
													SCREAMING_SNAKE_CASE					:      int     					=			[floats_list((1, x)				)[0] for x in range(8_00				,    14_00				,    2_00				)]

													SCREAMING_SNAKE_CASE					:      List[Any]     					=			['''longest''', '''max_length''', '''do_not_pad''']
													SCREAMING_SNAKE_CASE					:      int     					=			[None, 16, None]
													for max_length, padding in zip(lowerCAmelCase__				,    lowerCAmelCase__				):
																				SCREAMING_SNAKE_CASE					:      Dict     					=			feature_extractor(
																				    lowerCAmelCase__				,    padding=lowerCAmelCase__				,    max_length=lowerCAmelCase__				,    return_attention_mask=lowerCAmelCase__				)
																				SCREAMING_SNAKE_CASE					:      int     					=			inputs.input_features
																				SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			inputs.attention_mask
																				SCREAMING_SNAKE_CASE					:      Tuple     					=			[np.sum(lowerCAmelCase__				) 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 					__lowercase    (  self   :      Optional[int]				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()				)
													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			[floats_list((1, x)				)[0] for x in range(8_00				,    14_00				,    2_00				)]

													SCREAMING_SNAKE_CASE					:      Dict     					=			['''longest''', '''max_length''', '''do_not_pad''']
													SCREAMING_SNAKE_CASE					:      Dict     					=			[None, 16, None]
													for max_length, padding in zip(lowerCAmelCase__				,    lowerCAmelCase__				):
																				SCREAMING_SNAKE_CASE					:      List[Any]     					=			feature_extractor(
																				    lowerCAmelCase__				,    max_length=lowerCAmelCase__				,    padding=lowerCAmelCase__				,    return_tensors='''np'''				,    return_attention_mask=lowerCAmelCase__				)
																				SCREAMING_SNAKE_CASE					:      str     					=			inputs.input_features
																				SCREAMING_SNAKE_CASE					:      Dict     					=			inputs.attention_mask
																				SCREAMING_SNAKE_CASE					:      int     					=			[np.sum(lowerCAmelCase__				) 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 					__lowercase    (  self   :      int				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()				)
													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			[floats_list((1, x)				)[0] for x in range(8_00				,    14_00				,    2_00				)]
													SCREAMING_SNAKE_CASE					:      str     					=			feature_extractor(
													    lowerCAmelCase__				,    padding='''max_length'''				,    max_length=4				,    truncation=lowerCAmelCase__				,    return_tensors='''np'''				,    return_attention_mask=lowerCAmelCase__				,    )
													SCREAMING_SNAKE_CASE					:      List[str]     					=			inputs.input_features
													SCREAMING_SNAKE_CASE					:      Any     					=			inputs.attention_mask
													SCREAMING_SNAKE_CASE					:      int     					=			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 					__lowercase    (  self   :      Tuple				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()				)
													SCREAMING_SNAKE_CASE					:      Dict     					=			[floats_list((1, x)				)[0] for x in range(8_00				,    14_00				,    2_00				)]
													SCREAMING_SNAKE_CASE					:      str     					=			feature_extractor(
													    lowerCAmelCase__				,    padding='''longest'''				,    max_length=4				,    truncation=lowerCAmelCase__				,    return_tensors='''np'''				,    return_attention_mask=lowerCAmelCase__				,    )
													SCREAMING_SNAKE_CASE					:      List[str]     					=			inputs.input_features
													SCREAMING_SNAKE_CASE					:      int     					=			inputs.attention_mask
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			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)				)

													SCREAMING_SNAKE_CASE					:      Tuple     					=			[floats_list((1, x)				)[0] for x in range(8_00				,    14_00				,    2_00				)]
													SCREAMING_SNAKE_CASE					:      Any     					=			feature_extractor(
													    lowerCAmelCase__				,    padding='''longest'''				,    max_length=16				,    truncation=lowerCAmelCase__				,    return_tensors='''np'''				,    return_attention_mask=lowerCAmelCase__				,    )
													SCREAMING_SNAKE_CASE					:      Tuple     					=			inputs.input_features
													SCREAMING_SNAKE_CASE					:      Any     					=			inputs.attention_mask
													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			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 					__lowercase    (  self   :      Optional[int]				):

													"""simple docstring"""
													import torch

													SCREAMING_SNAKE_CASE					:      List[str]     					=			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()				)
													SCREAMING_SNAKE_CASE					:      Dict     					=			np.random.rand(1_00				,    32				).astype(np.floataa				)
													SCREAMING_SNAKE_CASE					:      Tuple     					=			np_speech_inputs.tolist()

													for inputs in [py_speech_inputs, np_speech_inputs]:
																				SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			feature_extractor.pad([{'''input_features''': inputs}]				,    return_tensors='''np'''				)
																				self.assertTrue(np_processed.input_features.dtype == np.floataa				)
																				SCREAMING_SNAKE_CASE					:      Optional[int]     					=			feature_extractor.pad([{'''input_features''': inputs}]				,    return_tensors='''pt'''				)
																				self.assertTrue(pt_processed.input_features.dtype == torch.floataa				)







						def 					__lowercase    (  self   :      Tuple				,    lowerCAmelCase__   :      List[Any]				):

													"""simple docstring"""
													from datasets import load_dataset

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

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







						def 					__lowercase    (  self   :      List[str]				):

													"""simple docstring"""
													# fmt: off
													SCREAMING_SNAKE_CASE					:      Optional[int]     					=			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

													SCREAMING_SNAKE_CASE					:      Dict     					=			self._load_datasamples(1				)
													SCREAMING_SNAKE_CASE					:      Tuple     					=			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()				)
													SCREAMING_SNAKE_CASE					:      str     					=			feature_extractor(lowerCAmelCase__				,    return_tensors='''pt'''				).input_features
													self.assertEquals(input_features.shape				,    (1, 5_84, 24)				)
													self.assertTrue(np.allclose(input_features[0, 0, :30]				,    lowerCAmelCase__				,    atol=1e-4				)				)









'''simple docstring'''



import shutil
import tempfile
import unittest

from transformers import ClapFeatureExtractor, ClapProcessor, RobertaTokenizer, RobertaTokenizerFast
from transformers.testing_utils import require_sentencepiece, require_torchaudio

from .test_feature_extraction_clap import floats_list
@require_torchaudio
@require_sentencepiece
class 	lowerCamelCase_							(					unittest.TestCase			):







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

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      int     					=			'''laion/clap-htsat-unfused'''
													SCREAMING_SNAKE_CASE					:      Tuple     					=			tempfile.mkdtemp()







						def 					__lowercase    (  self   :      Tuple				,    **lowerCAmelCase__   :      Dict				):

													"""simple docstring"""
													return RobertaTokenizer.from_pretrained(self.checkpoint				,    **lowerCAmelCase__				)







						def 					__lowercase    (  self   :      int				,    **lowerCAmelCase__   :      str				):

													"""simple docstring"""
													return ClapFeatureExtractor.from_pretrained(self.checkpoint				,    **lowerCAmelCase__				)







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

													"""simple docstring"""
													shutil.rmtree(self.tmpdirname				)







						def 					__lowercase    (  self   :      Dict				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      List[str]     					=			self.get_tokenizer()
													SCREAMING_SNAKE_CASE					:      Optional[int]     					=			self.get_feature_extractor()

													SCREAMING_SNAKE_CASE					:      List[str]     					=			ClapProcessor(tokenizer=lowerCAmelCase__				,    feature_extractor=lowerCAmelCase__				)

													processor.save_pretrained(self.tmpdirname				)
													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			ClapProcessor.from_pretrained(self.tmpdirname				)

													self.assertEqual(processor.tokenizer.get_vocab()				,    tokenizer.get_vocab()				)
													self.assertIsInstance(processor.tokenizer				,    lowerCAmelCase__				)

													self.assertEqual(processor.feature_extractor.to_json_string()				,    feature_extractor.to_json_string()				)
													self.assertIsInstance(processor.feature_extractor				,    lowerCAmelCase__				)







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

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Dict     					=			ClapProcessor(tokenizer=self.get_tokenizer()				,    feature_extractor=self.get_feature_extractor()				)
													processor.save_pretrained(self.tmpdirname				)

													SCREAMING_SNAKE_CASE					:      List[Any]     					=			self.get_tokenizer(bos_token='''(BOS)'''				,    eos_token='''(EOS)'''				)
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			self.get_feature_extractor(do_normalize=lowerCAmelCase__				,    padding_value=1.0				)

													SCREAMING_SNAKE_CASE					:      str     					=			ClapProcessor.from_pretrained(
													    self.tmpdirname				,    bos_token='''(BOS)'''				,    eos_token='''(EOS)'''				,    do_normalize=lowerCAmelCase__				,    padding_value=1.0				)

													self.assertEqual(processor.tokenizer.get_vocab()				,    tokenizer_add_kwargs.get_vocab()				)
													self.assertIsInstance(processor.tokenizer				,    lowerCAmelCase__				)

													self.assertEqual(processor.feature_extractor.to_json_string()				,    feature_extractor_add_kwargs.to_json_string()				)
													self.assertIsInstance(processor.feature_extractor				,    lowerCAmelCase__				)







						def 					__lowercase    (  self   :      Dict				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			self.get_feature_extractor()
													SCREAMING_SNAKE_CASE					:      Tuple     					=			self.get_tokenizer()

													SCREAMING_SNAKE_CASE					:      Tuple     					=			ClapProcessor(tokenizer=lowerCAmelCase__				,    feature_extractor=lowerCAmelCase__				)

													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			floats_list((3, 10_00)				)

													SCREAMING_SNAKE_CASE					:      Any     					=			feature_extractor(lowerCAmelCase__				,    return_tensors='''np'''				)
													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			processor(audios=lowerCAmelCase__				,    return_tensors='''np'''				)

													for key in input_feat_extract.keys():
																				self.assertAlmostEqual(input_feat_extract[key].sum()				,    input_processor[key].sum()				,    delta=1e-2				)







						def 					__lowercase    (  self   :      Any				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Tuple     					=			self.get_feature_extractor()
													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			self.get_tokenizer()

													SCREAMING_SNAKE_CASE					:      Optional[int]     					=			ClapProcessor(tokenizer=lowerCAmelCase__				,    feature_extractor=lowerCAmelCase__				)

													SCREAMING_SNAKE_CASE					:      int     					=			'''This is a test string'''

													SCREAMING_SNAKE_CASE					:      int     					=			processor(text=lowerCAmelCase__				)

													SCREAMING_SNAKE_CASE					:      Optional[int]     					=			tokenizer(lowerCAmelCase__				)

													for key in encoded_tok.keys():
																				self.assertListEqual(encoded_tok[key]				,    encoded_processor[key]				)







						def 					__lowercase    (  self   :      Optional[Any]				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      str     					=			self.get_feature_extractor()
													SCREAMING_SNAKE_CASE					:      List[str]     					=			self.get_tokenizer()

													SCREAMING_SNAKE_CASE					:      Any     					=			ClapProcessor(tokenizer=lowerCAmelCase__				,    feature_extractor=lowerCAmelCase__				)

													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

													SCREAMING_SNAKE_CASE					:      Tuple     					=			processor.batch_decode(lowerCAmelCase__				)
													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			tokenizer.batch_decode(lowerCAmelCase__				)

													self.assertListEqual(lowerCAmelCase__				,    lowerCAmelCase__				)







						def 					__lowercase    (  self   :      Optional[Any]				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			self.get_feature_extractor()
													SCREAMING_SNAKE_CASE					:      str     					=			self.get_tokenizer()

													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			ClapProcessor(tokenizer=lowerCAmelCase__				,    feature_extractor=lowerCAmelCase__				)

													self.assertListEqual(
													    processor.model_input_names[2:]				,    feature_extractor.model_input_names				,    msg='''`processor` and `feature_extractor` model input names do not match'''				,    )




