




import argparse
import json
from pathlib import Path

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

from transformers import (
    BertTokenizer,
    ViltConfig,
    ViltForImageAndTextRetrieval,
    ViltForImagesAndTextClassification,
    ViltForMaskedLM,
    ViltForQuestionAnswering,
    ViltImageProcessor,
    ViltProcessor,
)
from transformers.utils import logging


logging.set_verbosity_info()
a_   		=     logging.get_logger(__name__)




def 					__SCREAMING_SNAKE_CASE   (  lowercase_					,     lowercase_=False					,     lowercase_=False					,     lowercase_=False      )       ->	List[Any]:

    """simple docstring"""


    __UpperCamelCase  		=						[]
    for i in range(config.num_hidden_layers      ):
        # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
        rename_keys.append((F"transformer.blocks.{i}.norm1.weight", F"vilt.encoder.layer.{i}.layernorm_before.weight")      )
        rename_keys.append((F"transformer.blocks.{i}.norm1.bias", F"vilt.encoder.layer.{i}.layernorm_before.bias")      )
        rename_keys.append(
            (F"transformer.blocks.{i}.attn.proj.weight", F"vilt.encoder.layer.{i}.attention.output.dense.weight")      )
        rename_keys.append(
            (F"transformer.blocks.{i}.attn.proj.bias", F"vilt.encoder.layer.{i}.attention.output.dense.bias")      )
        rename_keys.append((F"transformer.blocks.{i}.norm2.weight", F"vilt.encoder.layer.{i}.layernorm_after.weight")      )
        rename_keys.append((F"transformer.blocks.{i}.norm2.bias", F"vilt.encoder.layer.{i}.layernorm_after.bias")      )
        rename_keys.append(
            (F"transformer.blocks.{i}.mlp.fc1.weight", F"vilt.encoder.layer.{i}.intermediate.dense.weight")      )
        rename_keys.append((F"transformer.blocks.{i}.mlp.fc1.bias", F"vilt.encoder.layer.{i}.intermediate.dense.bias")      )
        rename_keys.append((F"transformer.blocks.{i}.mlp.fc2.weight", F"vilt.encoder.layer.{i}.output.dense.weight")      )
        rename_keys.append((F"transformer.blocks.{i}.mlp.fc2.bias", F"vilt.encoder.layer.{i}.output.dense.bias")      )

    # embeddings
    rename_keys.extend(
        [
            # text embeddings
            ('''text_embeddings.word_embeddings.weight''', '''vilt.embeddings.text_embeddings.word_embeddings.weight'''),
            (
                '''text_embeddings.position_embeddings.weight''',
                '''vilt.embeddings.text_embeddings.position_embeddings.weight''',
            ),
            ('''text_embeddings.position_ids''', '''vilt.embeddings.text_embeddings.position_ids'''),
            (
                '''text_embeddings.token_type_embeddings.weight''',
                '''vilt.embeddings.text_embeddings.token_type_embeddings.weight''',
            ),
            ('''text_embeddings.LayerNorm.weight''', '''vilt.embeddings.text_embeddings.LayerNorm.weight'''),
            ('''text_embeddings.LayerNorm.bias''', '''vilt.embeddings.text_embeddings.LayerNorm.bias'''),
            # patch embeddings
            ('''transformer.cls_token''', '''vilt.embeddings.cls_token'''),
            ('''transformer.patch_embed.proj.weight''', '''vilt.embeddings.patch_embeddings.projection.weight'''),
            ('''transformer.patch_embed.proj.bias''', '''vilt.embeddings.patch_embeddings.projection.bias'''),
            ('''transformer.pos_embed''', '''vilt.embeddings.position_embeddings'''),
            # token type embeddings
            ('''token_type_embeddings.weight''', '''vilt.embeddings.token_type_embeddings.weight'''),
        ]      )

    # final layernorm + pooler
    rename_keys.extend(
        [
            ('''transformer.norm.weight''', '''vilt.layernorm.weight'''),
            ('''transformer.norm.bias''', '''vilt.layernorm.bias'''),
            ('''pooler.dense.weight''', '''vilt.pooler.dense.weight'''),
            ('''pooler.dense.bias''', '''vilt.pooler.dense.bias'''),
        ]      )

    # classifier head(s)
    if vqa_model:
        # classification head
        rename_keys.extend(
            [
                ('''vqa_classifier.0.weight''', '''classifier.0.weight'''),
                ('''vqa_classifier.0.bias''', '''classifier.0.bias'''),
                ('''vqa_classifier.1.weight''', '''classifier.1.weight'''),
                ('''vqa_classifier.1.bias''', '''classifier.1.bias'''),
                ('''vqa_classifier.3.weight''', '''classifier.3.weight'''),
                ('''vqa_classifier.3.bias''', '''classifier.3.bias'''),
            ]      )
    elif nlvr_model:
        # classification head
        rename_keys.extend(
            [
                ('''nlvr2_classifier.0.weight''', '''classifier.0.weight'''),
                ('''nlvr2_classifier.0.bias''', '''classifier.0.bias'''),
                ('''nlvr2_classifier.1.weight''', '''classifier.1.weight'''),
                ('''nlvr2_classifier.1.bias''', '''classifier.1.bias'''),
                ('''nlvr2_classifier.3.weight''', '''classifier.3.weight'''),
                ('''nlvr2_classifier.3.bias''', '''classifier.3.bias'''),
            ]      )
    else:
        pass

    return rename_keys




