
"""simple docstring"""






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

import numpy as np

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


lowerCamelCase__ :       str						     =			logging.get_logger(__name__)




class 				lowercase__(				_UpperCAmelCase   ):
	'''simple docstring'''

	UpperCamelCase				=  ["""input_values""", """attention_mask"""]





	def __init__(						self    :List[Any]		, lowerCamelCase_    :int = 1		, lowerCamelCase_    :int = 1_60_00		, lowerCamelCase_    :float = 0.0		, lowerCamelCase_    :bool = False		, lowerCamelCase_    :int = 80		, lowerCamelCase_    :int = 16		, lowerCamelCase_    :int = 64		, lowerCamelCase_    :str = "hann_window"		, lowerCamelCase_    :float = 1.0		, lowerCamelCase_    :float = 80		, lowerCamelCase_    :float = 76_00		, lowerCamelCase_    :float = 1E-10		, lowerCamelCase_    :int = 2		, lowerCamelCase_    :bool = True		, **lowerCamelCase_    :Dict		, )							->			Dict:







			'''simple docstring'''




			super().__init__(feature_size=lowerCamelCase_		, sampling_rate=lowerCamelCase_		, padding_value=lowerCamelCase_		, **lowerCamelCase_					)
			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= do_normalize
			SCREAMING_SNAKE_CASE       :     int				= return_attention_mask

			SCREAMING_SNAKE_CASE       :     Tuple				= num_mel_bins
			SCREAMING_SNAKE_CASE       :     Tuple				= hop_length
			SCREAMING_SNAKE_CASE       :     str				= win_length
			SCREAMING_SNAKE_CASE       :     Any				= win_function
			SCREAMING_SNAKE_CASE       :     int				= frame_signal_scale
			SCREAMING_SNAKE_CASE       :     List[Any]				= fmin
			SCREAMING_SNAKE_CASE       :     Optional[int]				= fmax
			SCREAMING_SNAKE_CASE       :     Any				= mel_floor
			SCREAMING_SNAKE_CASE       :     Optional[Any]				= reduction_factor

			SCREAMING_SNAKE_CASE       :     Dict				= win_length * sampling_rate // 10_00
			SCREAMING_SNAKE_CASE       :     List[str]				= hop_length * sampling_rate // 10_00
			SCREAMING_SNAKE_CASE       :     str				= optimal_fft_length(self.sample_size					)
			SCREAMING_SNAKE_CASE       :     Optional[int]				= (self.n_fft // 2) + 1

			SCREAMING_SNAKE_CASE       :     Optional[Any]				= window_function(window_length=self.sample_size		, name=self.win_function		, periodic=lowerCamelCase_					)

			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= mel_filter_bank(
			    num_frequency_bins=self.n_freqs		, num_mel_filters=self.num_mel_bins		, min_frequency=self.fmin		, max_frequency=self.fmax		, sampling_rate=self.sampling_rate		, norm='''slaney'''		, mel_scale='''slaney'''		, )

			if frame_signal_scale != 1.0:
					warnings.warn(
					    '''The argument `frame_signal_scale` is deprecated and will be removed in version 4.30.0 of Transformers'''		, lowerCamelCase_		, )
			if reduction_factor != 2.0:
					warnings.warn(
					    '''The argument `reduction_factor` is deprecated and will be removed in version 4.30.0 of Transformers'''		, lowerCamelCase_		, )





	@staticmethod
	# Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm
	def   __lowerCAmelCase (						lowerCamelCase_    :List[np.ndarray]		, lowerCamelCase_    :List[np.ndarray]		, lowerCamelCase_    :float = 0.0					)							->			List[np.ndarray]:







			'''simple docstring'''




			if attention_mask is not None:
					SCREAMING_SNAKE_CASE       :     Any				= np.array(lowerCamelCase_		, np.intaa					)
					SCREAMING_SNAKE_CASE       :     Optional[Any]				= []

					for vector, length in zip(lowerCamelCase_		, attention_mask.sum(-1					)					):
							SCREAMING_SNAKE_CASE       :     Dict				= (vector - vector[:length].mean()) / np.sqrt(vector[:length].var() + 1E-7					)
							if length < normed_slice.shape[0]:
									SCREAMING_SNAKE_CASE       :     str				= padding_value

							normed_input_values.append(lowerCamelCase_					)
			else:
					SCREAMING_SNAKE_CASE       :     Dict				= [(x - x.mean()) / np.sqrt(x.var() + 1E-7					) for x in input_values]

			return normed_input_values





	def   __lowerCAmelCase (						self    :str		, lowerCamelCase_    :np.ndarray		, )							->			np.ndarray:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Tuple				= spectrogram(
			    lowerCamelCase_		, window=self.window		, frame_length=self.sample_size		, hop_length=self.sample_stride		, fft_length=self.n_fft		, mel_filters=self.mel_filters		, mel_floor=self.mel_floor		, log_mel='''log10'''		, )
			return log_mel_spec.T





	def __call__(						self    :Optional[int]		, lowerCamelCase_    :Optional[Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]] = None		, lowerCamelCase_    :Optional[Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]] = None		, lowerCamelCase_    :Union[bool, str, PaddingStrategy] = False		, lowerCamelCase_    :Optional[int] = None		, lowerCamelCase_    :bool = False		, lowerCamelCase_    :Optional[int] = None		, lowerCamelCase_    :Optional[bool] = None		, lowerCamelCase_    :Optional[Union[str, TensorType]] = None		, lowerCamelCase_    :Optional[int] = None		, **lowerCamelCase_    :List[Any]		, )							->			BatchFeature:







			'''simple docstring'''




			if audio is None and audio_target is None:
					raise ValueError('''You must provide either `audio` or `audio_target` values.'''					)

			if sampling_rate is not None:
					if sampling_rate != self.sampling_rate:
							raise ValueError(
							    f"The model corresponding to this feature extractor: {self} was trained using a sampling rate of"
							    f" {self.sampling_rate}. Please make sure that the provided audio input was sampled with"
							    f" {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.'''					)

			if audio is not None:
					SCREAMING_SNAKE_CASE       :     int				= self._process_audio(
					    lowerCamelCase_		, lowerCamelCase_		, lowerCamelCase_		, lowerCamelCase_		, lowerCamelCase_		, lowerCamelCase_		, lowerCamelCase_		, lowerCamelCase_		, **lowerCamelCase_		, )
			else:
					SCREAMING_SNAKE_CASE       :     int				= None

			if audio_target is not None:
					SCREAMING_SNAKE_CASE       :     Optional[Any]				= self._process_audio(
					    lowerCamelCase_		, lowerCamelCase_		, lowerCamelCase_		, lowerCamelCase_		, lowerCamelCase_		, lowerCamelCase_		, lowerCamelCase_		, lowerCamelCase_		, **lowerCamelCase_		, )

					if inputs is None:
							return inputs_target
					else:
							SCREAMING_SNAKE_CASE       :     Tuple				= inputs_target['''input_values''']
							SCREAMING_SNAKE_CASE       :     Any				= inputs_target.get('''attention_mask'''					)
							if decoder_attention_mask is not None:
									SCREAMING_SNAKE_CASE       :     Optional[Any]				= decoder_attention_mask

			return inputs





	def   __lowerCAmelCase (						self    :int		, lowerCamelCase_    :Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]		, lowerCamelCase_    :bool = False		, lowerCamelCase_    :Union[bool, str, PaddingStrategy] = False		, lowerCamelCase_    :Optional[int] = None		, lowerCamelCase_    :bool = False		, lowerCamelCase_    :Optional[int] = None		, lowerCamelCase_    :Optional[bool] = None		, lowerCamelCase_    :Optional[Union[str, TensorType]] = None		, **lowerCamelCase_    :Optional[int]		, )							->			BatchFeature:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Optional[Any]				= isinstance(lowerCamelCase_		, np.ndarray					) and len(speech.shape					) > 1
			if is_batched_numpy and len(speech.shape					) > 2:
					raise ValueError(f"Only mono-channel audio is supported for input to {self}"					)
			SCREAMING_SNAKE_CASE       :     Tuple				= is_batched_numpy or (
			    isinstance(lowerCamelCase_		, (list, tuple)					) and (isinstance(speech[0]		, (np.ndarray, tuple, list)					))
			)

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

			# always return batch
			if not is_batched:
					SCREAMING_SNAKE_CASE       :     Any				= [speech]

			# needed to make pad() work on spectrogram inputs
			SCREAMING_SNAKE_CASE       :     Any				= self.feature_size

			# convert into correct format for padding
			if is_target:
					SCREAMING_SNAKE_CASE       :     Any				= [self._extract_mel_features(lowerCamelCase_					) for waveform in speech]
					SCREAMING_SNAKE_CASE       :     Optional[int]				= BatchFeature({'''input_values''': features}					)
					SCREAMING_SNAKE_CASE       :     Optional[Any]				= self.num_mel_bins
			else:
					SCREAMING_SNAKE_CASE       :     Union[str, Any]				= BatchFeature({'''input_values''': speech}					)

			SCREAMING_SNAKE_CASE       :     Any				= self.pad(
			    lowerCamelCase_		, padding=lowerCamelCase_		, max_length=lowerCamelCase_		, truncation=lowerCamelCase_		, pad_to_multiple_of=lowerCamelCase_		, return_attention_mask=lowerCamelCase_		, **lowerCamelCase_		, )

			SCREAMING_SNAKE_CASE       :     Any				= feature_size_hack

			# convert input values to correct format
			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= padded_inputs['''input_values''']
			if not isinstance(input_values[0]		, np.ndarray					):
					SCREAMING_SNAKE_CASE       :     Optional[int]				= [np.asarray(lowerCamelCase_		, dtype=np.floataa					) for array in input_values]
			elif (
			    not isinstance(lowerCamelCase_		, np.ndarray					)
			    and isinstance(input_values[0]		, np.ndarray					)
			    and input_values[0].dtype is np.dtype(np.floataa					)
			):
					SCREAMING_SNAKE_CASE       :     List[str]				= [array.astype(np.floataa					) for array in input_values]
			elif isinstance(lowerCamelCase_		, np.ndarray					) and input_values.dtype is np.dtype(np.floataa					):
					SCREAMING_SNAKE_CASE       :     List[str]				= input_values.astype(np.floataa					)

			# convert attention_mask to correct format
			SCREAMING_SNAKE_CASE       :     Tuple				= padded_inputs.get('''attention_mask'''					)
			if attention_mask is not None:
					SCREAMING_SNAKE_CASE       :     List[str]				= [np.asarray(lowerCamelCase_		, dtype=np.intaa					) for array in attention_mask]

			# zero-mean and unit-variance normalization
			if not is_target and self.do_normalize:
					SCREAMING_SNAKE_CASE       :     str				= (
					    attention_mask
					    if self._get_padding_strategies(lowerCamelCase_		, max_length=lowerCamelCase_					) is not PaddingStrategy.DO_NOT_PAD
					    else None
					)
					SCREAMING_SNAKE_CASE       :     List[Any]				= self.zero_mean_unit_var_norm(
					    padded_inputs['''input_values''']		, attention_mask=lowerCamelCase_		, padding_value=self.padding_value					)

			if return_tensors is not None:
					SCREAMING_SNAKE_CASE       :     Any				= padded_inputs.convert_to_tensors(lowerCamelCase_					)

			return padded_inputs







	def   __lowerCAmelCase (						self    :Optional[int]					)							->			Dict[str, Any]:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     List[str]				= super().to_dict()

			# Don't serialize these as they are derived from the other properties.
			SCREAMING_SNAKE_CASE       :     Any				= ['''window''', '''mel_filters''', '''sample_size''', '''sample_stride''', '''n_fft''', '''n_freqs''']
			for name in names:
					if name in output:
							del output[name]

			return output







