




import copy
import inspect
import unittest

from transformers import PretrainedConfig, SwiftFormerConfig
from transformers.testing_utils import (
    require_torch,
    require_vision,
    slow,
    torch_device,
)
from transformers.utils import cached_property, is_torch_available, is_vision_available

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


if is_torch_available():
					import torch
					from torch import nn

					from transformers import SwiftFormerForImageClassification, SwiftFormerModel
					from transformers.models.swiftformer.modeling_swiftformer import SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
					from PIL import Image

					from transformers import ViTImageProcessor







class     __lowerCAmelCase :

			"""simple docstring"""







			def __init__(      self			,						lowerCamelCase__			,						lowerCamelCase__=13			,						lowerCamelCase__=3			,						lowerCamelCase__=True			,						lowerCamelCase__=True			,						lowerCamelCase__=0.1			,						lowerCamelCase__=0.1			,						lowerCamelCase__=224			,						lowerCamelCase__=1_000			,						lowerCamelCase__=[3, 3, 6, 4]			,						lowerCamelCase__=[48, 56, 112, 220]			,						)    ->      Tuple:



							'''simple docstring'''
							__lowerCamelCase		       =    parent
							__lowerCamelCase		       =    batch_size
							__lowerCamelCase		       =    num_channels
							__lowerCamelCase		       =    is_training
							__lowerCamelCase		       =    use_labels
							__lowerCamelCase		       =    hidden_dropout_prob
							__lowerCamelCase		       =    attention_probs_dropout_prob
							__lowerCamelCase		       =    num_labels
							__lowerCamelCase		       =    image_size
							__lowerCamelCase		       =    layer_depths
							__lowerCamelCase		       =    embed_dims


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



							'''simple docstring'''
							__lowerCamelCase		       =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

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

							__lowerCamelCase		       =    self.get_config()

							return config, pixel_values, labels


			def       lowercase_    (      self							)    ->      int:



							'''simple docstring'''
							return SwiftFormerConfig(
							    depths=self.layer_depths			,						embed_dims=self.embed_dims			,						mlp_ratio=4			,						downsamples=[True, True, True, True]			,						hidden_act='gelu'			,						num_labels=self.num_labels			,						down_patch_size=3			,						down_stride=2			,						down_pad=1			,						drop_rate=0.0			,						drop_path_rate=0.0			,						use_layer_scale=lowerCamelCase__			,						layer_scale_init_value=1e-5			,						)


			def       lowercase_    (      self			,						lowerCamelCase__			,						lowerCamelCase__			,						lowerCamelCase__							)    ->      List[Any]:



							'''simple docstring'''
							__lowerCamelCase		       =    SwiftFormerModel(config=lowerCamelCase__							)
							model.to(lowerCamelCase__							)
							model.eval()
							__lowerCamelCase		       =    model(lowerCamelCase__							)
							self.parent.assertEqual(result.last_hidden_state.shape			,						(self.batch_size, self.embed_dims[-1], 7, 7)							)


			def       lowercase_    (      self			,						lowerCamelCase__			,						lowerCamelCase__			,						lowerCamelCase__							)    ->      Dict:



							'''simple docstring'''
							__lowerCamelCase		       =    self.num_labels
							__lowerCamelCase		       =    SwiftFormerForImageClassification(lowerCamelCase__							)
							model.to(lowerCamelCase__							)
							model.eval()
							__lowerCamelCase		       =    model(lowerCamelCase__			,						labels=lowerCamelCase__							)
							self.parent.assertEqual(result.logits.shape			,						(self.batch_size, self.num_labels)							)

							__lowerCamelCase		       =    SwiftFormerForImageClassification(lowerCamelCase__							)
							model.to(lowerCamelCase__							)
							model.eval()

							__lowerCamelCase		       =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)
							__lowerCamelCase		       =    model(lowerCamelCase__							)
							self.parent.assertEqual(result.logits.shape			,						(self.batch_size, self.num_labels)							)






			def       lowercase_    (      self							)    ->      Dict:



							'''simple docstring'''
							((__lowerCamelCase)       ,						(__lowerCamelCase)       ,						(__lowerCamelCase))		       =    self.prepare_config_and_inputs()
							__lowerCamelCase		       =    {'pixel_values': pixel_values}
							return config, inputs_dict







