




"""simple docstring"""







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

import numpy as np

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   :  int					=      logging.get_logger(__name__)




class       lowerCAmelCase__       (			lowerCAmelCase_    ):


				"""simple docstring"""





				__UpperCAmelCase :     Tuple       =      ["input_features"]



				def __init__(     self					:	Union[str, Any]    ,   lowercase__					:	Optional[int]=8_0    ,   lowercase__					:	str=1_6_0_0_0    ,   lowercase__					:	int=1_6_0    ,   lowercase__					:	int=3_0    ,   lowercase__					:	Union[str, Any]=4_0_0    ,   lowercase__					:	Union[str, Any]=0.0    ,   lowercase__					:	Any=False    ,   **lowercase__					:	Optional[Any]    ,   ):
						super().__init__(
						    feature_size=lowercase__    ,   sampling_rate=lowercase__    ,   padding_value=lowercase__    ,   return_attention_mask=lowercase__    ,   **lowercase__    ,   )
						__lowercase				:		str												=				n_fft
						__lowercase				:		Union[str, Any]												=				hop_length
						__lowercase				:		List[str]												=				chunk_length
						__lowercase				:		Union[str, Any]												=				chunk_length * sampling_rate
						__lowercase				:		Any												=				self.n_samples // hop_length
						__lowercase				:		int												=				sampling_rate
						__lowercase				:		Optional[int]												=				mel_filter_bank(
						    num_frequency_bins=1 + n_fft // 2    ,   num_mel_filters=lowercase__    ,   min_frequency=0.0    ,   max_frequency=8_0_0_0.0    ,   sampling_rate=lowercase__    ,   norm="slaney"    ,   mel_scale="slaney"    ,   )



				def       snake_case    (     self					:	Tuple    ,   lowercase__					:	np.array						):
						__lowercase				:		List[str]												=				spectrogram(
						    lowercase__    ,   window_function(self.n_fft    ,   "hann"						)    ,   frame_length=self.n_fft    ,   hop_length=self.hop_length    ,   power=2.0    ,   mel_filters=self.mel_filters    ,   log_mel="log10"    ,   )
						__lowercase				:		List[Any]												=				log_spec[:, :-1]
						__lowercase				:		Any												=				np.maximum(lowercase__    ,   log_spec.max() - 8.0						)
						__lowercase				:		int												=				(log_spec + 4.0) / 4.0
						return log_spec



				@staticmethod
				# Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm
				def       snake_case    (     lowercase__					:	List[np.ndarray]    ,   lowercase__					:	List[np.ndarray]    ,   lowercase__					:	float = 0.0						):
						if attention_mask is not None:
								__lowercase				:		List[Any]												=				np.array(lowercase__    ,   np.intaa						)
								__lowercase				:		Optional[Any]												=				[]

								for vector, length in zip(lowercase__    ,   attention_mask.sum(-1						)						):
										__lowercase				:		Optional[int]												=				(vector - vector[:length].mean()) / np.sqrt(vector[:length].var() + 1e-7						)
										if length < normed_slice.shape[0]:
												__lowercase				:		int												=				padding_value

										normed_input_values.append(lowercase__						)
						else:
								__lowercase				:		Any												=				[(x - x.mean()) / np.sqrt(x.var() + 1e-7						) for x in input_values]

						return normed_input_values



				def __call__(     self					:	List[Any]    ,   lowercase__					:	Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]    ,   lowercase__					:	bool = True    ,   lowercase__					:	Optional[int] = None    ,   lowercase__					:	Optional[Union[str, TensorType]] = None    ,   lowercase__					:	Optional[bool] = None    ,   lowercase__					:	Optional[str] = "max_length"    ,   lowercase__					:	Optional[int] = None    ,   lowercase__					:	Optional[int] = None    ,   lowercase__					:	Optional[bool] = None    ,   **lowercase__					:	str    ,   ):

						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."						)

						__lowercase				:		Optional[int]												=				isinstance(lowercase__    ,   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}'						)
						__lowercase				:		Union[str, Any]												=				is_batched_numpy or (
						    isinstance(lowercase__    ,   (list, tuple)						) and (isinstance(raw_speech[0]    ,   (np.ndarray, tuple, list)						))
						)

						if is_batched:
								__lowercase				:		List[str]												=				[np.asarray([speech]    ,   dtype=np.floataa						).T for speech in raw_speech]
						elif not is_batched and not isinstance(lowercase__    ,   np.ndarray						):
								__lowercase				:		Tuple												=				np.asarray(lowercase__    ,   dtype=np.floataa						)
						elif isinstance(lowercase__    ,   np.ndarray						) and raw_speech.dtype is np.dtype(np.floataa						):
								__lowercase				:		Tuple												=				raw_speech.astype(np.floataa						)

						# always return batch
						if not is_batched:
								__lowercase				:		int												=				[np.asarray([raw_speech]						).T]

						__lowercase				:		Dict												=				BatchFeature({"input_features": raw_speech}						)

						# convert into correct format for padding

						__lowercase				:		Tuple												=				self.pad(
						    lowercase__    ,   padding=lowercase__    ,   max_length=max_length if max_length else self.n_samples    ,   truncation=lowercase__    ,   pad_to_multiple_of=lowercase__    ,   return_attention_mask=return_attention_mask or do_normalize    ,   )

						# zero-mean and unit-variance normalization
						if do_normalize:
								__lowercase				:		Optional[int]												=				self.zero_mean_unit_var_norm(
								    padded_inputs["input_features"]    ,   attention_mask=padded_inputs["attention_mask"]    ,   padding_value=self.padding_value    ,   )
								__lowercase				:		Optional[Any]												=				np.stack(padded_inputs["input_features"]    ,   axis=0						)

						# make sure list is in array format
						__lowercase				:		Optional[int]												=				padded_inputs.get("input_features"						).transpose(2    ,   0    ,   1						)

						__lowercase				:		int												=				[self._np_extract_fbank_features(lowercase__						) for waveform in input_features[0]]

						if isinstance(input_features[0]    ,   lowercase__						):
								__lowercase				:		Union[str, Any]												=				[np.asarray(lowercase__    ,   dtype=np.floataa						) for feature in input_features]
						else:
								__lowercase				:		Optional[Any]												=				input_features

						if return_attention_mask:
								# rescale from sample (48000) to feature (3000)
								__lowercase				:		int												=				padded_inputs["attention_mask"][:, :: self.hop_length]

						if return_tensors is not None:
								__lowercase				:		List[str]												=				padded_inputs.convert_to_tensors(lowercase__						)

						return padded_inputs



				def       snake_case    (     self					:	List[str]						):
						__lowercase				:		str												=				copy.deepcopy(self.__dict__						)
						__lowercase				:		int												=				self.__class__.__name__
						if "mel_filters" in output:
								del output["mel_filters"]
						return output






