



import argparse
import json

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import ConvNextConfig, SegformerImageProcessor, UperNetConfig, UperNetForSemanticSegmentation


def 			UpperCamelCase(  __UpperCamelCase							:		Union[str, Any] ):
		lowerCAmelCase_			:     Any									= 384
		if "tiny" in model_name:
				lowerCAmelCase_			:     Tuple									= [3, 3, 9, 3]
				lowerCAmelCase_			:     List[str]									= [96, 192, 384, 768]
		if "small" in model_name:
				lowerCAmelCase_			:     List[Any]									= [3, 3, 27, 3]
				lowerCAmelCase_			:     List[str]									= [96, 192, 384, 768]
		if "base" in model_name:
				lowerCAmelCase_			:     Optional[int]									= [3, 3, 27, 3]
				lowerCAmelCase_			:     List[str]									= [128, 256, 512, 1024]
				lowerCAmelCase_			:     int									= 512
		if "large" in model_name:
				lowerCAmelCase_			:     List[str]									= [3, 3, 27, 3]
				lowerCAmelCase_			:     int									= [192, 384, 768, 1536]
				lowerCAmelCase_			:     List[Any]									= 768
		if "xlarge" in model_name:
				lowerCAmelCase_			:     Optional[Any]									= [3, 3, 27, 3]
				lowerCAmelCase_			:     Optional[int]									= [256, 512, 1024, 2048]
				lowerCAmelCase_			:     Optional[Any]									= 1024

		# set label information
		lowerCAmelCase_			:     Tuple									= 150
		lowerCAmelCase_			:     Optional[int]									= '''huggingface/label-files'''
		lowerCAmelCase_			:     str									= '''ade20k-id2label.json'''
		lowerCAmelCase_			:     List[str]									= json.load(open(hf_hub_download(__UpperCamelCase     ,__UpperCamelCase     ,repo_type='''dataset''' )     ,'''r''' ) )
		lowerCAmelCase_			:     Any									= {int(__UpperCamelCase ): v for k, v in idalabel.items()}
		lowerCAmelCase_			:     Optional[int]									= {v: k for k, v in idalabel.items()}

		lowerCAmelCase_			:     Dict									= ConvNextConfig(
		    depths=__UpperCamelCase     ,hidden_sizes=__UpperCamelCase     ,out_features=['''stage1''', '''stage2''', '''stage3''', '''stage4'''] )
		lowerCAmelCase_			:     List[Any]									= UperNetConfig(
		    backbone_config=__UpperCamelCase     ,auxiliary_in_channels=__UpperCamelCase     ,num_labels=__UpperCamelCase     ,idalabel=__UpperCamelCase     ,labelaid=__UpperCamelCase     ,)

		return config


