


'''simple docstring'''



import gc
import unittest

from transformers import CTRLConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
		import torch

		from transformers import (
		    CTRL_PRETRAINED_MODEL_ARCHIVE_LIST,
		    CTRLForSequenceClassification,
		    CTRLLMHeadModel,
		    CTRLModel,
		)


class 		_snake_case					:




					def __init__(      self							,							_lowerCamelCase							,							_lowerCamelCase=14							,							_lowerCamelCase=7							,							_lowerCamelCase=True							,							_lowerCamelCase=True							,							_lowerCamelCase=True							,							_lowerCamelCase=True							,							_lowerCamelCase=True							,							_lowerCamelCase=99							,							_lowerCamelCase=32							,							_lowerCamelCase=5							,							_lowerCamelCase=4							,							_lowerCamelCase=37							,							_lowerCamelCase="gelu"							,							_lowerCamelCase=0.1							,							_lowerCamelCase=0.1							,							_lowerCamelCase=512							,							_lowerCamelCase=16							,							_lowerCamelCase=2							,							_lowerCamelCase=0.02							,							_lowerCamelCase=3							,							_lowerCamelCase=4							,							_lowerCamelCase=None							,							):
								UpperCAmelCase__  :					str        =				parent
								UpperCAmelCase__  :					Any        =				batch_size
								UpperCAmelCase__  :					Union[str, Any]        =				seq_length
								UpperCAmelCase__  :					List[str]        =				is_training
								UpperCAmelCase__  :					Tuple        =				use_token_type_ids
								UpperCAmelCase__  :					List[Any]        =				use_input_mask
								UpperCAmelCase__  :					Dict        =				use_labels
								UpperCAmelCase__  :					Union[str, Any]        =				use_mc_token_ids
								UpperCAmelCase__  :					Optional[Any]        =				vocab_size
								UpperCAmelCase__  :					Dict        =				hidden_size
								UpperCAmelCase__  :					Optional[Any]        =				num_hidden_layers
								UpperCAmelCase__  :					int        =				num_attention_heads
								UpperCAmelCase__  :					str        =				intermediate_size
								UpperCAmelCase__  :					List[Any]        =				hidden_act
								UpperCAmelCase__  :					int        =				hidden_dropout_prob
								UpperCAmelCase__  :					int        =				attention_probs_dropout_prob
								UpperCAmelCase__  :					Tuple        =				max_position_embeddings
								UpperCAmelCase__  :					Union[str, Any]        =				type_vocab_size
								UpperCAmelCase__  :					str        =				type_sequence_label_size
								UpperCAmelCase__  :					Union[str, Any]        =				initializer_range
								UpperCAmelCase__  :					Optional[Any]        =				num_labels
								UpperCAmelCase__  :					int        =				num_choices
								UpperCAmelCase__  :					List[str]        =				scope
								UpperCAmelCase__  :					int        =				self.vocab_size - 1




					def 				snake_case__						(      self):
								UpperCAmelCase__  :					int        =				ids_tensor([self.batch_size, self.seq_length]							,							self.vocab_size)

								UpperCAmelCase__  :					Union[str, Any]        =				None
								if self.use_input_mask:
											UpperCAmelCase__  :					int        =				random_attention_mask([self.batch_size, self.seq_length])

								UpperCAmelCase__  :					str        =				None
								if self.use_token_type_ids:
											UpperCAmelCase__  :					Dict        =				ids_tensor([self.batch_size, self.seq_length]							,							self.type_vocab_size)

								UpperCAmelCase__  :					str        =				None
								if self.use_mc_token_ids:
											UpperCAmelCase__  :					List[Any]        =				ids_tensor([self.batch_size, self.num_choices]							,							self.seq_length)

								UpperCAmelCase__  :					Any        =				None
								UpperCAmelCase__  :					Union[str, Any]        =				None
								UpperCAmelCase__  :					Optional[Any]        =				None
								if self.use_labels:
											UpperCAmelCase__  :					Optional[Any]        =				ids_tensor([self.batch_size]							,							self.type_sequence_label_size)
											UpperCAmelCase__  :					Any        =				ids_tensor([self.batch_size, self.seq_length]							,							self.num_labels)
											UpperCAmelCase__  :					int        =				ids_tensor([self.batch_size]							,							self.num_choices)

								UpperCAmelCase__  :					Any        =				self.get_config()

								UpperCAmelCase__  :					Any        =				ids_tensor([self.num_hidden_layers, self.num_attention_heads]							,							2)

								return (
								    config,
								    input_ids,
								    input_mask,
								    head_mask,
								    token_type_ids,
								    mc_token_ids,
								    sequence_labels,
								    token_labels,
								    choice_labels,
								)




					def 				snake_case__						(      self):
								return CTRLConfig(
								    vocab_size=self.vocab_size							,							n_embd=self.hidden_size							,							n_layer=self.num_hidden_layers							,							n_head=self.num_attention_heads							,							n_positions=self.max_position_embeddings							,							pad_token_id=self.pad_token_id							,							)




					def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							*_lowerCamelCase):
								UpperCAmelCase__  :					List[Any]        =				CTRLModel(config=UpperCamelCase_)
								model.to(UpperCamelCase_)
								model.eval()

								model(UpperCamelCase_							,							token_type_ids=UpperCamelCase_							,							head_mask=UpperCamelCase_)
								model(UpperCamelCase_							,							token_type_ids=UpperCamelCase_)
								UpperCAmelCase__  :					Optional[Any]        =				model(UpperCamelCase_)
								self.parent.assertEqual(result.last_hidden_state.shape							,							(self.batch_size, self.seq_length, self.hidden_size))
								self.parent.assertEqual(len(result.past_key_values)							,							config.n_layer)




					def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							*_lowerCamelCase):
								UpperCAmelCase__  :					Union[str, Any]        =				CTRLLMHeadModel(UpperCamelCase_)
								model.to(UpperCamelCase_)
								model.eval()

								UpperCAmelCase__  :					Optional[int]        =				model(UpperCamelCase_							,							token_type_ids=UpperCamelCase_							,							labels=UpperCamelCase_)
								self.parent.assertEqual(result.loss.shape							,							())
								self.parent.assertEqual(result.logits.shape							,							(self.batch_size, self.seq_length, self.vocab_size))




					def 				snake_case__						(      self):
								UpperCAmelCase__  :					List[str]        =				self.prepare_config_and_inputs()

								(
								    (
								    UpperCAmelCase__     
								)   ,       (
								    UpperCAmelCase__     
								)   ,       (
								    UpperCAmelCase__     
								)   ,       (
								    UpperCAmelCase__     
								)   ,       (
								    UpperCAmelCase__     
								)   ,       (
								    UpperCAmelCase__     
								)   ,       (
								    UpperCAmelCase__     
								)   ,       (
								    UpperCAmelCase__     
								)   ,       (
								    UpperCAmelCase__     
								)   ,            
								)  :					Any        =				config_and_inputs

								UpperCAmelCase__  :					List[str]        =				{"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """head_mask""": head_mask}

								return config, inputs_dict




					def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							*_lowerCamelCase):
								UpperCAmelCase__  :					Optional[Any]        =				self.num_labels
								UpperCAmelCase__  :					List[Any]        =				CTRLForSequenceClassification(UpperCamelCase_)
								model.to(UpperCamelCase_)
								model.eval()
								UpperCAmelCase__  :					Dict        =				ids_tensor([self.batch_size]							,							self.type_sequence_label_size)
								UpperCAmelCase__  :					str        =				model(UpperCamelCase_							,							token_type_ids=UpperCamelCase_							,							labels=UpperCamelCase_)
								self.parent.assertEqual(result.logits.shape							,							(self.batch_size, self.num_labels))


@require_torch
class 		_snake_case					(     __lowerCamelCase       ,   __lowerCamelCase       ,   __lowerCamelCase       ,   unittest.TestCase	):
					lowerCAmelCase      :Any   =					(CTRLModel, CTRLLMHeadModel, CTRLForSequenceClassification) if is_torch_available() else ()
					lowerCAmelCase      :Optional[Any]   =					(CTRLLMHeadModel,) if is_torch_available() else ()
					lowerCAmelCase      :int   =					(
					    {
					        'feature-extraction': CTRLModel,
					        'text-classification': CTRLForSequenceClassification,
					        'text-generation': CTRLLMHeadModel,
					        'zero-shot': CTRLForSequenceClassification,
					    }
					    if is_torch_available()
					    else {}
					)
					lowerCAmelCase      :List[str]   =					True
					lowerCAmelCase      :Optional[Any]   =					False
					lowerCAmelCase      :Optional[Any]   =					False




					def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase):
								if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests":
											# Get `tokenizer does not have a padding token` error for both fast/slow tokenizers.
											# `CTRLConfig` was never used in pipeline tests, either because of a missing checkpoint or because a tiny
											# config could not be created.
											return True

								return False




					def 				snake_case__						(      self):
								UpperCAmelCase__  :					Union[str, Any]        =				CTRLModelTester(self)
								UpperCAmelCase__  :					Dict        =				ConfigTester(self							,							config_class=UpperCamelCase_							,							n_embd=37)




					def 				snake_case__						(      self):
								super().tearDown()
								# clean-up as much as possible GPU memory occupied by PyTorch
								gc.collect()
								torch.cuda.empty_cache()




					def 				snake_case__						(      self):
								self.config_tester.run_common_tests()




					def 				snake_case__						(      self):
								UpperCAmelCase__  :					Any        =				self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_ctrl_model(*UpperCamelCase_)




					def 				snake_case__						(      self):
								UpperCAmelCase__  :					Tuple        =				self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_lm_head_model(*UpperCamelCase_)




					@unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests.""")
					def 				snake_case__						(      self):
								pass




					@slow
					def 				snake_case__						(      self):
								for model_name in CTRL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											UpperCAmelCase__  :					str        =				CTRLModel.from_pretrained(UpperCamelCase_)
											self.assertIsNotNone(UpperCamelCase_)




					@unittest.skip("""The model doesn't support left padding""")  # and it's not used enough to be worth fixing :)
					def 				snake_case__						(      self):
								pass