"""simple docstring"""







from ...configuration_utils import PretrainedConfig
from ...utils import logging


__A   :  str					=      logging.get_logger(__name__)

__A   :  str					=      {
    'uclanlp/visualbert-vqa': 'https://huggingface.co/uclanlp/visualbert-vqa/resolve/main/config.json',
    'uclanlp/visualbert-vqa-pre': 'https://huggingface.co/uclanlp/visualbert-vqa-pre/resolve/main/config.json',
    'uclanlp/visualbert-vqa-coco-pre': (
        'https://huggingface.co/uclanlp/visualbert-vqa-coco-pre/resolve/main/config.json'
    ),
    'uclanlp/visualbert-vcr': 'https://huggingface.co/uclanlp/visualbert-vcr/resolve/main/config.json',
    'uclanlp/visualbert-vcr-pre': 'https://huggingface.co/uclanlp/visualbert-vcr-pre/resolve/main/config.json',
    'uclanlp/visualbert-vcr-coco-pre': (
        'https://huggingface.co/uclanlp/visualbert-vcr-coco-pre/resolve/main/config.json'
    ),
    'uclanlp/visualbert-nlvr2': 'https://huggingface.co/uclanlp/visualbert-nlvr2/resolve/main/config.json',
    'uclanlp/visualbert-nlvr2-pre': 'https://huggingface.co/uclanlp/visualbert-nlvr2-pre/resolve/main/config.json',
    'uclanlp/visualbert-nlvr2-coco-pre': (
        'https://huggingface.co/uclanlp/visualbert-nlvr2-coco-pre/resolve/main/config.json'
    )
    # See all VisualBERT models at https://huggingface.co/models?filter=visual_bert
}




class       lowerCAmelCase__       (			lowerCAmelCase_    ):


				"""simple docstring"""





				__UpperCAmelCase :     Tuple       =      "visual_bert"



				def __init__(     self					:	List[Any]    ,   lowercase__					:	Dict=3_0_5_2_2    ,   lowercase__					:	Any=7_6_8    ,   lowercase__					:	Dict=5_1_2    ,   lowercase__					:	Tuple=1_2    ,   lowercase__					:	Any=1_2    ,   lowercase__					:	Union[str, Any]=3_0_7_2    ,   lowercase__					:	Tuple="gelu"    ,   lowercase__					:	Dict=0.1    ,   lowercase__					:	Tuple=0.1    ,   lowercase__					:	str=5_1_2    ,   lowercase__					:	str=2    ,   lowercase__					:	Any=0.0_2    ,   lowercase__					:	Any=1e-12    ,   lowercase__					:	Any=False    ,   lowercase__					:	List[str]=True    ,   lowercase__					:	Dict=1    ,   lowercase__					:	List[Any]=0    ,   lowercase__					:	Tuple=2    ,   **lowercase__					:	Any    ,   ):
						super().__init__(pad_token_id=lowercase__    ,   bos_token_id=lowercase__    ,   eos_token_id=lowercase__    ,   **lowercase__						)

						__lowercase				:		Optional[int]												=				vocab_size
						__lowercase				:		Any												=				max_position_embeddings
						__lowercase				:		Optional[Any]												=				hidden_size
						__lowercase				:		List[str]												=				visual_embedding_dim
						__lowercase				:		Dict												=				num_hidden_layers
						__lowercase				:		Any												=				num_attention_heads
						__lowercase				:		str												=				intermediate_size
						__lowercase				:		Dict												=				hidden_act
						__lowercase				:		Any												=				hidden_dropout_prob
						__lowercase				:		Optional[int]												=				attention_probs_dropout_prob
						__lowercase				:		Dict												=				initializer_range
						__lowercase				:		str												=				type_vocab_size
						__lowercase				:		List[Any]												=				layer_norm_eps
						__lowercase				:		Tuple												=				bypass_transformer
						__lowercase				:		List[str]												=				special_visual_initialize
