



'''simple docstring'''







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


SCREAMING_SNAKE_CASE__     : str				=   logging.get_logger(__name__)




class 				__lowerCAmelCase(							lowerCAmelCase__      ):
			__snake_case  :		str		=      ['input_values', 'attention_mask']






			def __init__(   self  :							List[str]      ,       SCREAMING_SNAKE_CASE  :							List[str]=1      ,       SCREAMING_SNAKE_CASE  :							Dict=16_000      ,       SCREAMING_SNAKE_CASE  :							Tuple=128      ,       SCREAMING_SNAKE_CASE  :							List[str]=1_024      ,       SCREAMING_SNAKE_CASE  :							int=0.0      ,       SCREAMING_SNAKE_CASE  :							Optional[int]=True      ,       SCREAMING_SNAKE_CASE  :							Optional[Any]=-4.2_67_73_93      ,       SCREAMING_SNAKE_CASE  :							Dict=4.5_68_99_74      ,       SCREAMING_SNAKE_CASE  :							Optional[Any]=False      ,       **SCREAMING_SNAKE_CASE  :							str      ,       ):




					"""simple docstring"""







					super().__init__(feature_size=SCREAMING_SNAKE_CASE      ,       sampling_rate=SCREAMING_SNAKE_CASE      ,       padding_value=SCREAMING_SNAKE_CASE      ,       **SCREAMING_SNAKE_CASE	)
					SCREAMING_SNAKE_CASE_						:Union[str, Any]										=      num_mel_bins
					SCREAMING_SNAKE_CASE_						:str										=      max_length
					SCREAMING_SNAKE_CASE_						:int										=      do_normalize
					SCREAMING_SNAKE_CASE_						:Any										=      mean
					SCREAMING_SNAKE_CASE_						:Tuple										=      std
					SCREAMING_SNAKE_CASE_						:Union[str, Any]										=      return_attention_mask






			def 				_lowercase	(   self  :							Tuple      ,       SCREAMING_SNAKE_CASE  :							np.ndarray      ,       SCREAMING_SNAKE_CASE  :							int      ,       ):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:Any										=      torch.from_numpy(SCREAMING_SNAKE_CASE	).unsqueeze(0	)
					SCREAMING_SNAKE_CASE_						:Any										=      ta_kaldi.fbank(
					    SCREAMING_SNAKE_CASE      ,       htk_compat=SCREAMING_SNAKE_CASE      ,       sample_frequency=self.sampling_rate      ,       use_energy=SCREAMING_SNAKE_CASE      ,       window_type='hanning'      ,       num_mel_bins=self.num_mel_bins      ,       dither=0.0      ,       frame_shift=10      ,       )

					SCREAMING_SNAKE_CASE_						:Dict										=      fbank.shape[0]
					SCREAMING_SNAKE_CASE_						:Any										=      max_length - n_frames

					# pad or truncate, depending on difference
					if difference > 0:
							SCREAMING_SNAKE_CASE_						:List[str]										=      torch.nn.ZeroPadad((0, 0, 0, difference)	)
							SCREAMING_SNAKE_CASE_						:str										=      pad_module(SCREAMING_SNAKE_CASE	)
					elif difference < 0:
							SCREAMING_SNAKE_CASE_						:Tuple										=      fbank[0:max_length, :]

					SCREAMING_SNAKE_CASE_						:List[Any]										=      fbank.numpy()

					return fbank






			def 				_lowercase	(   self  :							List[str]      ,       SCREAMING_SNAKE_CASE  :							np.ndarray	):




					"""simple docstring"""







					return (input_values - (self.mean)) / (self.std * 2)






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




					"""simple docstring"""







					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[Any]										=      isinstance(SCREAMING_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}'	)
					SCREAMING_SNAKE_CASE_						:Tuple										=      is_batched_numpy or (
					    isinstance(SCREAMING_SNAKE_CASE      ,       (list, tuple)	) and (isinstance(raw_speech[0]      ,       (np.ndarray, tuple, list)	))
					)

					if is_batched:
							SCREAMING_SNAKE_CASE_						:Optional[Any]										=      [np.asarray(SCREAMING_SNAKE_CASE      ,       dtype=np.floataa	) for speech in raw_speech]
					elif not is_batched and not isinstance(SCREAMING_SNAKE_CASE      ,       np.ndarray	):
							SCREAMING_SNAKE_CASE_						:Dict										=      np.asarray(SCREAMING_SNAKE_CASE      ,       dtype=np.floataa	)
					elif isinstance(SCREAMING_SNAKE_CASE      ,       np.ndarray	) and raw_speech.dtype is np.dtype(np.floataa	):
							SCREAMING_SNAKE_CASE_						:str										=      raw_speech.astype(np.floataa	)

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

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

					# convert into BatchFeature
					SCREAMING_SNAKE_CASE_						:Optional[Any]										=      BatchFeature({'input_values': features}	)

					# make sure list is in array format
					SCREAMING_SNAKE_CASE_						:Union[str, Any]										=      padded_inputs.get('input_values'	)
					if isinstance(input_values[0]      ,       SCREAMING_SNAKE_CASE	):
							SCREAMING_SNAKE_CASE_						:Tuple										=      [np.asarray(SCREAMING_SNAKE_CASE      ,       dtype=np.floataa	) for feature in input_values]

					# normalization
					if self.do_normalize:
							SCREAMING_SNAKE_CASE_						:List[str]										=      [self.normalize(SCREAMING_SNAKE_CASE	) for feature in input_values]

					if return_tensors is not None:
							SCREAMING_SNAKE_CASE_						:Tuple										=      padded_inputs.convert_to_tensors(SCREAMING_SNAKE_CASE	)

					return padded_inputs