@require_torch
class     __lowerCAmelCase (       __magic_name__			,				__magic_name__			,				unittest.TestCase ):

			"""simple docstring"""







			snake_case_   		=       (SwiftFormerModel, SwiftFormerForImageClassification) if is_torch_available() else ()
			snake_case_   		=       (
			    {'''feature-extraction''': SwiftFormerModel, '''image-classification''': SwiftFormerForImageClassification}
			    if is_torch_available()
			    else {}
			)

			snake_case_   		=       False
			snake_case_   		=       False
			snake_case_   		=       False
			snake_case_   		=       False
			snake_case_   		=       False


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



							'''simple docstring'''
							__lowerCamelCase		       =    SwiftFormerModelTester(self							)
							__lowerCamelCase		       =    ConfigTester(
							    self			,						config_class=lowerCamelCase__			,						has_text_modality=lowerCamelCase__			,						hidden_size=37			,						num_attention_heads=12			,						num_hidden_layers=12			,						)


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



							'''simple docstring'''
							self.config_tester.run_common_tests()


			@unittest.skip(reason='SwiftFormer does not use inputs_embeds'							)
			def       lowercase_    (      self							)    ->      List[Any]:



							'''simple docstring'''
							pass


			def       lowercase_    (      self							)    ->      int:



							'''simple docstring'''
							__lowerCamelCase       ,						__lowerCamelCase		       =    self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
											__lowerCamelCase		       =    model_class(lowerCamelCase__							)
											__lowerCamelCase		       =    model.get_output_embeddings()
											self.assertTrue(x is None or isinstance(lowerCamelCase__			,						nn.Linear							)							)


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



							'''simple docstring'''
							__lowerCamelCase       ,						__lowerCamelCase		       =    self.model_tester.prepare_config_and_inputs_for_common()

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

											__lowerCamelCase		       =    ['pixel_values']
											self.assertListEqual(arg_names[:1]			,						lowerCamelCase__							)


			def       lowercase_    (      self							)    ->      Dict:



							'''simple docstring'''
							__lowerCamelCase		       =    self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*lowerCamelCase__							)


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



							'''simple docstring'''
							__lowerCamelCase		       =    self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*lowerCamelCase__							)


			@slow
			def       lowercase_    (      self							)    ->      int:



							'''simple docstring'''
							for model_name in SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											__lowerCamelCase		       =    SwiftFormerModel.from_pretrained(lowerCamelCase__							)
											self.assertIsNotNone(lowerCamelCase__							)


			@unittest.skip(reason='SwiftFormer does not output attentions'							)
			def       lowercase_    (      self							)    ->      Dict:



							'''simple docstring'''
							pass


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



							'''simple docstring'''
							def check_hidden_states_output(lowerCamelCase__			,						lowerCamelCase__			,						lowerCamelCase__							):
											__lowerCamelCase		       =    model_class(lowerCamelCase__							)
											model.to(lowerCamelCase__							)
											model.eval()

											with torch.no_grad():
															__lowerCamelCase		       =    model(**self._prepare_for_class(lowerCamelCase__			,						lowerCamelCase__							)							)

											__lowerCamelCase		       =    outputs.hidden_states

											__lowerCamelCase		       =    8
											self.assertEqual(len(lowerCamelCase__							)			,						lowerCamelCase__							)  # TODO

											# SwiftFormer's feature maps are of shape (batch_size, embed_dims, height, width)
											# with the width and height being successively divided by 2, after every 2 blocks
											for i in range(len(lowerCamelCase__							)							):
															self.assertEqual(
															    hidden_states[i].shape			,						torch.Size(
															        [
															            self.model_tester.batch_size,
															            self.model_tester.embed_dims[i // 2],
															            (self.model_tester.image_size // 4) // 2 ** (i // 2),
															            (self.model_tester.image_size // 4) // 2 ** (i // 2),
															        ]							)			,						)

							__lowerCamelCase       ,						__lowerCamelCase		       =    self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
											__lowerCamelCase		       =    True
											check_hidden_states_output(lowerCamelCase__			,						lowerCamelCase__			,						lowerCamelCase__							)

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

											check_hidden_states_output(lowerCamelCase__			,						lowerCamelCase__			,						lowerCamelCase__							)


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



							'''simple docstring'''
							def _config_zero_init(lowerCamelCase__							):
											__lowerCamelCase		       =    copy.deepcopy(lowerCamelCase__							)
											for key in configs_no_init.__dict__.keys():
															if "_range" in key or "_std" in key or "initializer_factor" in key or "layer_scale" in key:
																			setattr(lowerCamelCase__			,						lowerCamelCase__			,						1e-10							)
															if isinstance(getattr(lowerCamelCase__			,						lowerCamelCase__			,						lowerCamelCase__							)			,						lowerCamelCase__							):
																			__lowerCamelCase		       =    _config_zero_init(getattr(lowerCamelCase__			,						lowerCamelCase__							)							)
																			setattr(lowerCamelCase__			,						lowerCamelCase__			,						lowerCamelCase__							)
											return configs_no_init

							__lowerCamelCase       ,						__lowerCamelCase		       =    self.model_tester.prepare_config_and_inputs_for_common()

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






			@unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'							)
			def       lowercase_    (      self							)    ->      int:



							'''simple docstring'''
							pass







def 			lowerCamelCase_		(       )     ->       Tuple:





				"""simple docstring"""


				__lowerCamelCase		       =    Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'      )
				return image







@require_torch
@require_vision
class     __lowerCAmelCase (       unittest.TestCase ):

			"""simple docstring"""







			@cached_property
			def       lowercase_    (      self							)    ->      List[str]:



							'''simple docstring'''
							return ViTImageProcessor.from_pretrained('MBZUAI/swiftformer-xs'							) if is_vision_available() else None






			@slow
			def       lowercase_    (      self							)    ->      Optional[Any]:



							'''simple docstring'''
							__lowerCamelCase		       =    SwiftFormerForImageClassification.from_pretrained('MBZUAI/swiftformer-xs'							).to(lowerCamelCase__							)

							__lowerCamelCase		       =    self.default_image_processor
							__lowerCamelCase		       =    prepare_img()
							__lowerCamelCase		       =    image_processor(images=lowerCamelCase__			,						return_tensors='pt'							).to(lowerCamelCase__							)

							# forward pass
							with torch.no_grad():
											__lowerCamelCase		       =    model(**lowerCamelCase__							)

							# verify the logits
							__lowerCamelCase		       =    torch.Size((1, 1_000)							)
							self.assertEqual(outputs.logits.shape			,						lowerCamelCase__							)

							__lowerCamelCase		       =    torch.tensor([[-2.17_03e00, 2.11_07e00, -2.08_11e00]]							).to(lowerCamelCase__							)
							self.assertTrue(torch.allclose(outputs.logits[0, :3]			,						lowerCamelCase__			,						atol=1e-4							)							)








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     __lowerCAmelCase (       __magic_name__ ):

			"""simple docstring"""







			snake_case_   		=       ['''input_features''', '''is_longer''']


			def __init__(      self			,						lowerCamelCase__=64			,						lowerCamelCase__=48_000			,						lowerCamelCase__=480			,						lowerCamelCase__=10			,						lowerCamelCase__=1_024			,						lowerCamelCase__=0.0			,						lowerCamelCase__=False			,						lowerCamelCase__ = 0			,						lowerCamelCase__ = 14_000			,						lowerCamelCase__ = None			,						lowerCamelCase__ = "fusion"			,						lowerCamelCase__ = "repeatpad"			,						**lowerCamelCase__			,						)    ->      Tuple:



							'''simple docstring'''
							super().__init__(
							    feature_size=lowerCamelCase__			,						sampling_rate=lowerCamelCase__			,						padding_value=lowerCamelCase__			,						return_attention_mask=lowerCamelCase__			,						**lowerCamelCase__			,						)
							__lowerCamelCase		       =    top_db
							__lowerCamelCase		       =    truncation
							__lowerCamelCase		       =    padding
							__lowerCamelCase		       =    fft_window_size
							__lowerCamelCase		       =    (fft_window_size >> 1) + 1
							__lowerCamelCase		       =    hop_length
							__lowerCamelCase		       =    max_length_s
							__lowerCamelCase		       =    max_length_s * sampling_rate
							__lowerCamelCase		       =    sampling_rate
							__lowerCamelCase		       =    frequency_min
							__lowerCamelCase		       =    frequency_max
							__lowerCamelCase		       =    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'			,						)
							__lowerCamelCase		       =    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       lowercase_    (      self							)    ->      Dict[str, Any]:



							'''simple docstring'''
							__lowerCamelCase		       =    copy.deepcopy(self.__dict__							)
							__lowerCamelCase		       =    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       lowercase_    (      self			,						lowerCamelCase__			,						lowerCamelCase__ = None							)    ->      np.ndarray:



							'''simple docstring'''
							__lowerCamelCase		       =    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       lowercase_    (      self			,						lowerCamelCase__			,						lowerCamelCase__			,						lowerCamelCase__							)    ->      int:



							'''simple docstring'''
							__lowerCamelCase		       =    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
											__lowerCamelCase		       =    [0]
							if len(ranges[2]							) == 0:
											# if the audio is too short, we just use the first chunk
											__lowerCamelCase		       =    [0]
							# randomly choose index for each part
							__lowerCamelCase		       =    np.random.choice(ranges[0]							)
							__lowerCamelCase		       =    np.random.choice(ranges[1]							)
							__lowerCamelCase		       =    np.random.choice(ranges[2]							)

							__lowerCamelCase		       =    mel[idx_front : idx_front + chunk_frames, :]
							__lowerCamelCase		       =    mel[idx_middle : idx_middle + chunk_frames, :]
							__lowerCamelCase		       =    mel[idx_back : idx_back + chunk_frames, :]

							__lowerCamelCase		       =    torch.tensor(mel[None, None, :]							)
							__lowerCamelCase		       =    torch.nn.functional.interpolate(
							    lowerCamelCase__			,						size=[chunk_frames, 64]			,						mode='bilinear'			,						align_corners=lowerCamelCase__							)
							__lowerCamelCase		       =    mel_shrink[0][0].numpy()
							__lowerCamelCase		       =    np.stack([mel_shrink, mel_chunk_front, mel_chunk_middle, mel_chunk_back]			,						axis=0							)
							return mel_fusion


			def       lowercase_    (      self			,						lowerCamelCase__			,						lowerCamelCase__			,						lowerCamelCase__			,						lowerCamelCase__							)    ->      np.array:



							'''simple docstring'''
							if waveform.shape[0] > max_length:
											if truncation == "rand_trunc":
															__lowerCamelCase		       =    True
															# random crop to max_length (for compatibility) -> this should be handled by self.pad
															__lowerCamelCase		       =    len(lowerCamelCase__							) - max_length
															__lowerCamelCase		       =    np.random.randint(0			,						overflow + 1							)
															__lowerCamelCase		       =    waveform[idx : idx + max_length]
															__lowerCamelCase		       =    self._np_extract_fbank_features(lowerCamelCase__			,						self.mel_filters_slaney							)[None, :]
											elif truncation == "fusion":
															__lowerCamelCase		       =    self._np_extract_fbank_features(lowerCamelCase__			,						self.mel_filters							)
															__lowerCamelCase		       =    max_length // self.hop_length + 1  # the +1 related to how the spectrogram is computed
															__lowerCamelCase		       =    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.
																			__lowerCamelCase		       =    np.stack([mel, mel, mel, mel]			,						axis=0							)
																			__lowerCamelCase		       =    False
															else:
																			__lowerCamelCase		       =    self._random_mel_fusion(lowerCamelCase__			,						lowerCamelCase__			,						lowerCamelCase__							)
																			__lowerCamelCase		       =    True
											else:
															raise NotImplementedError(f"""data_truncating {truncation} not implemented"""							)

							else:
											__lowerCamelCase		       =    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":
																			__lowerCamelCase		       =    int(max_length / len(lowerCamelCase__							)							)
																			__lowerCamelCase		       =    np.stack(np.tile(lowerCamelCase__			,						n_repeat + 1							)							)[:max_length]
															if padding == "repeatpad":
																			__lowerCamelCase		       =    int(max_length / len(lowerCamelCase__							)							)
																			__lowerCamelCase		       =    np.stack(np.tile(lowerCamelCase__			,						lowerCamelCase__							)							)
															__lowerCamelCase		       =    np.pad(lowerCamelCase__			,						(0, max_length - waveform.shape[0])			,						mode='constant'			,						constant_values=0							)

											if truncation == "fusion":
															__lowerCamelCase		       =    self._np_extract_fbank_features(lowerCamelCase__			,						self.mel_filters							)
															__lowerCamelCase		       =    np.stack([input_mel, input_mel, input_mel, input_mel]			,						axis=0							)
											else:
															__lowerCamelCase		       =    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__			,						)    ->      BatchFeature:



							'''simple docstring'''
							__lowerCamelCase		       =    truncation if truncation is not None else self.truncation
							__lowerCamelCase		       =    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.'							)

							__lowerCamelCase		       =    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}"""							)
							__lowerCamelCase		       =    is_batched_numpy or (
							    isinstance(lowerCamelCase__			,						(list, tuple)							) and (isinstance(raw_speech[0]			,						(np.ndarray, tuple, list)							))
							)

							if is_batched:
											__lowerCamelCase		       =    [np.asarray(lowerCamelCase__			,						dtype=np.floataa							) for speech in raw_speech]
							elif not is_batched and not isinstance(lowerCamelCase__			,						np.ndarray							):
											__lowerCamelCase		       =    np.asarray(lowerCamelCase__			,						dtype=np.floataa							)
							elif isinstance(lowerCamelCase__			,						np.ndarray							) and raw_speech.dtype is np.dtype(np.floataa							):
											__lowerCamelCase		       =    raw_speech.astype(np.floataa							)

							# always return batch
							if not is_batched:
											__lowerCamelCase		       =    [np.asarray(lowerCamelCase__							)]

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

							__lowerCamelCase		       =    []
							__lowerCamelCase		       =    []
							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
											__lowerCamelCase		       =    np.random.randint(0			,						len(lowerCamelCase__							)							)
											__lowerCamelCase		       =    True

							if isinstance(input_mel[0]			,						lowerCamelCase__							):
											__lowerCamelCase		       =    [np.asarray(lowerCamelCase__			,						dtype=np.floataa							) for feature in input_mel]

							# is_longer is a list of bool
							__lowerCamelCase		       =    [[longer] for longer in is_longer]

							__lowerCamelCase		       =    {'input_features': input_mel, 'is_longer': is_longer}
							__lowerCamelCase		       =    BatchFeature(lowerCamelCase__							)

							if return_tensors is not None:
											__lowerCamelCase		       =    input_features.convert_to_tensors(lowerCamelCase__							)

							return input_features


