




from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


UpperCamelCase__       				=	{
    '''configuration_big_bird''': ['''BIG_BIRD_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''BigBirdConfig''', '''BigBirdOnnxConfig'''],
}

try:
  if not is_sentencepiece_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  UpperCamelCase__       				=	['''BigBirdTokenizer''']

try:
  if not is_tokenizers_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  UpperCamelCase__       				=	['''BigBirdTokenizerFast''']

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  UpperCamelCase__       				=	[
      '''BIG_BIRD_PRETRAINED_MODEL_ARCHIVE_LIST''',
      '''BigBirdForCausalLM''',
      '''BigBirdForMaskedLM''',
      '''BigBirdForMultipleChoice''',
      '''BigBirdForPreTraining''',
      '''BigBirdForQuestionAnswering''',
      '''BigBirdForSequenceClassification''',
      '''BigBirdForTokenClassification''',
      '''BigBirdLayer''',
      '''BigBirdModel''',
      '''BigBirdPreTrainedModel''',
      '''load_tf_weights_in_big_bird''',
  ]

try:
  if not is_flax_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  UpperCamelCase__       				=	[
      '''FlaxBigBirdForCausalLM''',
      '''FlaxBigBirdForMaskedLM''',
      '''FlaxBigBirdForMultipleChoice''',
      '''FlaxBigBirdForPreTraining''',
      '''FlaxBigBirdForQuestionAnswering''',
      '''FlaxBigBirdForSequenceClassification''',
      '''FlaxBigBirdForTokenClassification''',
      '''FlaxBigBirdModel''',
      '''FlaxBigBirdPreTrainedModel''',
  ]

if TYPE_CHECKING:
  from .configuration_big_bird import BIG_BIRD_PRETRAINED_CONFIG_ARCHIVE_MAP, BigBirdConfig, BigBirdOnnxConfig

  try:
    if not is_sentencepiece_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .tokenization_big_bird import BigBirdTokenizer

  try:
    if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .tokenization_big_bird_fast import BigBirdTokenizerFast

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_big_bird import (
        BIG_BIRD_PRETRAINED_MODEL_ARCHIVE_LIST,
        BigBirdForCausalLM,
        BigBirdForMaskedLM,
        BigBirdForMultipleChoice,
        BigBirdForPreTraining,
        BigBirdForQuestionAnswering,
        BigBirdForSequenceClassification,
        BigBirdForTokenClassification,
        BigBirdLayer,
        BigBirdModel,
        BigBirdPreTrainedModel,
        load_tf_weights_in_big_bird,
    )

  try:
    if not is_flax_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_flax_big_bird import (
        FlaxBigBirdForCausalLM,
        FlaxBigBirdForMaskedLM,
        FlaxBigBirdForMultipleChoice,
        FlaxBigBirdForPreTraining,
        FlaxBigBirdForQuestionAnswering,
        FlaxBigBirdForSequenceClassification,
        FlaxBigBirdForTokenClassification,
        FlaxBigBirdModel,
        FlaxBigBirdPreTrainedModel,
    )

else:
  import sys

  UpperCamelCase__       				=	_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)






from typing import List, Optional, Union

import numpy as np

from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import PaddingStrategy, TensorType, logging


UpperCamelCase__       				=	logging.get_logger(__name__)
class 							__lowercase   (			a__    ):
     _lowerCAmelCase		       =						["input_values", "attention_mask"]



     def __init__(  self   :							Union[str, Any]      ,		lowercase__   :							str=1      ,		lowercase__   :							int=1_6_0_0_0      ,		lowercase__   :							Optional[int]=0.0      ,		lowercase__   :							List[Any]=False      ,		lowercase__   :							Dict=True      ,		**lowercase__   :							Any      ,		):
       super().__init__(feature_size=lowercase__      ,		sampling_rate=lowercase__      ,		padding_value=lowercase__      ,		**lowercase__       )
       a_		    =  return_attention_mask
       a_		    =  do_normalize



     @staticmethod
     def 				__magic_name__		(  lowercase__   :							List[np.ndarray]      ,		lowercase__   :							List[np.ndarray]      ,		lowercase__   :							float = 0.0       ):
       if attention_mask is not None:
         a_		    =  np.array(lowercase__      ,		np.intaa       )
         a_		    =  []

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

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

       return normed_input_values



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

       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 `raw_speech` 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.'''       )

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

       # always return batch
       if not is_batched:
         a_		    =  [raw_speech]

       # convert into correct format for padding
       a_		    =  BatchFeature({'''input_values''': raw_speech}       )

       a_		    =  self.pad(
           lowercase__      ,		padding=lowercase__      ,		max_length=lowercase__      ,		truncation=lowercase__      ,		pad_to_multiple_of=lowercase__      ,		return_attention_mask=lowercase__      ,		)

       # convert input values to correct format
       a_		    =  padded_inputs['''input_values''']
       if not isinstance(input_values[0]      ,		np.ndarray       ):
         a_		    =  [np.asarray(lowercase__      ,		dtype=np.floataa       ) for array in input_values]
       elif (
           not isinstance(lowercase__      ,		np.ndarray       )
           and isinstance(input_values[0]      ,		np.ndarray       )
           and input_values[0].dtype is np.dtype(np.floataa       )
       ):
         a_		    =  [array.astype(np.floataa       ) for array in input_values]
       elif isinstance(lowercase__      ,		np.ndarray       ) and input_values.dtype is np.dtype(np.floataa       ):
         a_		    =  input_values.astype(np.floataa       )

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

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

       if return_tensors is not None:
         a_		    =  padded_inputs.convert_to_tensors(lowercase__       )

       return padded_inputs