def 					__SCREAMING_SNAKE_CASE   (  lowercase_					,     lowercase_      )       ->	Dict:

    """simple docstring"""


    for i in range(config.num_hidden_layers      ):
        __UpperCamelCase  		=						'''vilt.'''
        # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
        __UpperCamelCase  		=						state_dict.pop(F"transformer.blocks.{i}.attn.qkv.weight"      )
        __UpperCamelCase  		=						state_dict.pop(F"transformer.blocks.{i}.attn.qkv.bias"      )
        # next, add query, keys and values (in that order) to the state dict
        __UpperCamelCase  		=						in_proj_weight[
            : config.hidden_size, :
        ]
        __UpperCamelCase  		=						in_proj_bias[: config.hidden_size]
        __UpperCamelCase  		=						in_proj_weight[
            config.hidden_size : config.hidden_size * 2, :
        ]
        __UpperCamelCase  		=						in_proj_bias[
            config.hidden_size : config.hidden_size * 2
        ]
        __UpperCamelCase  		=						in_proj_weight[
            -config.hidden_size :, :
        ]
        __UpperCamelCase  		=						in_proj_bias[-config.hidden_size :]




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

    """simple docstring"""


    __UpperCamelCase  		=						['''head.weight''', '''head.bias''']
    for k in ignore_keys:
        state_dict.pop(lowercase_					,     lowercase_      )




def 					__SCREAMING_SNAKE_CASE   (  lowercase_					,     lowercase_					,     lowercase_      )       ->	List[str]:

    """simple docstring"""


    __UpperCamelCase  		=						dct.pop(lowercase_      )
    __UpperCamelCase  		=						val