@require_torch
class 		_snake_case					(     unittest.TestCase	):




					def 				snake_case__						(      self):
								super().tearDown()
								# clean-up as much as possible GPU memory occupied by PyTorch
								gc.collect()
								torch.cuda.empty_cache()




					@slow
					def 				snake_case__						(      self):
								UpperCAmelCase__  :					Optional[int]        =				CTRLLMHeadModel.from_pretrained("""ctrl""")
								model.to(UpperCamelCase_)
								UpperCAmelCase__  :					Optional[int]        =				torch.tensor(
								    [[1_1859, 0, 1611, 8]]							,							dtype=torch.long							,							device=UpperCamelCase_)  # Legal the president is
								UpperCAmelCase__  :					Union[str, Any]        =				[
								    1_1859,
								    0,
								    1611,
								    8,
								    5,
								    150,
								    2_6449,
								    2,
								    19,
								    348,
								    469,
								    3,
								    2595,
								    48,
								    2_0740,
								    24_6533,
								    24_6533,
								    19,
								    30,
								    5,
								]  # Legal the president is a good guy and I don't want to lose my job. \n \n I have a

								UpperCAmelCase__  :					List[str]        =				model.generate(UpperCamelCase_							,							do_sample=UpperCamelCase_)
								self.assertListEqual(output_ids[0].tolist()							,							UpperCamelCase_)