def 			UpperCamelCase(  __UpperCamelCase							:		List[Any] ):
		lowerCAmelCase_			:     List[str]									= []

		# fmt: off
		# stem
		rename_keys.append(('''backbone.downsample_layers.0.0.weight''', '''backbone.embeddings.patch_embeddings.weight''') )
		rename_keys.append(('''backbone.downsample_layers.0.0.bias''', '''backbone.embeddings.patch_embeddings.bias''') )
		rename_keys.append(('''backbone.downsample_layers.0.1.weight''', '''backbone.embeddings.layernorm.weight''') )
		rename_keys.append(('''backbone.downsample_layers.0.1.bias''', '''backbone.embeddings.layernorm.bias''') )
		# stages
		for i in range(len(config.backbone_config.depths ) ):
				for j in range(config.backbone_config.depths[i] ):
						rename_keys.append((f"""backbone.stages.{i}.{j}.gamma""", f"""backbone.encoder.stages.{i}.layers.{j}.layer_scale_parameter""") )
						rename_keys.append((f"""backbone.stages.{i}.{j}.depthwise_conv.weight""", f"""backbone.encoder.stages.{i}.layers.{j}.dwconv.weight""") )
						rename_keys.append((f"""backbone.stages.{i}.{j}.depthwise_conv.bias""", f"""backbone.encoder.stages.{i}.layers.{j}.dwconv.bias""") )
						rename_keys.append((f"""backbone.stages.{i}.{j}.norm.weight""", f"""backbone.encoder.stages.{i}.layers.{j}.layernorm.weight""") )
						rename_keys.append((f"""backbone.stages.{i}.{j}.norm.bias""", f"""backbone.encoder.stages.{i}.layers.{j}.layernorm.bias""") )
						rename_keys.append((f"""backbone.stages.{i}.{j}.pointwise_conv1.weight""", f"""backbone.encoder.stages.{i}.layers.{j}.pwconv1.weight""") )
						rename_keys.append((f"""backbone.stages.{i}.{j}.pointwise_conv1.bias""", f"""backbone.encoder.stages.{i}.layers.{j}.pwconv1.bias""") )
						rename_keys.append((f"""backbone.stages.{i}.{j}.pointwise_conv2.weight""", f"""backbone.encoder.stages.{i}.layers.{j}.pwconv2.weight""") )
						rename_keys.append((f"""backbone.stages.{i}.{j}.pointwise_conv2.bias""", f"""backbone.encoder.stages.{i}.layers.{j}.pwconv2.bias""") )
				if i > 0:
						rename_keys.append((f"""backbone.downsample_layers.{i}.0.weight""", f"""backbone.encoder.stages.{i}.downsampling_layer.0.weight""") )
						rename_keys.append((f"""backbone.downsample_layers.{i}.0.bias""", f"""backbone.encoder.stages.{i}.downsampling_layer.0.bias""") )
						rename_keys.append((f"""backbone.downsample_layers.{i}.1.weight""", f"""backbone.encoder.stages.{i}.downsampling_layer.1.weight""") )
						rename_keys.append((f"""backbone.downsample_layers.{i}.1.bias""", f"""backbone.encoder.stages.{i}.downsampling_layer.1.bias""") )

				rename_keys.append((f"""backbone.norm{i}.weight""", f"""backbone.hidden_states_norms.stage{i+1}.weight""") )
				rename_keys.append((f"""backbone.norm{i}.bias""", f"""backbone.hidden_states_norms.stage{i+1}.bias""") )

		# decode head
		rename_keys.extend(
		    [
		        ('''decode_head.conv_seg.weight''', '''decode_head.classifier.weight'''),
		        ('''decode_head.conv_seg.bias''', '''decode_head.classifier.bias'''),
		        ('''auxiliary_head.conv_seg.weight''', '''auxiliary_head.classifier.weight'''),
		        ('''auxiliary_head.conv_seg.bias''', '''auxiliary_head.classifier.bias'''),
		    ] )
		# fmt: on

		return rename_keys


def 			UpperCamelCase(  __UpperCamelCase							:		int     ,__UpperCamelCase							:		Optional[Any]     ,__UpperCamelCase							:		Tuple ):
		lowerCAmelCase_			:     Any									= dct.pop(__UpperCamelCase )
		lowerCAmelCase_			:     Tuple									= val


