"""simple docstring"""




from __future__ import annotations

import os
import tempfile
import unittest

from transformers import ConvBertConfig, 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 (
				    TFConvBertForMaskedLM,
				    TFConvBertForMultipleChoice,
				    TFConvBertForQuestionAnswering,
				    TFConvBertForSequenceClassification,
				    TFConvBertForTokenClassification,
				    TFConvBertModel,
				)
class     UpperCamelCase__:





						def __init__(       self		,__UpperCAmelCase		,__UpperCAmelCase=13		,__UpperCAmelCase=7		,__UpperCAmelCase=True		,__UpperCAmelCase=True		,__UpperCAmelCase=True		,__UpperCAmelCase=True		,__UpperCAmelCase=99		,__UpperCAmelCase=32		,__UpperCAmelCase=2		,__UpperCAmelCase=4		,__UpperCAmelCase=37		,__UpperCAmelCase="gelu"		,__UpperCAmelCase=0.1		,__UpperCAmelCase=0.1		,__UpperCAmelCase=5_12		,__UpperCAmelCase=16		,__UpperCAmelCase=2		,__UpperCAmelCase=0.0_2		,__UpperCAmelCase=3		,__UpperCAmelCase=4		,__UpperCAmelCase=None		,)					->				Any:
													A__	     =							parent
													A__	     =							13
													A__	     =							7
													A__	     =							True
													A__	     =							True
													A__	     =							True
													A__	     =							True
													A__	     =							99
													A__	     =							3_84
													A__	     =							2
													A__	     =							4
													A__	     =							37
													A__	     =							'gelu'
													A__	     =							0.1
													A__	     =							0.1
													A__	     =							5_12
													A__	     =							16
													A__	     =							2
													A__	     =							0.0_2
													A__	     =							3
													A__	     =							4
													A__	     =							1_28
													A__	     =							2
													A__	     =							9
													A__	     =							1
													A__	     =							None





						def 				snake_case__	(       self     )					->				List[str]:
													A__	     =							ids_tensor([self.batch_size, self.seq_length]		,self.vocab_size     )

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

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

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

													A__	     =							ConvBertConfig(
													    vocab_size=self.vocab_size		,hidden_size=self.hidden_size		,num_hidden_layers=self.num_hidden_layers		,num_attention_heads=self.num_attention_heads		,intermediate_size=self.intermediate_size		,hidden_act=self.hidden_act		,hidden_dropout_prob=self.hidden_dropout_prob		,attention_probs_dropout_prob=self.attention_probs_dropout_prob		,max_position_embeddings=self.max_position_embeddings		,type_vocab_size=self.type_vocab_size		,initializer_range=self.initializer_range		,return_dict=A_		,)

													return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels





						def 				snake_case__	(       self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase     )					->				Optional[int]:
													A__	     =							TFConvBertModel(config=A_     )
													A__	     =							{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}

													A__	     =							[input_ids, input_mask]
													A__	     =							model(A_     )

													A__	     =							model(A_     )

													self.parent.assertEqual(result.last_hidden_state.shape		,(self.batch_size, self.seq_length, self.hidden_size)     )





						def 				snake_case__	(       self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase     )					->				Any:
													A__	     =							TFConvBertForMaskedLM(config=A_     )
													A__	     =							{
													    'input_ids': input_ids,
													    'attention_mask': input_mask,
													    'token_type_ids': token_type_ids,
													}
													A__	     =							model(A_     )
													self.parent.assertEqual(result.logits.shape		,(self.batch_size, self.seq_length, self.vocab_size)     )





						def 				snake_case__	(       self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase     )					->				List[str]:
													A__	     =							self.num_labels
													A__	     =							TFConvBertForSequenceClassification(config=A_     )
													A__	     =							{
													    'input_ids': input_ids,
													    'attention_mask': input_mask,
													    'token_type_ids': token_type_ids,
													}

													A__	     =							model(A_     )
													self.parent.assertEqual(result.logits.shape		,(self.batch_size, self.num_labels)     )





						def 				snake_case__	(       self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase     )					->				Tuple:
													A__	     =							self.num_choices
													A__	     =							TFConvBertForMultipleChoice(config=A_     )
													A__	     =							tf.tile(tf.expand_dims(A_		,1     )		,(1, self.num_choices, 1)     )
													A__	     =							tf.tile(tf.expand_dims(A_		,1     )		,(1, self.num_choices, 1)     )
													A__	     =							tf.tile(tf.expand_dims(A_		,1     )		,(1, self.num_choices, 1)     )
													A__	     =							{
													    'input_ids': multiple_choice_inputs_ids,
													    'attention_mask': multiple_choice_input_mask,
													    'token_type_ids': multiple_choice_token_type_ids,
													}
													A__	     =							model(A_     )
													self.parent.assertEqual(result.logits.shape		,(self.batch_size, self.num_choices)     )





						def 				snake_case__	(       self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase     )					->				str:
													A__	     =							self.num_labels
													A__	     =							TFConvBertForTokenClassification(config=A_     )
													A__	     =							{
													    'input_ids': input_ids,
													    'attention_mask': input_mask,
													    'token_type_ids': token_type_ids,
													}
													A__	     =							model(A_     )
													self.parent.assertEqual(result.logits.shape		,(self.batch_size, self.seq_length, self.num_labels)     )





						def 				snake_case__	(       self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase     )					->				Optional[Any]:
													A__	     =							TFConvBertForQuestionAnswering(config=A_     )
													A__	     =							{
													    'input_ids': input_ids,
													    'attention_mask': input_mask,
													    'token_type_ids': token_type_ids,
													}

													A__	     =							model(A_     )
													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     )					->				str:
													A__	     =							self.prepare_config_and_inputs()
													(
													    (
													    A__						
													)     ,  (
													    A__						
													)     ,  (
													    A__						
													)     ,  (
													    A__						
													)     ,  (
													    A__						
													)     ,  (
													    A__						
													)     ,  (
													    A__						
													)     ,  						
													)	     =							config_and_inputs
													A__	     =							{'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
													return config, inputs_dict






@require_tf
class     UpperCamelCase__(			_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		,						unittest.TestCase ):
						lowerCAmelCase__  :						Optional[Any]													=		(
						    (
						        TFConvBertModel,
						        TFConvBertForMaskedLM,
						        TFConvBertForQuestionAnswering,
						        TFConvBertForSequenceClassification,
						        TFConvBertForTokenClassification,
						        TFConvBertForMultipleChoice,
						    )
						    if is_tf_available()
						    else ()
						)
						lowerCAmelCase__  :						Any													=		(
						    {
						        "feature-extraction": TFConvBertModel,
						        "fill-mask": TFConvBertForMaskedLM,
						        "question-answering": TFConvBertForQuestionAnswering,
						        "text-classification": TFConvBertForSequenceClassification,
						        "token-classification": TFConvBertForTokenClassification,
						        "zero-shot": TFConvBertForSequenceClassification,
						    }
						    if is_tf_available()
						    else {}
						)
						lowerCAmelCase__  :						Tuple													=		False
						lowerCAmelCase__  :						Any													=		False
						lowerCAmelCase__  :						Optional[int]													=		False





						def 				snake_case__	(       self     )					->				Union[str, Any]:
													A__	     =							TFConvBertModelTester(self     )
													A__	     =							ConfigTester(self		,config_class=A_		,hidden_size=37     )





						def 				snake_case__	(       self     )					->				Optional[Any]:
													self.config_tester.run_common_tests()





						def 				snake_case__	(       self     )					->				Dict:
													A__	     =							self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_model(*A_     )





						def 				snake_case__	(       self     )					->				Tuple:
													A__	     =							self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_masked_lm(*A_     )





						def 				snake_case__	(       self     )					->				List[Any]:
													A__	     =							self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_multiple_choice(*A_     )





						def 				snake_case__	(       self     )					->				str:
													A__	     =							self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_question_answering(*A_     )





						def 				snake_case__	(       self     )					->				Any:
													A__	     =							self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_sequence_classification(*A_     )





						def 				snake_case__	(       self     )					->				Union[str, Any]:
													A__	     =							self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_token_classification(*A_     )





						@slow
						def 				snake_case__	(       self     )					->				int:
													A__     ,  A__	     =							self.model_tester.prepare_config_and_inputs_for_common()
													A__	     =							True
													A__	     =							True

													if hasattr(A_		,'use_cache'     ):
																				A__	     =							True

													A__	     =							getattr(self.model_tester		,'encoder_seq_length'		,self.model_tester.seq_length     )
													A__	     =							getattr(self.model_tester		,'key_length'		,A_     )

													for model_class in self.all_model_classes:
																				A__	     =							self._prepare_for_class(A_		,A_     )
																				A__	     =							model_class(A_     )
																				A__	     =							len(model(A_     )     )

																				with tempfile.TemporaryDirectory() as tmpdirname:
																											model.save_pretrained(A_		,saved_model=A_     )
																											A__	     =							os.path.join(A_		,'saved_model'		,'1'     )
																											A__	     =							tf.keras.models.load_model(A_     )
																											A__	     =							model(A_     )

																											if self.is_encoder_decoder:
																																		A__	     =							outputs['encoder_hidden_states']
																																		A__	     =							outputs['encoder_attentions']
																											else:
																																		A__	     =							outputs['hidden_states']
																																		A__	     =							outputs['attentions']

																											self.assertEqual(len(A_     )		,A_     )

																											A__	     =							getattr(
																											    self.model_tester		,'expected_num_hidden_layers'		,self.model_tester.num_hidden_layers + 1     )

																											self.assertEqual(len(A_     )		,A_     )
																											self.assertListEqual(
																											    list(output_hidden_states[0].shape[-2:]     )		,[self.model_tester.seq_length, self.model_tester.hidden_size]		,)

																											self.assertEqual(len(A_     )		,self.model_tester.num_hidden_layers     )
																											self.assertListEqual(
																											    list(output_attentions[0].shape[-3:]     )		,[self.model_tester.num_attention_heads / 2, encoder_seq_length, encoder_key_length]		,)





						@slow
						def 				snake_case__	(       self     )					->				Optional[int]:
													A__	     =							TFConvBertModel.from_pretrained('YituTech/conv-bert-base'     )
													self.assertIsNotNone(A_     )





						def 				snake_case__	(       self     )					->				Any:
													A__     ,  A__	     =							self.model_tester.prepare_config_and_inputs_for_common()
													A__	     =							True
													A__	     =							getattr(self.model_tester		,'decoder_seq_length'		,self.model_tester.seq_length     )
													A__	     =							getattr(self.model_tester		,'encoder_seq_length'		,self.model_tester.seq_length     )
													A__	     =							getattr(self.model_tester		,'key_length'		,A_     )
													A__	     =							getattr(self.model_tester		,'key_length'		,A_     )

													def check_decoder_attentions_output(__UpperCAmelCase     ):
																				A__	     =							len(A_     )
																				self.assertEqual(out_len % 2		,0     )
																				A__	     =							outputs.decoder_attentions
																				self.assertEqual(len(A_     )		,self.model_tester.num_hidden_layers     )
																				self.assertListEqual(
																				    list(decoder_attentions[0].shape[-3:]     )		,[self.model_tester.num_attention_heads / 2, decoder_seq_length, decoder_key_length]		,)

													def check_encoder_attentions_output(__UpperCAmelCase     ):
																				A__	     =							[
																				    t.numpy() for t in (outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions)
																				]
																				self.assertEqual(len(A_     )		,self.model_tester.num_hidden_layers     )
																				self.assertListEqual(
																				    list(attentions[0].shape[-3:]     )		,[self.model_tester.num_attention_heads / 2, encoder_seq_length, encoder_key_length]		,)

													for model_class in self.all_model_classes:
																				A__	     =							True
																				A__	     =							False
																				A__	     =							model_class(A_     )
																				A__	     =							model(self._prepare_for_class(A_		,A_     )     )
																				A__	     =							len(A_     )
																				self.assertEqual(config.output_hidden_states		,A_     )
																				check_encoder_attentions_output(A_     )

																				if self.is_encoder_decoder:
																											A__	     =							model_class(A_     )
																											A__	     =							model(self._prepare_for_class(A_		,A_     )     )
																											self.assertEqual(config.output_hidden_states		,A_     )
																											check_decoder_attentions_output(A_     )

																				# Check that output attentions can also be changed via the config
																				del inputs_dict["output_attentions"]
																				A__	     =							True
																				A__	     =							model_class(A_     )
																				A__	     =							model(self._prepare_for_class(A_		,A_     )     )
																				self.assertEqual(config.output_hidden_states		,A_     )
																				check_encoder_attentions_output(A_     )

																				# Check attention is always last and order is fine
																				A__	     =							True
																				A__	     =							True
																				A__	     =							model_class(A_     )
																				A__	     =							model(self._prepare_for_class(A_		,A_     )     )

																				self.assertEqual(out_len + (2 if self.is_encoder_decoder else 1)		,len(A_     )     )
																				self.assertEqual(model.config.output_hidden_states		,A_     )
																				check_encoder_attentions_output(A_     )






@require_tf
class     UpperCamelCase__(			unittest.TestCase ):





						@slow
						def 				snake_case__	(       self     )					->				List[Any]:
													A__	     =							TFConvBertModel.from_pretrained('YituTech/conv-bert-base'     )
													A__	     =							tf.constant([[0, 1, 2, 3, 4, 5]]     )
													A__	     =							model(A_     )[0]

													A__	     =							[1, 6, 7_68]
													self.assertEqual(output.shape		,A_     )

													A__	     =							tf.constant(
													    [
													        [
													            [-0.0_3_4_7_5_4_9_3, -0.4_6_8_6_0_3_4, -0.3_0_6_3_8_8_3_2],
													            [0.2_2_6_3_7_2_4_8, -0.2_6_9_8_8_6_4_6, -0.7_4_2_3_4_2_4],
													            [0.1_0_3_2_4_8_6_8, -0.4_5_0_1_3_5_0_8, -0.5_8_2_8_0_7_8_4],
													        ]
													    ]     )
													tf.debugging.assert_near(output[:, :3, :3]		,A_		,atol=1e-4     )






"""simple docstring"""




from math import cos, sin, sqrt, tau

from audio_filters.iir_filter import IIRFilter






def   UpperCAmelCase					(	UpperCamelCase__       ,    UpperCamelCase__       ,    UpperCamelCase__ = 1 / sqrt(2				)				):






							"""simple docstring"""





							A__	     =							tau * frequency / samplerate
							A__	     =							sin(UpperCamelCase__				)
							A__	     =							cos(UpperCamelCase__				)
							A__	     =							_sin / (2 * q_factor)

							A__	     =							(1 - _cos) / 2
							A__	     =							1 - _cos

							A__	     =							1 + alpha
							A__	     =							-2 * _cos
							A__	     =							1 - alpha

							A__	     =							IIRFilter(2				)
							filt.set_coefficients([aa, aa, aa]       ,    [ba, ba, ba]				)
							return filt






def   UpperCAmelCase					(	UpperCamelCase__       ,    UpperCamelCase__       ,    UpperCamelCase__ = 1 / sqrt(2				)				):






							"""simple docstring"""





							A__	     =							tau * frequency / samplerate
							A__	     =							sin(UpperCamelCase__				)
							A__	     =							cos(UpperCamelCase__				)
							A__	     =							_sin / (2 * q_factor)

							A__	     =							(1 + _cos) / 2
							A__	     =							-1 - _cos

							A__	     =							1 + alpha
							A__	     =							-2 * _cos
							A__	     =							1 - alpha

							A__	     =							IIRFilter(2				)
							filt.set_coefficients([aa, aa, aa]       ,    [ba, ba, ba]				)
							return filt






def   UpperCAmelCase					(	UpperCamelCase__       ,    UpperCamelCase__       ,    UpperCamelCase__ = 1 / sqrt(2				)				):






							"""simple docstring"""





							A__	     =							tau * frequency / samplerate
							A__	     =							sin(UpperCamelCase__				)
							A__	     =							cos(UpperCamelCase__				)
							A__	     =							_sin / (2 * q_factor)

							A__	     =							_sin / 2
							A__	     =							0
							A__	     =							-ba

							A__	     =							1 + alpha
							A__	     =							-2 * _cos
							A__	     =							1 - alpha

							A__	     =							IIRFilter(2				)
							filt.set_coefficients([aa, aa, aa]       ,    [ba, ba, ba]				)
							return filt






def   UpperCAmelCase					(	UpperCamelCase__       ,    UpperCamelCase__       ,    UpperCamelCase__ = 1 / sqrt(2				)				):






							"""simple docstring"""





							A__	     =							tau * frequency / samplerate
							A__	     =							sin(UpperCamelCase__				)
							A__	     =							cos(UpperCamelCase__				)
							A__	     =							_sin / (2 * q_factor)

							A__	     =							1 - alpha
							A__	     =							-2 * _cos
							A__	     =							1 + alpha

							A__	     =							IIRFilter(2				)
							filt.set_coefficients([ba, ba, ba]       ,    [ba, ba, ba]				)
							return filt






def   UpperCAmelCase					(	UpperCamelCase__       ,    UpperCamelCase__       ,    UpperCamelCase__       ,    UpperCamelCase__ = 1 / sqrt(2				)       ,    ):






							"""simple docstring"""





							A__	     =							tau * frequency / samplerate
							A__	     =							sin(UpperCamelCase__				)
							A__	     =							cos(UpperCamelCase__				)
							A__	     =							_sin / (2 * q_factor)
							A__	     =							10 ** (gain_db / 40)

							A__	     =							1 + alpha * big_a
							A__	     =							-2 * _cos
							A__	     =							1 - alpha * big_a
							A__	     =							1 + alpha / big_a
							A__	     =							-2 * _cos
							A__	     =							1 - alpha / big_a

							A__	     =							IIRFilter(2				)
							filt.set_coefficients([aa, aa, aa]       ,    [ba, ba, ba]				)
							return filt






def   UpperCAmelCase					(	UpperCamelCase__       ,    UpperCamelCase__       ,    UpperCamelCase__       ,    UpperCamelCase__ = 1 / sqrt(2				)       ,    ):






							"""simple docstring"""





							A__	     =							tau * frequency / samplerate
							A__	     =							sin(UpperCamelCase__				)
							A__	     =							cos(UpperCamelCase__				)
							A__	     =							_sin / (2 * q_factor)
							A__	     =							10 ** (gain_db / 40)
							A__	     =							(big_a + 1) - (big_a - 1) * _cos
							A__	     =							(big_a + 1) + (big_a - 1) * _cos
							A__	     =							(big_a - 1) - (big_a + 1) * _cos
							A__	     =							(big_a - 1) + (big_a + 1) * _cos
							A__	     =							2 * sqrt(UpperCamelCase__				) * alpha

							A__	     =							big_a * (pmc + aaa)
							A__	     =							2 * big_a * mpc
							A__	     =							big_a * (pmc - aaa)
							A__	     =							ppmc + aaa
							A__	     =							-2 * pmpc
							A__	     =							ppmc - aaa

							A__	     =							IIRFilter(2				)
							filt.set_coefficients([aa, aa, aa]       ,    [ba, ba, ba]				)
							return filt






def   UpperCAmelCase					(	UpperCamelCase__       ,    UpperCamelCase__       ,    UpperCamelCase__       ,    UpperCamelCase__ = 1 / sqrt(2				)       ,    ):






							"""simple docstring"""





							A__	     =							tau * frequency / samplerate
							A__	     =							sin(UpperCamelCase__				)
							A__	     =							cos(UpperCamelCase__				)
							A__	     =							_sin / (2 * q_factor)
							A__	     =							10 ** (gain_db / 40)
							A__	     =							(big_a + 1) - (big_a - 1) * _cos
							A__	     =							(big_a + 1) + (big_a - 1) * _cos
							A__	     =							(big_a - 1) - (big_a + 1) * _cos
							A__	     =							(big_a - 1) + (big_a + 1) * _cos
							A__	     =							2 * sqrt(UpperCamelCase__				) * alpha

							A__	     =							big_a * (ppmc + aaa)
							A__	     =							-2 * big_a * pmpc
							A__	     =							big_a * (ppmc - aaa)
							A__	     =							pmc + aaa
							A__	     =							2 * mpc
							A__	     =							pmc - aaa

							A__	     =							IIRFilter(2				)
							filt.set_coefficients([aa, aa, aa]       ,    [ba, ba, ba]				)
							return filt





