



from typing import List, Optional, Union

import numpy as np
import torch
import torchaudio.compliance.kaldi as ta_kaldi

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


_lowerCamelCase         =	logging.get_logger(__name__)

class    _SCREAMING_SNAKE_CASE						(UpperCamelCase			):
     lowerCAmelCase       =      ["""input_values""", """attention_mask"""]





     def __init__(							self			:				Union[str, Any]  ,	UpperCamelCase			:				Optional[int]=1  ,	UpperCamelCase			:				Dict=1_6_0_0_0  ,	UpperCamelCase			:				int=1_2_8  ,	UpperCamelCase			:				Tuple=1_0_2_4  ,	UpperCamelCase			:				List[str]=0.0  ,	UpperCamelCase			:				str=True  ,	UpperCamelCase			:				Optional[Any]=-4.2_6_7_7_3_9_3  ,	UpperCamelCase			:				Union[str, Any]=4.5_6_8_9_9_7_4  ,	UpperCamelCase			:				Tuple=False  ,	**UpperCamelCase			:				Optional[Any]  ,	)->Union[str, Any]:
      super().__init__(feature_size=UpperCamelCase  ,	sampling_rate=UpperCamelCase  ,	padding_value=UpperCamelCase  ,	**UpperCamelCase					)
      __SCREAMING_SNAKE_CASE							:     str							=						num_mel_bins
      __SCREAMING_SNAKE_CASE							:     List[Any]							=						max_length
      __SCREAMING_SNAKE_CASE							:     Dict							=						do_normalize
      __SCREAMING_SNAKE_CASE							:     List[str]							=						mean
      __SCREAMING_SNAKE_CASE							:     Any							=						std
      __SCREAMING_SNAKE_CASE							:     Tuple							=						return_attention_mask





     def 						__snake_case     (							self			:				Any  ,	UpperCamelCase			:				np.ndarray  ,	UpperCamelCase			:				int  ,	)->np.ndarray:
      __SCREAMING_SNAKE_CASE							:     Union[str, Any]							=						torch.from_numpy(UpperCamelCase					).unsqueeze(0					)
      __SCREAMING_SNAKE_CASE							:     List[Any]							=						ta_kaldi.fbank(
          UpperCamelCase  ,	htk_compat=UpperCamelCase  ,	sample_frequency=self.sampling_rate  ,	use_energy=UpperCamelCase  ,	window_type="hanning"  ,	num_mel_bins=self.num_mel_bins  ,	dither=0.0  ,	frame_shift=1_0  ,	)

      __SCREAMING_SNAKE_CASE							:     Tuple							=						fbank.shape[0]
      __SCREAMING_SNAKE_CASE							:     Union[str, Any]							=						max_length - n_frames

      # pad or truncate, depending on difference
      if difference > 0:
       __SCREAMING_SNAKE_CASE							:     List[Any]							=						torch.nn.ZeroPadad((0, 0, 0, difference)					)
       __SCREAMING_SNAKE_CASE							:     Optional[Any]							=						pad_module(UpperCamelCase					)
      elif difference < 0:
       __SCREAMING_SNAKE_CASE							:     Union[str, Any]							=						fbank[0:max_length, :]

      __SCREAMING_SNAKE_CASE							:     Tuple							=						fbank.numpy()

      return fbank





     def 						__snake_case     (							self			:				List[Any]  ,	UpperCamelCase			:				np.ndarray					)->np.ndarray:
      return (input_values - (self.mean)) / (self.std * 2)






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

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

      __SCREAMING_SNAKE_CASE							:     List[str]							=						isinstance(UpperCamelCase  ,	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}"""					)
      __SCREAMING_SNAKE_CASE							:     Optional[Any]							=						is_batched_numpy or (
          isinstance(UpperCamelCase  ,	(list, tuple)					) and (isinstance(raw_speech[0]  ,	(np.ndarray, tuple, list)					))
      )

      if is_batched:
       __SCREAMING_SNAKE_CASE							:     int							=						[np.asarray(UpperCamelCase  ,	dtype=np.floataa					) for speech in raw_speech]
      elif not is_batched and not isinstance(UpperCamelCase  ,	np.ndarray					):
       __SCREAMING_SNAKE_CASE							:     Any							=						np.asarray(UpperCamelCase  ,	dtype=np.floataa					)
      elif isinstance(UpperCamelCase  ,	np.ndarray					) and raw_speech.dtype is np.dtype(np.floataa					):
       __SCREAMING_SNAKE_CASE							:     Optional[Any]							=						raw_speech.astype(np.floataa					)

      # always return batch
      if not is_batched:
       __SCREAMING_SNAKE_CASE							:     List[Any]							=						[raw_speech]

      # extract fbank features and pad/truncate to max_length
      __SCREAMING_SNAKE_CASE							:     Tuple							=						[self._extract_fbank_features(UpperCamelCase  ,	max_length=self.max_length					) for waveform in raw_speech]

      # convert into BatchFeature
      __SCREAMING_SNAKE_CASE							:     Optional[int]							=						BatchFeature({"input_values": features}					)

      # make sure list is in array format
      __SCREAMING_SNAKE_CASE							:     str							=						padded_inputs.get("input_values"					)
      if isinstance(input_values[0]  ,	UpperCamelCase					):
       __SCREAMING_SNAKE_CASE							:     List[str]							=						[np.asarray(UpperCamelCase  ,	dtype=np.floataa					) for feature in input_values]

      # normalization
      if self.do_normalize:
       __SCREAMING_SNAKE_CASE							:     Optional[Any]							=						[self.normalize(UpperCamelCase					) for feature in input_values]

      if return_tensors is not None:
       __SCREAMING_SNAKE_CASE							:     Dict							=						padded_inputs.convert_to_tensors(UpperCamelCase					)

      return padded_inputs







"""simple docstring"""


from __future__ import annotations

import unittest

from transformers import OpenAIGPTConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
  import tensorflow as tf

  from transformers.models.openai.modeling_tf_openai import (
      TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFOpenAIGPTDoubleHeadsModel,
      TFOpenAIGPTForSequenceClassification,
      TFOpenAIGPTLMHeadModel,
      TFOpenAIGPTModel,
  )
class   UpperCAmelCase_	:
    def __init__(	self			:       Tuple   ,						_lowercase			:       List[str]   ,						)						->    Tuple:
       _lowercase							     =       parent
       _lowercase							     =       1_3
       _lowercase							     =       7
       _lowercase							     =       True
       _lowercase							     =       True
       _lowercase							     =       True
       _lowercase							     =       True
       _lowercase							     =       True
       _lowercase							     =       9_9
       _lowercase							     =       3_2
       _lowercase							     =       2
       _lowercase							     =       4
       _lowercase							     =       3_7
       _lowercase							     =       "gelu"
       _lowercase							     =       0.1
       _lowercase							     =       0.1
       _lowercase							     =       5_1_2
       _lowercase							     =       1_6
       _lowercase							     =       2
       _lowercase							     =       0.02
       _lowercase							     =       3
       _lowercase							     =       4
       _lowercase							     =       None
       _lowercase							     =       self.vocab_size - 1
    def 		_lowerCamelCase      (	self			:       int		)						->    List[Any]:
       _lowercase							     =       ids_tensor([self.batch_size, self.seq_length]   ,						self.vocab_size		)

       _lowercase							     =       None
       if self.use_input_mask:
          _lowercase							     =       random_attention_mask([self.batch_size, self.seq_length]		)

       _lowercase							     =       None
       if self.use_token_type_ids:
          _lowercase							     =       ids_tensor([self.batch_size, self.seq_length]   ,						self.type_vocab_size		)

       _lowercase							     =       None
       if self.use_mc_token_ids:
          _lowercase							     =       ids_tensor([self.batch_size, self.num_choices]   ,						self.seq_length		)

       _lowercase							     =       None
       _lowercase							     =       None
       _lowercase							     =       None
       if self.use_labels:
          _lowercase							     =       ids_tensor([self.batch_size]   ,						self.type_sequence_label_size		)
          _lowercase							     =       ids_tensor([self.batch_size, self.seq_length]   ,						self.num_labels		)
          _lowercase							     =       ids_tensor([self.batch_size]   ,						self.num_choices		)

       _lowercase							     =       OpenAIGPTConfig(
           vocab_size=self.vocab_size   ,						n_embd=self.hidden_size   ,						n_layer=self.num_hidden_layers   ,						n_head=self.num_attention_heads   ,						n_positions=self.max_position_embeddings   ,						pad_token_id=self.pad_token_id   ,						)

       _lowercase							     =       ids_tensor([self.num_hidden_layers, self.num_attention_heads]   ,						2		)

       return (
           config,
           input_ids,
           input_mask,
           head_mask,
           token_type_ids,
           mc_token_ids,
           sequence_labels,
           token_labels,
           choice_labels,
       )
    def 		_lowerCamelCase      (	self			:       Union[str, Any]   ,						_lowercase			:       Optional[int]   ,						_lowercase			:       str   ,						_lowercase			:       Dict   ,						_lowercase			:       List[Any]   ,						_lowercase			:       int   ,						*_lowercase			:       List[str]		)						->    Optional[int]:
       _lowercase							     =       TFOpenAIGPTModel(config=_lowercase		)
       _lowercase							     =       {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
       _lowercase							     =       model(_lowercase		)

       _lowercase							     =       [input_ids, input_mask]
       _lowercase							     =       model(_lowercase		)

       _lowercase							     =       model(_lowercase		)

       self.parent.assertEqual(result.last_hidden_state.shape   ,						(self.batch_size, self.seq_length, self.hidden_size)		)
    def 		_lowerCamelCase      (	self			:       Any   ,						_lowercase			:       Optional[Any]   ,						_lowercase			:       Optional[int]   ,						_lowercase			:       str   ,						_lowercase			:       Dict   ,						_lowercase			:       List[str]   ,						*_lowercase			:       Optional[Any]		)						->    Dict:
       _lowercase							     =       TFOpenAIGPTLMHeadModel(config=_lowercase		)
       _lowercase							     =       {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
       _lowercase							     =       model(_lowercase		)
       self.parent.assertEqual(result.logits.shape   ,						(self.batch_size, self.seq_length, self.vocab_size)		)
    def 		_lowerCamelCase      (	self			:       Union[str, Any]   ,						_lowercase			:       Optional[int]   ,						_lowercase			:       int   ,						_lowercase			:       str   ,						_lowercase			:       int   ,						_lowercase			:       Optional[int]   ,						_lowercase			:       List[Any]   ,						*_lowercase			:       Tuple		)						->    Optional[int]:
       _lowercase							     =       TFOpenAIGPTDoubleHeadsModel(config=_lowercase		)

       _lowercase							     =       tf.tile(tf.expand_dims(_lowercase   ,						1		)   ,						(1, self.num_choices, 1)		)
       _lowercase							     =       tf.tile(tf.expand_dims(_lowercase   ,						1		)   ,						(1, self.num_choices, 1)		)
       _lowercase							     =       tf.tile(tf.expand_dims(_lowercase   ,						1		)   ,						(1, self.num_choices, 1)		)

       _lowercase							     =       {
           "input_ids": multiple_choice_inputs_ids,
           "mc_token_ids": mc_token_ids,
           "attention_mask": multiple_choice_input_mask,
           "token_type_ids": multiple_choice_token_type_ids,
       }
       _lowercase							     =       model(_lowercase		)
       self.parent.assertEqual(
           result.logits.shape   ,						(self.batch_size, self.num_choices, self.seq_length, self.vocab_size)		)
       self.parent.assertEqual(result.mc_logits.shape   ,						(self.batch_size, self.num_choices)		)
    def 		_lowerCamelCase      (	self			:       Union[str, Any]   ,						_lowercase			:       List[Any]   ,						_lowercase			:       Tuple   ,						_lowercase			:       Any   ,						_lowercase			:       Optional[Any]   ,						_lowercase			:       List[Any]   ,						*_lowercase			:       str		)						->    str:
       _lowercase							     =       self.num_labels
       _lowercase							     =       ids_tensor([self.batch_size]   ,						self.type_sequence_label_size		)
       _lowercase							     =       {
           "input_ids": input_ids,
           "attention_mask": input_mask,
           "token_type_ids": token_type_ids,
           "labels": sequence_labels,
       }
       _lowercase							     =       TFOpenAIGPTForSequenceClassification(_lowercase		)
       _lowercase							     =       model(_lowercase		)
       self.parent.assertEqual(result.logits.shape   ,						(self.batch_size, self.num_labels)		)




    def 		_lowerCamelCase      (	self			:       str		)						->    Tuple:
       _lowercase							     =       self.prepare_config_and_inputs()

       (
           (
           _lowercase
       )     ,  (
           _lowercase
       )     ,  (
           _lowercase
       )     ,  (
           _lowercase
       )     ,  (
           _lowercase
       )     ,  (
           _lowercase
       )     ,  (
           _lowercase
       )     ,  (
           _lowercase
       )     ,  (
           _lowercase
       )     ,  
       )							     =       config_and_inputs

       _lowercase							     =       {"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
       return config, inputs_dict
@require_tf
class   UpperCAmelCase_	(				lowercase__,    lowercase__,    unittest.TestCase   ):
    snake_case_											=      (
        (TFOpenAIGPTModel, TFOpenAIGPTLMHeadModel, TFOpenAIGPTDoubleHeadsModel, TFOpenAIGPTForSequenceClassification)
        if is_tf_available()
        else ()
    )
    snake_case_											=      (
        (TFOpenAIGPTLMHeadModel,) if is_tf_available() else ()
    )  # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly
    snake_case_											=      (
        {
            """feature-extraction""": TFOpenAIGPTModel,
            """text-classification""": TFOpenAIGPTForSequenceClassification,
            """text-generation""": TFOpenAIGPTLMHeadModel,
            """zero-shot""": TFOpenAIGPTForSequenceClassification,
        }
        if is_tf_available()
        else {}
    )
    snake_case_											=      False
    snake_case_											=      False
    def 		_lowerCamelCase      (	self			:       Optional[int]   ,						_lowercase			:       Optional[int]   ,						_lowercase			:       List[str]   ,						_lowercase			:       Tuple   ,						_lowercase			:       Union[str, Any]   ,						_lowercase			:       Any		)						->    List[str]:
       if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests":
          # Get `tokenizer does not have a padding token` error for both fast/slow tokenizers.
          # `OpenAIGPTConfig` was never used in pipeline tests, either because of a missing checkpoint or because a
          # tiny config could not be created.
          return True

       return False
    def 		_lowerCamelCase      (	self			:       Union[str, Any]		)						->    str:
       _lowercase							     =       TFOpenAIGPTModelTester(self		)
       _lowercase							     =       ConfigTester(self   ,						config_class=_lowercase   ,						n_embd=3_7		)
    def 		_lowerCamelCase      (	self			:       List[Any]		)						->    Optional[int]:
       self.config_tester.run_common_tests()
    def 		_lowerCamelCase      (	self			:       Any		)						->    List[str]:
       _lowercase							     =       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_openai_gpt_model(*_lowercase		)
    def 		_lowerCamelCase      (	self			:       Optional[int]		)						->    List[Any]:
       _lowercase							     =       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_openai_gpt_lm_head(*_lowercase		)
    def 		_lowerCamelCase      (	self			:       Optional[Any]		)						->    List[Any]:
       _lowercase							     =       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_openai_gpt_double_head(*_lowercase		)
    def 		_lowerCamelCase      (	self			:       int		)						->    Union[str, Any]:
       _lowercase							     =       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*_lowercase		)




    @slow
    def 		_lowerCamelCase      (	self			:       Tuple		)						->    Dict:
       for model_name in TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          _lowercase							     =       TFOpenAIGPTModel.from_pretrained(_lowercase		)
          self.assertIsNotNone(_lowercase		)
@require_tf
class   UpperCAmelCase_	(				unittest.TestCase   ):
    @slow
    def 		_lowerCamelCase      (	self			:       Optional[Any]		)						->    Union[str, Any]:
       _lowercase							     =       TFOpenAIGPTLMHeadModel.from_pretrained("openai-gpt"		)
       _lowercase							     =       tf.convert_to_tensor([[4_8_1, 4_7_3_5, 5_4_4]]   ,						dtype=tf.intaa		)  # the president is
       _lowercase							     =       [
           4_8_1,
           4_7_3_5,
           5_4_4,
           2_4_6,
           9_6_3,
           8_7_0,
           7_6_2,
           2_3_9,
           2_4_4,
           4_0_4_7_7,
           2_4_4,
           2_4_9,
           7_1_9,
           8_8_1,
           4_8_7,
           5_4_4,
           2_4_0,
           2_4_4,
           6_0_3,
           4_8_1,
       ]  # the president is a very good man. " \n " i\'m sure he is, " said the

       _lowercase							     =       model.generate(_lowercase   ,						do_sample=_lowercase		)
       self.assertListEqual(output_ids[0].numpy().tolist()   ,						_lowercase		)