def 			UpperCamelCase(  __UpperCamelCase							:		Optional[int]     ,__UpperCamelCase							:		int     ,__UpperCamelCase							:		Dict ):
		lowerCAmelCase_			:     List[Any]									= {
		    '''upernet-convnext-tiny''': '''https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_tiny_fp16_512x512_160k_ade20k/upernet_convnext_tiny_fp16_512x512_160k_ade20k_20220227_124553-cad485de.pth''',
		    '''upernet-convnext-small''': '''https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_small_fp16_512x512_160k_ade20k/upernet_convnext_small_fp16_512x512_160k_ade20k_20220227_131208-1b1e394f.pth''',
		    '''upernet-convnext-base''': '''https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_base_fp16_512x512_160k_ade20k/upernet_convnext_base_fp16_512x512_160k_ade20k_20220227_181227-02a24fc6.pth''',
		    '''upernet-convnext-large''': '''https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_large_fp16_640x640_160k_ade20k/upernet_convnext_large_fp16_640x640_160k_ade20k_20220226_040532-e57aa54d.pth''',
		    '''upernet-convnext-xlarge''': '''https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_xlarge_fp16_640x640_160k_ade20k/upernet_convnext_xlarge_fp16_640x640_160k_ade20k_20220226_080344-95fc38c2.pth''',
		}
		lowerCAmelCase_			:     str									= model_name_to_url[model_name]
		lowerCAmelCase_			:     str									= torch.hub.load_state_dict_from_url(__UpperCamelCase     ,map_location='''cpu''' )['''state_dict''']

		lowerCAmelCase_			:     Optional[int]									= get_upernet_config(__UpperCamelCase )
		lowerCAmelCase_			:     Any									= UperNetForSemanticSegmentation(__UpperCamelCase )
		model.eval()

		# replace "bn" => "batch_norm"
		for key in state_dict.copy().keys():
				lowerCAmelCase_			:     Dict									= state_dict.pop(__UpperCamelCase )
				if "bn" in key:
						lowerCAmelCase_			:     List[str]									= key.replace('''bn'''     ,'''batch_norm''' )
				lowerCAmelCase_			:     Tuple									= val

		# rename keys
		lowerCAmelCase_			:     str									= create_rename_keys(__UpperCamelCase )
		for src, dest in rename_keys:
				rename_key(__UpperCamelCase     ,__UpperCamelCase     ,__UpperCamelCase )

		model.load_state_dict(__UpperCamelCase )

		# verify on image
		lowerCAmelCase_			:     int									= '''https://huggingface.co/datasets/hf-internal-testing/fixtures_ade20k/resolve/main/ADE_val_00000001.jpg'''
		lowerCAmelCase_			:     Tuple									= Image.open(requests.get(__UpperCamelCase     ,stream=__UpperCamelCase ).raw ).convert('''RGB''' )

		lowerCAmelCase_			:     Dict									= SegformerImageProcessor()
		lowerCAmelCase_			:     Any									= processor(__UpperCamelCase     ,return_tensors='''pt''' ).pixel_values

		with torch.no_grad():
				lowerCAmelCase_			:     str									= model(__UpperCamelCase )

		if model_name == "upernet-convnext-tiny":
				lowerCAmelCase_			:     List[str]									= torch.tensor(
				    [[-8.8_1_1_0, -8.8_1_1_0, -8.6_5_2_1], [-8.8_1_1_0, -8.8_1_1_0, -8.6_5_2_1], [-8.7_7_4_6, -8.7_7_4_6, -8.6_1_3_0]] )
		elif model_name == "upernet-convnext-small":
				lowerCAmelCase_			:     Union[str, Any]									= torch.tensor(
				    [[-8.8_2_3_6, -8.8_2_3_6, -8.6_7_7_1], [-8.8_2_3_6, -8.8_2_3_6, -8.6_7_7_1], [-8.7_6_3_8, -8.7_6_3_8, -8.6_2_4_0]] )
		elif model_name == "upernet-convnext-base":
				lowerCAmelCase_			:     Dict									= torch.tensor(
				    [[-8.8_5_5_8, -8.8_5_5_8, -8.6_9_0_5], [-8.8_5_5_8, -8.8_5_5_8, -8.6_9_0_5], [-8.7_6_6_9, -8.7_6_6_9, -8.6_0_2_1]] )
		elif model_name == "upernet-convnext-large":
				lowerCAmelCase_			:     Optional[Any]									= torch.tensor(
				    [[-8.6_6_6_0, -8.6_6_6_0, -8.6_2_1_0], [-8.6_6_6_0, -8.6_6_6_0, -8.6_2_1_0], [-8.6_3_1_0, -8.6_3_1_0, -8.5_9_6_4]] )
		elif model_name == "upernet-convnext-xlarge":
				lowerCAmelCase_			:     Dict									= torch.tensor(
				    [[-8.4_9_8_0, -8.4_9_8_0, -8.3_9_7_7], [-8.4_9_8_0, -8.4_9_8_0, -8.3_9_7_7], [-8.4_3_7_9, -8.4_3_7_9, -8.3_4_1_2]] )
		print('''Logits:'''     ,outputs.logits[0, 0, :3, :3] )
		assert torch.allclose(outputs.logits[0, 0, :3, :3]     ,__UpperCamelCase     ,atol=1e-4 )
		print('''Looks ok!''' )

		if pytorch_dump_folder_path is not None:
				print(f"""Saving model {model_name} to {pytorch_dump_folder_path}""" )
				model.save_pretrained(__UpperCamelCase )
				print(f"""Saving processor to {pytorch_dump_folder_path}""" )
				processor.save_pretrained(__UpperCamelCase )

		if push_to_hub:
				print(f"""Pushing model and processor for {model_name} to hub""" )
				model.push_to_hub(f"""openmmlab/{model_name}""" )
				processor.push_to_hub(f"""openmmlab/{model_name}""" )


if __name__ == "__main__":
						A__  :  Optional[Any]								=					argparse.ArgumentParser()
						# Required parameters
						parser.add_argument(
						    '''--model_name''',
						    default='''upernet-convnext-tiny''',
						    type=str,
						    choices=[F'''upernet-convnext-{size}''' for size in ['''tiny''', '''small''', '''base''', '''large''', '''xlarge''']],
						    help='''Name of the ConvNext UperNet model you\'d like to convert.''',
						)
						parser.add_argument(
						    '''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model directory.'''
						)
						parser.add_argument(
						    '''--push_to_hub''', action='''store_true''', help='''Whether or not to push the converted model to the 🤗 hub.'''
						)

						A__  :  int								=					parser.parse_args()
						convert_upernet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)











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