@torch.no_grad()
def 					__SCREAMING_SNAKE_CASE   (  lowercase_					,     lowercase_      )       ->	Dict:

    """simple docstring"""


    __UpperCamelCase  		=						ViltConfig(image_size=3_84					,     patch_size=32					,     tie_word_embeddings=lowercase_      )
    __UpperCamelCase  		=						False
    __UpperCamelCase  		=						False
    __UpperCamelCase  		=						False
    __UpperCamelCase  		=						False
    if "vqa" in checkpoint_url:
        __UpperCamelCase  		=						True
        __UpperCamelCase  		=						31_29
        __UpperCamelCase  		=						'''huggingface/label-files'''
        __UpperCamelCase  		=						'''vqa2-id2label.json'''
        __UpperCamelCase  		=						json.load(open(hf_hub_download(lowercase_					,     lowercase_					,     repo_type='''dataset'''      )					,     '''r'''      )      )
        __UpperCamelCase  		=						{int(lowercase_      ): v for k, v in idalabel.items()}
        __UpperCamelCase  		=						idalabel
        __UpperCamelCase  		=						{v: k for k, v in idalabel.items()}
        __UpperCamelCase  		=						ViltForQuestionAnswering(lowercase_      )
    elif "nlvr" in checkpoint_url:
        __UpperCamelCase  		=						True
        __UpperCamelCase  		=						2
        __UpperCamelCase  		=						{0: '''False''', 1: '''True'''}
        __UpperCamelCase  		=						{v: k for k, v in config.idalabel.items()}
        __UpperCamelCase  		=						3
        __UpperCamelCase  		=						ViltForImagesAndTextClassification(lowercase_      )
    elif "irtr" in checkpoint_url:
        __UpperCamelCase  		=						True
        __UpperCamelCase  		=						ViltForImageAndTextRetrieval(lowercase_      )
    elif "mlm_itm" in checkpoint_url:
        __UpperCamelCase  		=						True
        __UpperCamelCase  		=						ViltForMaskedLM(lowercase_      )
    else:
        raise ValueError('''Unknown model type'''      )

    # load state_dict of original model, remove and rename some keys
    __UpperCamelCase  		=						torch.hub.load_state_dict_from_url(lowercase_					,     map_location='''cpu'''      )['''state_dict''']
    __UpperCamelCase  		=						create_rename_keys(lowercase_					,     lowercase_					,     lowercase_					,     lowercase_      )
    for src, dest in rename_keys:
        rename_key(lowercase_					,     lowercase_					,     lowercase_      )
    read_in_q_k_v(lowercase_					,     lowercase_      )
    if mlm_model or irtr_model:
        __UpperCamelCase  		=						['''itm_score.fc.weight''', '''itm_score.fc.bias''']
        for k in ignore_keys:
            state_dict.pop(lowercase_					,     lowercase_      )

    # load state dict into HuggingFace model
    model.eval()
    if mlm_model:
        __UpperCamelCase		,      __UpperCamelCase  		=						model.load_state_dict(lowercase_					,     strict=lowercase_      )
        assert missing_keys == ["mlm_score.decoder.bias"]
    else:
        model.load_state_dict(lowercase_      )

    # Define processor
    __UpperCamelCase  		=						ViltImageProcessor(size=3_84      )
    __UpperCamelCase  		=						BertTokenizer.from_pretrained('''bert-base-uncased'''      )
    __UpperCamelCase  		=						ViltProcessor(lowercase_					,     lowercase_      )

    # Forward pass on example inputs (image + text)
    if nlvr_model:
        __UpperCamelCase  		=						Image.open(requests.get('''https://lil.nlp.cornell.edu/nlvr/exs/ex0_0.jpg'''					,     stream=lowercase_      ).raw      )
        __UpperCamelCase  		=						Image.open(requests.get('''https://lil.nlp.cornell.edu/nlvr/exs/ex0_0.jpg'''					,     stream=lowercase_      ).raw      )
        __UpperCamelCase  		=						(
            '''The left image contains twice the number of dogs as the right image, and at least two dogs in total are'''
            ''' standing.'''
        )
        __UpperCamelCase  		=						processor(lowercase_					,     lowercase_					,     return_tensors='''pt'''      )
        __UpperCamelCase  		=						processor(lowercase_					,     lowercase_					,     return_tensors='''pt'''      )
        __UpperCamelCase  		=						model(
            input_ids=encoding_a.input_ids					,     pixel_values=encoding_a.pixel_values					,     pixel_values_a=encoding_a.pixel_values					,     )
    else:
        __UpperCamelCase  		=						Image.open(requests.get('''http://images.cocodataset.org/val2017/000000039769.jpg'''					,     stream=lowercase_      ).raw      )
        if mlm_model:
            __UpperCamelCase  		=						'''a bunch of [MASK] laying on a [MASK].'''
        else:
            __UpperCamelCase  		=						'''How many cats are there?'''
        __UpperCamelCase  		=						processor(lowercase_					,     lowercase_					,     return_tensors='''pt'''      )
        __UpperCamelCase  		=						model(**lowercase_      )

    # Verify outputs
    if mlm_model:
        __UpperCamelCase  		=						torch.Size([1, 11, 3_05_22]      )
        __UpperCamelCase  		=						torch.tensor([-12.5061, -12.5123, -12.5174]      )
        assert outputs.logits.shape == expected_shape
        assert torch.allclose(outputs.logits[0, 0, :3]					,     lowercase_					,     atol=1E-4      )

        # verify masked token prediction equals "cats"
        __UpperCamelCase  		=						outputs.logits[0, 4, :].argmax(-1      ).item()
        assert tokenizer.decode([predicted_id]      ) == "cats"
    elif vqa_model:
        __UpperCamelCase  		=						torch.Size([1, 31_29]      )
        __UpperCamelCase  		=						torch.tensor([-15.9495, -18.1472, -10.3041]      )
        assert torch.allclose(outputs.logits[0, :3]					,     lowercase_					,     atol=1E-4      )
        assert outputs.logits.shape == expected_shape
        assert torch.allclose(outputs.logits[0, 0, :3]					,     lowercase_					,     atol=1E-4      )

        # verify vqa prediction equals "2"
        __UpperCamelCase  		=						outputs.logits.argmax(-1      ).item()
        assert model.config.idalabel[predicted_idx] == "2"
    elif nlvr_model:
        __UpperCamelCase  		=						torch.Size([1, 2]      )
        __UpperCamelCase  		=						torch.tensor([-2.8721, 2.1291]      )
        assert torch.allclose(outputs.logits[0, :3]					,     lowercase_					,     atol=1E-4      )
        assert outputs.logits.shape == expected_shape

    Path(lowercase_      ).mkdir(exist_ok=lowercase_      )
    print(F"Saving model and processor to {pytorch_dump_folder_path}"      )
    model.save_pretrained(lowercase_      )
    processor.save_pretrained(lowercase_      )