"""simple docstring"""






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


lowerCamelCase__ :       Tuple						     =			logging.get_logger(__name__)

lowerCamelCase__ :       str						     =			{
    "studio-ousia/luke-base": "https://huggingface.co/studio-ousia/luke-base/resolve/main/config.json",
    "studio-ousia/luke-large": "https://huggingface.co/studio-ousia/luke-large/resolve/main/config.json",
}




class 				lowercase__(				_UpperCAmelCase   ):
	'''simple docstring'''

	UpperCamelCase				=  """luke"""





	def __init__(						self    :Optional[int]		, lowerCamelCase_    :Union[str, Any]=5_02_67		, lowerCamelCase_    :int=50_00_00		, lowerCamelCase_    :Tuple=7_68		, lowerCamelCase_    :List[str]=2_56		, lowerCamelCase_    :Dict=12		, lowerCamelCase_    :Optional[int]=12		, lowerCamelCase_    :Optional[Any]=30_72		, lowerCamelCase_    :List[Any]="gelu"		, lowerCamelCase_    :Any=0.1		, lowerCamelCase_    :Union[str, Any]=0.1		, lowerCamelCase_    :List[str]=5_12		, lowerCamelCase_    :Optional[int]=2		, lowerCamelCase_    :Tuple=0.0_2		, lowerCamelCase_    :Optional[int]=1E-12		, lowerCamelCase_    :List[Any]=True		, lowerCamelCase_    :List[str]=None		, lowerCamelCase_    :str=1		, lowerCamelCase_    :Any=0		, lowerCamelCase_    :str=2		, **lowerCamelCase_    :List[Any]		, )							->			Optional[int]:







			'''simple docstring'''




			super().__init__(pad_token_id=lowerCamelCase_		, bos_token_id=lowerCamelCase_		, eos_token_id=lowerCamelCase_		, **lowerCamelCase_					)

			SCREAMING_SNAKE_CASE       :     Dict				= vocab_size
			SCREAMING_SNAKE_CASE       :     List[str]				= entity_vocab_size
			SCREAMING_SNAKE_CASE       :     str				= hidden_size
			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= entity_emb_size
			SCREAMING_SNAKE_CASE       :     List[Any]				= num_hidden_layers
			SCREAMING_SNAKE_CASE       :     Optional[int]				= num_attention_heads
			SCREAMING_SNAKE_CASE       :     Optional[Any]				= hidden_act
			SCREAMING_SNAKE_CASE       :     Optional[Any]				= intermediate_size
			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= hidden_dropout_prob
			SCREAMING_SNAKE_CASE       :     Dict				= attention_probs_dropout_prob
			SCREAMING_SNAKE_CASE       :     Dict				= max_position_embeddings
			SCREAMING_SNAKE_CASE       :     Tuple				= type_vocab_size
			SCREAMING_SNAKE_CASE       :     str				= initializer_range
			SCREAMING_SNAKE_CASE       :     Dict				= layer_norm_eps
			SCREAMING_SNAKE_CASE       :     Optional[int]				= use_entity_aware_attention
			SCREAMING_SNAKE_CASE       :     List[str]				= classifier_dropout