'''simple docstring'''



import copy
from typing import Any, Dict, List, Optional, Union

import numpy as np
import torch

from ...audio_utils import mel_filter_bank, spectrogram, window_function
from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import TensorType, logging


__A	=logging.get_logger(__name__)


class 		_snake_case					(     a__	):
					lowerCAmelCase      :int   =					['''input_features''', '''is_longer''']




					def __init__(      self							,							_lowerCamelCase=64							,							_lowerCamelCase=4_8000							,							_lowerCamelCase=480							,							_lowerCamelCase=10							,							_lowerCamelCase=1024							,							_lowerCamelCase=0.0							,							_lowerCamelCase=False							,							_lowerCamelCase = 0							,							_lowerCamelCase = 1_4000							,							_lowerCamelCase = None							,							_lowerCamelCase = "fusion"							,							_lowerCamelCase = "repeatpad"							,							**_lowerCamelCase							,							):
								super().__init__(
								    feature_size=_lowerCamelCase							,							sampling_rate=_lowerCamelCase							,							padding_value=_lowerCamelCase							,							return_attention_mask=_lowerCamelCase							,							**_lowerCamelCase							,							)
								UpperCAmelCase__  :					Dict        =     top_db
								UpperCAmelCase__  :					int        =     truncation
								UpperCAmelCase__  :					Optional[Any]        =     padding
								UpperCAmelCase__  :					Union[str, Any]        =     fft_window_size
								UpperCAmelCase__  :					List[Any]        =     (fft_window_size >> 1) + 1
								UpperCAmelCase__  :					Optional[int]        =     hop_length
								UpperCAmelCase__  :					int        =     max_length_s
								UpperCAmelCase__  :					Tuple        =     max_length_s * sampling_rate
								UpperCAmelCase__  :					List[Any]        =     sampling_rate
								UpperCAmelCase__  :					Tuple        =     frequency_min
								UpperCAmelCase__  :					Dict        =     frequency_max
								UpperCAmelCase__  :					Union[str, Any]        =     mel_filter_bank(
								    num_frequency_bins=self.nb_frequency_bins							,							num_mel_filters=_lowerCamelCase							,							min_frequency=_lowerCamelCase							,							max_frequency=_lowerCamelCase							,							sampling_rate=_lowerCamelCase							,							norm=_lowerCamelCase							,							mel_scale="""htk"""							,							)
								UpperCAmelCase__  :					Optional[int]        =     mel_filter_bank(
								    num_frequency_bins=self.nb_frequency_bins							,							num_mel_filters=_lowerCamelCase							,							min_frequency=_lowerCamelCase							,							max_frequency=_lowerCamelCase							,							sampling_rate=_lowerCamelCase							,							norm="""slaney"""							,							mel_scale="""slaney"""							,							)




					def 				snake_case__						(      self):
								UpperCAmelCase__  :					List[Any]        =     copy.deepcopy(self.__dict__)
								UpperCAmelCase__  :					Optional[int]        =     self.__class__.__name__
								if "mel_filters" in output:
											del output["mel_filters"]
								if "mel_filters_slaney" in output:
											del output["mel_filters_slaney"]
								return output




					def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase = None):
								UpperCAmelCase__  :					str        =     spectrogram(
								    _lowerCamelCase							,							window_function(self.fft_window_size							,							"""hann""")							,							frame_length=self.fft_window_size							,							hop_length=self.hop_length							,							power=2.0							,							mel_filters=_lowerCamelCase							,							log_mel="""dB"""							,							)
								return log_mel_spectrogram.T




					def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase):
								UpperCAmelCase__  :					List[str]        =     np.array_split(list(range(0							,							total_frames - chunk_frames + 1))							,							3)
								if len(ranges[1]) == 0:
											# if the audio is too short, we just use the first chunk
											UpperCAmelCase__  :					List[Any]        =     [0]
								if len(ranges[2]) == 0:
											# if the audio is too short, we just use the first chunk
											UpperCAmelCase__  :					Union[str, Any]        =     [0]
								# randomly choose index for each part
								UpperCAmelCase__  :					List[str]        =     np.random.choice(ranges[0])
								UpperCAmelCase__  :					Optional[int]        =     np.random.choice(ranges[1])
								UpperCAmelCase__  :					List[str]        =     np.random.choice(ranges[2])

								UpperCAmelCase__  :					str        =     mel[idx_front : idx_front + chunk_frames, :]
								UpperCAmelCase__  :					Optional[int]        =     mel[idx_middle : idx_middle + chunk_frames, :]
								UpperCAmelCase__  :					Tuple        =     mel[idx_back : idx_back + chunk_frames, :]

								UpperCAmelCase__  :					int        =     torch.tensor(mel[None, None, :])
								UpperCAmelCase__  :					Optional[int]        =     torch.nn.functional.interpolate(
								    _lowerCamelCase							,							size=[chunk_frames, 64]							,							mode="""bilinear"""							,							align_corners=_lowerCamelCase)
								UpperCAmelCase__  :					Union[str, Any]        =     mel_shrink[0][0].numpy()
								UpperCAmelCase__  :					Optional[Any]        =     np.stack([mel_shrink, mel_chunk_front, mel_chunk_middle, mel_chunk_back]							,							axis=0)
								return mel_fusion




					def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase):
								if waveform.shape[0] > max_length:
											if truncation == "rand_trunc":
														UpperCAmelCase__  :					List[str]        =     True
														# random crop to max_length (for compatibility) -> this should be handled by self.pad
														UpperCAmelCase__  :					List[Any]        =     len(_lowerCamelCase) - max_length
														UpperCAmelCase__  :					Optional[Any]        =     np.random.randint(0							,							overflow + 1)
														UpperCAmelCase__  :					int        =     waveform[idx : idx + max_length]
														UpperCAmelCase__  :					Tuple        =     self._np_extract_fbank_features(_lowerCamelCase							,							self.mel_filters_slaney)[None, :]
											elif truncation == "fusion":
														UpperCAmelCase__  :					Any        =     self._np_extract_fbank_features(_lowerCamelCase							,							self.mel_filters)
														UpperCAmelCase__  :					int        =     max_length // self.hop_length + 1  # the +1 related to how the spectrogram is computed
														UpperCAmelCase__  :					int        =     mel.shape[0]
														if chunk_frames == total_frames:
																	# there is a corner case where the audio length is larger than max_length but smaller than max_length+hop_length.
																	# In this case, we just use the whole audio.
																	UpperCAmelCase__  :					Optional[Any]        =     np.stack([mel, mel, mel, mel]							,							axis=0)
																	UpperCAmelCase__  :					List[Any]        =     False
														else:
																	UpperCAmelCase__  :					Tuple        =     self._random_mel_fusion(_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase)
																	UpperCAmelCase__  :					str        =     True
											else:
														raise NotImplementedError(f'''data_truncating {truncation} not implemented''')

								else:
											UpperCAmelCase__  :					str        =     False
											# only use repeat as a new possible value for padding. you repeat the audio before applying the usual max_length padding
											if waveform.shape[0] < max_length:
														if padding == "repeat":
																	UpperCAmelCase__  :					int        =     int(max_length / len(_lowerCamelCase))
																	UpperCAmelCase__  :					int        =     np.stack(np.tile(_lowerCamelCase							,							n_repeat + 1))[:max_length]
														if padding == "repeatpad":
																	UpperCAmelCase__  :					str        =     int(max_length / len(_lowerCamelCase))
																	UpperCAmelCase__  :					str        =     np.stack(np.tile(_lowerCamelCase							,							_lowerCamelCase))
														UpperCAmelCase__  :					Optional[Any]        =     np.pad(_lowerCamelCase							,							(0, max_length - waveform.shape[0])							,							mode="""constant"""							,							constant_values=0)

											if truncation == "fusion":
														UpperCAmelCase__  :					List[Any]        =     self._np_extract_fbank_features(_lowerCamelCase							,							self.mel_filters)
														UpperCAmelCase__  :					Dict        =     np.stack([input_mel, input_mel, input_mel, input_mel]							,							axis=0)
											else:
														UpperCAmelCase__  :					int        =     self._np_extract_fbank_features(_lowerCamelCase							,							self.mel_filters_slaney)[None, :]

								return input_mel, longer




					def __call__(      self							,							_lowerCamelCase							,							_lowerCamelCase = None							,							_lowerCamelCase = None							,							_lowerCamelCase = None							,							_lowerCamelCase = None							,							_lowerCamelCase = None							,							**_lowerCamelCase							,							):
								UpperCAmelCase__  :					Dict        =     truncation if truncation is not None else self.truncation
								UpperCAmelCase__  :					List[Any]        =     padding if padding else self.padding

								if sampling_rate is not None:
											if sampling_rate != self.sampling_rate:
														raise ValueError(
														    f'''The model corresponding to this feature extractor: {self.__class__.__name__} was trained using a'''
														    f''' sampling rate of {self.sampling_rate}. Please make sure that the provided `raw_speech` input'''
														    f''' was sampled with {self.sampling_rate} and not {sampling_rate}.''')
								else:
											logger.warning(
											    """It is strongly recommended to pass the `sampling_rate` argument to this function. """
											    """Failing to do so can result in silent errors that might be hard to debug.""")

								UpperCAmelCase__  :					int        =     isinstance(_lowerCamelCase							,							np.ndarray) and len(raw_speech.shape) > 1
								if is_batched_numpy and len(raw_speech.shape) > 2:
											raise ValueError(f'''Only mono-channel audio is supported for input to {self}''')
								UpperCAmelCase__  :					List[str]        =     is_batched_numpy or (
								    isinstance(_lowerCamelCase							,							(list, tuple)) and (isinstance(raw_speech[0]							,							(np.ndarray, tuple, list)))
								)

								if is_batched:
											UpperCAmelCase__  :					str        =     [np.asarray(_lowerCamelCase							,							dtype=np.floataa) for speech in raw_speech]
								elif not is_batched and not isinstance(_lowerCamelCase							,							np.ndarray):
											UpperCAmelCase__  :					Optional[int]        =     np.asarray(_lowerCamelCase							,							dtype=np.floataa)
								elif isinstance(_lowerCamelCase							,							np.ndarray) and raw_speech.dtype is np.dtype(np.floataa):
											UpperCAmelCase__  :					str        =     raw_speech.astype(np.floataa)

								# always return batch
								if not is_batched:
											UpperCAmelCase__  :					int        =     [np.asarray(_lowerCamelCase)]

								# convert to mel spectrogram, truncate and pad if needed.
								UpperCAmelCase__  :					int        =     [
								    self._get_input_mel(_lowerCamelCase							,							max_length if max_length else self.nb_max_samples							,							_lowerCamelCase							,							_lowerCamelCase)
								    for waveform in raw_speech
								]

								UpperCAmelCase__  :					int        =     []
								UpperCAmelCase__  :					List[str]        =     []
								for mel, longer in padded_inputs:
											input_mel.append(_lowerCamelCase)
											is_longer.append(_lowerCamelCase)

								if truncation == "fusion" and sum(_lowerCamelCase) == 0:
											# if no audio is longer than 10s, then randomly select one audio to be longer
											UpperCAmelCase__  :					Optional[int]        =     np.random.randint(0							,							len(_lowerCamelCase))
											UpperCAmelCase__  :					Tuple        =     True

								if isinstance(input_mel[0]							,							_lowerCamelCase):
											UpperCAmelCase__  :					str        =     [np.asarray(_lowerCamelCase							,							dtype=np.floataa) for feature in input_mel]

								# is_longer is a list of bool
								UpperCAmelCase__  :					str        =     [[longer] for longer in is_longer]

								UpperCAmelCase__  :					Optional[int]        =     {"""input_features""": input_mel, """is_longer""": is_longer}
								UpperCAmelCase__  :					Optional[int]        =     BatchFeature(_lowerCamelCase)

								if return_tensors is not None:
											UpperCAmelCase__  :					str        =     input_features.convert_to_tensors(_lowerCamelCase)

								return input_features