if __name__ == "__main__":
 a_   		=     argparse.ArgumentParser()
 # Required parameters
 parser.add_argument(
     "--checkpoint_url",
     default="https://github.com/dandelin/ViLT/releases/download/200k/vilt_200k_mlm_itm.ckpt",
     type=str,
     help="URL of the checkpoint you'd like to convert.",
 )
 parser.add_argument(
     "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
 )

 a_   		=     parser.parse_args()
 convert_vilt_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)












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						(			_SCREAMING_SNAKE_CASE   ):

      """simple docstring"""

      lowerCAmelCase__			: Dict    =					["input_features", "is_longer"]







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







      def       snake_case	(     self					: Union[str, Any]				):
          __UpperCamelCase  		=						copy.deepcopy(self.__dict__				)
          __UpperCamelCase  		=						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					: Tuple ,       snake_case					: np.array ,       snake_case					: Optional[np.array] = None				):
          __UpperCamelCase  		=						spectrogram(
              snake_case ,       window_function(self.fft_window_size ,       '''hann'''				) ,       frame_length=self.fft_window_size ,       hop_length=self.hop_length ,       power=2.0 ,       mel_filters=snake_case ,       log_mel='''dB''' ,       )
          return log_mel_spectrogram.T







      def       snake_case	(     self					: Optional[int] ,       snake_case					: Any ,       snake_case					: List[Any] ,       snake_case					: int				):
          __UpperCamelCase  		=						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  		=						[0]
          if len(ranges[2]				) == 0:
              # if the audio is too short, we just use the first chunk
              __UpperCamelCase  		=						[0]
          # randomly choose index for each part
          __UpperCamelCase  		=						np.random.choice(ranges[0]				)
          __UpperCamelCase  		=						np.random.choice(ranges[1]				)
          __UpperCamelCase  		=						np.random.choice(ranges[2]				)

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

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







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

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

              if truncation == "fusion":
                  __UpperCamelCase  		=						self._np_extract_fbank_features(snake_case ,       self.mel_filters				)
                  __UpperCamelCase  		=						np.stack([input_mel, input_mel, input_mel, input_mel] ,       axis=0				)
              else:
                  __UpperCamelCase  		=						self._np_extract_fbank_features(snake_case ,       self.mel_filters_slaney				)[None, :]

          return input_mel, longer







      def __call__(     self					: List[str] ,       snake_case					: Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]] ,       snake_case					: str = None ,       snake_case					: Optional[str] = None ,       snake_case					: Optional[int] = None ,       snake_case					: Optional[int] = None ,       snake_case					: Optional[Union[str, TensorType]] = None ,       **snake_case					: Any ,       ):
          __UpperCamelCase  		=						truncation if truncation is not None else self.truncation
          __UpperCamelCase  		=						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  		=						isinstance(snake_case ,       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  		=						is_batched_numpy or (
              isinstance(snake_case ,       (list, tuple)				) and (isinstance(raw_speech[0] ,       (np.ndarray, tuple, list)				))
          )

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

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

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

          __UpperCamelCase  		=						[]
          __UpperCamelCase  		=						[]
          for mel, longer in padded_inputs:
              input_mel.append(snake_case				)
              is_longer.append(snake_case				)

          if truncation == "fusion" and sum(snake_case				) == 0:
              # if no audio is longer than 10s, then randomly select one audio to be longer
              __UpperCamelCase  		=						np.random.randint(0 ,       len(snake_case				)				)
              __UpperCamelCase  		=						True

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

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

          __UpperCamelCase  		=						{'''input_features''': input_mel, '''is_longer''': is_longer}
          __UpperCamelCase  		=						BatchFeature(snake_case				)

          if return_tensors is not None:
              __UpperCamelCase  		=						input_features.convert_to_tensors(snake_case				)

          return input_features