from __future__ import annotations

import unittest

from transformers import 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 import (
			    TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
			    TFXLMForMultipleChoice,
			    TFXLMForQuestionAnsweringSimple,
			    TFXLMForSequenceClassification,
			    TFXLMForTokenClassification,
			    TFXLMModel,
			    TFXLMWithLMHeadModel,
			    XLMConfig,
			)
class       _lowerCAmelCase :






			"""simple docstring"""





			def __init__(					self						:							Tuple      ,  lowercase						:							str      ,  )    ->       str:
									"""simple docstring"""







									__lowercase											=					parent
									__lowercase											=					13
									__lowercase											=					7
									__lowercase											=					True
									__lowercase											=					True
									__lowercase											=					True
									__lowercase											=					True
									__lowercase											=					True
									__lowercase											=					False
									__lowercase											=					False
									__lowercase											=					False
									__lowercase											=					2
									__lowercase											=					99
									__lowercase											=					0
									__lowercase											=					32
									__lowercase											=					2
									__lowercase											=					4
									__lowercase											=					0.1
									__lowercase											=					0.1
									__lowercase											=					512
									__lowercase											=					16
									__lowercase											=					2
									__lowercase											=					0.02
									__lowercase											=					3
									__lowercase											=					4
									__lowercase											=					"""last"""
									__lowercase											=					True
									__lowercase											=					None
									__lowercase											=					0





			def 		snake_case__      (					self						:							Dict )    ->       Tuple:
									"""simple docstring"""







									__lowercase											=					ids_tensor([self.batch_size, self.seq_length]      ,  self.vocab_size )
									__lowercase											=					random_attention_mask([self.batch_size, self.seq_length]      ,  dtype=tf.floataa )

									__lowercase											=					None
									if self.use_input_lengths:
															__lowercase											=					(
															    ids_tensor([self.batch_size]      ,  vocab_size=2 ) + self.seq_length - 2
															)  # small variation of seq_length

									__lowercase											=					None
									if self.use_token_type_ids:
															__lowercase											=					ids_tensor([self.batch_size, self.seq_length]      ,  self.n_langs )

									__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]      ,  2      ,  dtype=tf.floataa )
															__lowercase											=					ids_tensor([self.batch_size]      ,  self.num_choices )

									__lowercase											=					XLMConfig(
									    vocab_size=self.vocab_size      ,  n_special=self.n_special      ,  emb_dim=self.hidden_size      ,  n_layers=self.num_hidden_layers      ,  n_heads=self.num_attention_heads      ,  dropout=self.hidden_dropout_prob      ,  attention_dropout=self.attention_probs_dropout_prob      ,  gelu_activation=self.gelu_activation      ,  sinusoidal_embeddings=self.sinusoidal_embeddings      ,  asm=self.asm      ,  causal=self.causal      ,  n_langs=self.n_langs      ,  max_position_embeddings=self.max_position_embeddings      ,  initializer_range=self.initializer_range      ,  summary_type=self.summary_type      ,  use_proj=self.use_proj      ,  bos_token_id=self.bos_token_id      ,  )

									return (
									    config,
									    input_ids,
									    token_type_ids,
									    input_lengths,
									    sequence_labels,
									    token_labels,
									    is_impossible_labels,
									    choice_labels,
									    input_mask,
									)





			def 		snake_case__      (					self						:							List[str]      ,  lowercase						:							Tuple      ,  lowercase						:							List[Any]      ,  lowercase						:							Optional[int]      ,  lowercase						:							Optional[int]      ,  lowercase						:							Optional[Any]      ,  lowercase						:							Optional[int]      ,  lowercase						:							Optional[Any]      ,  lowercase						:							int      ,  lowercase						:							List[str]      ,  )    ->       Dict:
									"""simple docstring"""







									__lowercase											=					TFXLMModel(config=lowercase )
									__lowercase											=					{"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
									__lowercase											=					model(lowercase )

									__lowercase											=					[input_ids, input_mask]
									__lowercase											=					model(lowercase )
									self.parent.assertEqual(result.last_hidden_state.shape      ,  (self.batch_size, self.seq_length, self.hidden_size) )





			def 		snake_case__      (					self						:							Dict      ,  lowercase						:							List[str]      ,  lowercase						:							Optional[int]      ,  lowercase						:							Optional[Any]      ,  lowercase						:							List[Any]      ,  lowercase						:							Optional[Any]      ,  lowercase						:							Dict      ,  lowercase						:							Dict      ,  lowercase						:							int      ,  lowercase						:							Union[str, Any]      ,  )    ->       List[Any]:
									"""simple docstring"""







									__lowercase											=					TFXLMWithLMHeadModel(lowercase )

									__lowercase											=					{"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
									__lowercase											=					model(lowercase )

									__lowercase											=					outputs

									self.parent.assertEqual(result.logits.shape      ,  (self.batch_size, self.seq_length, self.vocab_size) )





			def 		snake_case__      (					self						:							Optional[Any]      ,  lowercase						:							Optional[Any]      ,  lowercase						:							Any      ,  lowercase						:							int      ,  lowercase						:							List[Any]      ,  lowercase						:							Any      ,  lowercase						:							int      ,  lowercase						:							List[Any]      ,  lowercase						:							List[str]      ,  lowercase						:							Optional[Any]      ,  )    ->       Dict:
									"""simple docstring"""







									__lowercase											=					TFXLMForQuestionAnsweringSimple(lowercase )

									__lowercase											=					{"""input_ids""": input_ids, """lengths""": input_lengths}

									__lowercase											=					model(lowercase )

									self.parent.assertEqual(result.start_logits.shape      ,  (self.batch_size, self.seq_length) )
									self.parent.assertEqual(result.end_logits.shape      ,  (self.batch_size, self.seq_length) )





			def 		snake_case__      (					self						:							Optional[int]      ,  lowercase						:							Tuple      ,  lowercase						:							List[str]      ,  lowercase						:							List[Any]      ,  lowercase						:							Optional[int]      ,  lowercase						:							Optional[int]      ,  lowercase						:							Any      ,  lowercase						:							Tuple      ,  lowercase						:							Any      ,  lowercase						:							Dict      ,  )    ->       List[Any]:
									"""simple docstring"""







									__lowercase											=					TFXLMForSequenceClassification(lowercase )

									__lowercase											=					{"""input_ids""": input_ids, """lengths""": input_lengths}

									__lowercase											=					model(lowercase )

									self.parent.assertEqual(result.logits.shape      ,  (self.batch_size, self.type_sequence_label_size) )





			def 		snake_case__      (					self						:							Union[str, Any]      ,  lowercase						:							List[str]      ,  lowercase						:							Optional[int]      ,  lowercase						:							List[Any]      ,  lowercase						:							Optional[int]      ,  lowercase						:							Tuple      ,  lowercase						:							Optional[Any]      ,  lowercase						:							Tuple      ,  lowercase						:							List[Any]      ,  lowercase						:							Optional[Any]      ,  )    ->       int:
									"""simple docstring"""







									__lowercase											=					self.num_labels
									__lowercase											=					TFXLMForTokenClassification(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.num_labels) )





			def 		snake_case__      (					self						:							int      ,  lowercase						:							Tuple      ,  lowercase						:							Optional[Any]      ,  lowercase						:							str      ,  lowercase						:							str      ,  lowercase						:							Dict      ,  lowercase						:							Optional[Any]      ,  lowercase						:							Optional[Any]      ,  lowercase						:							List[str]      ,  lowercase						:							List[str]      ,  )    ->       List[str]:
									"""simple docstring"""







									__lowercase											=					self.num_choices
									__lowercase											=					TFXLMForMultipleChoice(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,
									    """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) )







			def 		snake_case__      (					self						:							str )    ->       Optional[int]:
									"""simple docstring"""







									__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,
									    """langs""": token_type_ids,
									    """lengths""": input_lengths,
									}
									return config, inputs_dict





@require_tf
class       _lowerCAmelCase (			_UpperCAmelCase     ,       _UpperCAmelCase     ,       unittest.TestCase      ):






			"""simple docstring"""





			lowercase__   :	Tuple  			=      (
			    (
			        TFXLMModel,
			        TFXLMWithLMHeadModel,
			        TFXLMForSequenceClassification,
			        TFXLMForQuestionAnsweringSimple,
			        TFXLMForTokenClassification,
			        TFXLMForMultipleChoice,
			    )
			    if is_tf_available()
			    else ()
			)
			lowercase__   :	List[str]  			=      (
			    (TFXLMWithLMHeadModel,) if is_tf_available() else ()
			)  # TODO (PVP): Check other models whether language generation is also applicable
			lowercase__   :	Tuple  			=      (
			    {
			        """feature-extraction""": TFXLMModel,
			        """fill-mask""": TFXLMWithLMHeadModel,
			        """question-answering""": TFXLMForQuestionAnsweringSimple,
			        """text-classification""": TFXLMForSequenceClassification,
			        """text-generation""": TFXLMWithLMHeadModel,
			        """token-classification""": TFXLMForTokenClassification,
			        """zero-shot""": TFXLMForSequenceClassification,
			    }
			    if is_tf_available()
			    else {}
			)
			lowercase__   :	int  			=      False
			lowercase__   :	int  			=      False





			def 		snake_case__      (					self						:							Optional[int]      ,  lowercase						:							List[str]      ,  lowercase						:							Optional[Any]      ,  lowercase						:							Optional[int]      ,  lowercase						:							List[str]      ,  lowercase						:							Dict )    ->       str:
									"""simple docstring"""







									if (
									    pipeline_test_casse_name == "QAPipelineTests"
									    and tokenizer_name is not None
									    and not tokenizer_name.endswith("""Fast""" )
									):
															# `QAPipelineTests` fails for a few models when the slower tokenizer are used.
															# (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
															# TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
															return True

									return False





			def 		snake_case__      (					self						:							Tuple )    ->       List[str]:
									"""simple docstring"""







									__lowercase											=					TFXLMModelTester(self )
									__lowercase											=					ConfigTester(self      ,  config_class=lowercase      ,  emb_dim=37 )





			def 		snake_case__      (					self						:							List[str] )    ->       List[str]:
									"""simple docstring"""







									self.config_tester.run_common_tests()





			def 		snake_case__      (					self						:							List[Any] )    ->       List[Any]:
									"""simple docstring"""







									__lowercase											=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_xlm_model(*lowercase )





			def 		snake_case__      (					self						:							str )    ->       str:
									"""simple docstring"""







									__lowercase											=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_xlm_lm_head(*lowercase )





			def 		snake_case__      (					self						:							Optional[int] )    ->       Optional[int]:
									"""simple docstring"""







									__lowercase											=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_xlm_qa(*lowercase )





			def 		snake_case__      (					self						:							Optional[Any] )    ->       str:
									"""simple docstring"""







									__lowercase											=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_xlm_sequence_classif(*lowercase )





			def 		snake_case__      (					self						:							Union[str, Any] )    ->       int:
									"""simple docstring"""







									__lowercase											=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_xlm_for_token_classification(*lowercase )





			def 		snake_case__      (					self						:							Optional[Any] )    ->       Tuple:
									"""simple docstring"""







									__lowercase											=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_xlm_for_multiple_choice(*lowercase )







			@slow
			def 		snake_case__      (					self						:							Optional[int] )    ->       Optional[int]:
									"""simple docstring"""







									for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															__lowercase											=					TFXLMModel.from_pretrained(lowercase )
															self.assertIsNotNone(lowercase )





@require_tf
class       _lowerCAmelCase (			unittest.TestCase      ):






			"""simple docstring"""





			@slow
			def 		snake_case__      (					self						:							int )    ->       List[Any]:
									"""simple docstring"""







									__lowercase											=					TFXLMWithLMHeadModel.from_pretrained("""xlm-mlm-en-2048""" )
									__lowercase											=					tf.convert_to_tensor([[14, 447]]      ,  dtype=tf.intaa )  # the president
									__lowercase											=					[
									    14,
									    447,
									    14,
									    447,
									    14,
									    447,
									    14,
									    447,
									    14,
									    447,
									    14,
									    447,
									    14,
									    447,
									    14,
									    447,
									    14,
									    447,
									    14,
									    447,
									]  # the president the president the president the president the president the president the president the president the president the president
									# TODO(PVP): this and other input_ids I tried for generation give pretty bad results. Not sure why. Model might just not be made for auto-regressive inference
									__lowercase											=					model.generate(lowercase      ,  do_sample=lowercase )
									self.assertListEqual(output_ids[0].numpy().tolist()      ,  lowercase )





