






import unittest

from transformers import SqueezeBertConfig, is_torch_available
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
					import torch

					from transformers import (
					    SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
					    SqueezeBertForMaskedLM,
					    SqueezeBertForMultipleChoice,
					    SqueezeBertForQuestionAnswering,
					    SqueezeBertForSequenceClassification,
					    SqueezeBertForTokenClassification,
					    SqueezeBertModel,
					)
class     lowerCamelCase_					(   lowerCamelCase			):







				def __init__(    self							,       __lowerCAmelCase							,       __lowerCAmelCase=1_3							,       __lowerCAmelCase=7							,       __lowerCAmelCase=True							,       __lowerCAmelCase=True							,       __lowerCAmelCase=False							,       __lowerCAmelCase=True							,       __lowerCAmelCase=9_9							,       __lowerCAmelCase=3_2							,       __lowerCAmelCase=5							,       __lowerCAmelCase=4							,       __lowerCAmelCase=6_4							,       __lowerCAmelCase="gelu"							,       __lowerCAmelCase=0.1							,       __lowerCAmelCase=0.1							,       __lowerCAmelCase=5_1_2							,       __lowerCAmelCase=1_6							,       __lowerCAmelCase=2							,       __lowerCAmelCase=0.02							,       __lowerCAmelCase=3							,       __lowerCAmelCase=4							,       __lowerCAmelCase=None							,       __lowerCAmelCase=2							,       __lowerCAmelCase=2							,       __lowerCAmelCase=2							,       __lowerCAmelCase=2							,       __lowerCAmelCase=4							,       __lowerCAmelCase=1							,       ):
								"""simple docstring"""
								__magic_name__		:Union[str, Any]   =   parent
								__magic_name__		:int   =   batch_size
								__magic_name__		:int   =   seq_length
								__magic_name__		:List[Any]   =   is_training
								__magic_name__		:Any   =   use_input_mask
								__magic_name__		:List[Any]   =   use_token_type_ids
								__magic_name__		:Any   =   use_labels
								__magic_name__		:str   =   vocab_size
								__magic_name__		:Tuple   =   hidden_size
								__magic_name__		:List[str]   =   num_hidden_layers
								__magic_name__		:Dict   =   num_attention_heads
								__magic_name__		:str   =   intermediate_size
								__magic_name__		:Optional[int]   =   hidden_act
								__magic_name__		:List[Any]   =   hidden_dropout_prob
								__magic_name__		:List[str]   =   attention_probs_dropout_prob
								__magic_name__		:List[str]   =   max_position_embeddings
								__magic_name__		:Union[str, Any]   =   type_vocab_size
								__magic_name__		:int   =   type_sequence_label_size
								__magic_name__		:Optional[Any]   =   initializer_range
								__magic_name__		:int   =   num_labels
								__magic_name__		:Tuple   =   num_choices
								__magic_name__		:Optional[int]   =   scope
								__magic_name__		:Tuple   =   q_groups
								__magic_name__		:List[str]   =   k_groups
								__magic_name__		:str   =   v_groups
								__magic_name__		:Optional[Any]   =   post_attention_groups
								__magic_name__		:List[str]   =   intermediate_groups
								__magic_name__		:int   =   output_groups







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:Tuple   =   ids_tensor([self.batch_size, self.seq_length]							,       self.vocab_size  )

								__magic_name__		:List[Any]   =   None
								if self.use_input_mask:
												__magic_name__		:Dict   =   random_attention_mask([self.batch_size, self.seq_length]  )

								__magic_name__		:int   =   None
								__magic_name__		:Optional[Any]   =   None
								__magic_name__		:Union[str, Any]   =   None
								if self.use_labels:
												__magic_name__		:Optional[int]   =   ids_tensor([self.batch_size]							,       self.type_sequence_label_size  )
												__magic_name__		:List[str]   =   ids_tensor([self.batch_size, self.seq_length]							,       self.num_labels  )
												__magic_name__		:Dict   =   ids_tensor([self.batch_size]							,       self.num_choices  )

								__magic_name__		:Optional[int]   =   self.get_config()

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







				def       A						(    self  ):
								"""simple docstring"""
								return SqueezeBertConfig(
								    embedding_size=self.hidden_size							,       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							,       attention_probs_dropout_prob=self.hidden_dropout_prob							,       attention_dropout=self.attention_probs_dropout_prob							,       max_position_embeddings=self.max_position_embeddings							,       initializer_range=self.initializer_range							,       q_groups=self.q_groups							,       k_groups=self.k_groups							,       v_groups=self.v_groups							,       post_attention_groups=self.post_attention_groups							,       intermediate_groups=self.intermediate_groups							,       output_groups=self.output_groups							,       )







				def       A						(    self							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase  ):
								"""simple docstring"""
								__magic_name__		:Optional[Any]   =   SqueezeBertModel(config=__lowerCAmelCase  )
								model.to(__lowerCAmelCase  )
								model.eval()
								__magic_name__		:str   =   model(__lowerCAmelCase							,       __lowerCAmelCase  )
								__magic_name__		:List[Any]   =   model(__lowerCAmelCase  )
								self.parent.assertEqual(result.last_hidden_state.shape							,       (self.batch_size, self.seq_length, self.hidden_size)  )







				def       A						(    self							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase  ):
								"""simple docstring"""
								__magic_name__		:str   =   SqueezeBertForMaskedLM(config=__lowerCAmelCase  )
								model.to(__lowerCAmelCase  )
								model.eval()
								__magic_name__		:Optional[int]   =   model(__lowerCAmelCase							,       attention_mask=__lowerCAmelCase							,       labels=__lowerCAmelCase  )
								self.parent.assertEqual(result.logits.shape							,       (self.batch_size, self.seq_length, self.vocab_size)  )







				def       A						(    self							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase  ):
								"""simple docstring"""
								__magic_name__		:Optional[Any]   =   SqueezeBertForQuestionAnswering(config=__lowerCAmelCase  )
								model.to(__lowerCAmelCase  )
								model.eval()
								__magic_name__		:Union[str, Any]   =   model(
								    __lowerCAmelCase							,       attention_mask=__lowerCAmelCase							,       start_positions=__lowerCAmelCase							,       end_positions=__lowerCAmelCase  )
								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       A						(    self							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase  ):
								"""simple docstring"""
								__magic_name__		:Optional[Any]   =   self.num_labels
								__magic_name__		:int   =   SqueezeBertForSequenceClassification(__lowerCAmelCase  )
								model.to(__lowerCAmelCase  )
								model.eval()
								__magic_name__		:Optional[Any]   =   model(__lowerCAmelCase							,       attention_mask=__lowerCAmelCase							,       labels=__lowerCAmelCase  )
								self.parent.assertEqual(result.logits.shape							,       (self.batch_size, self.num_labels)  )







				def       A						(    self							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase  ):
								"""simple docstring"""
								__magic_name__		:List[Any]   =   self.num_labels
								__magic_name__		:Union[str, Any]   =   SqueezeBertForTokenClassification(config=__lowerCAmelCase  )
								model.to(__lowerCAmelCase  )
								model.eval()

								__magic_name__		:Tuple   =   model(__lowerCAmelCase							,       attention_mask=__lowerCAmelCase							,       labels=__lowerCAmelCase  )
								self.parent.assertEqual(result.logits.shape							,       (self.batch_size, self.seq_length, self.num_labels)  )







				def       A						(    self							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase  ):
								"""simple docstring"""
								__magic_name__		:str   =   self.num_choices
								__magic_name__		:Dict   =   SqueezeBertForMultipleChoice(config=__lowerCAmelCase  )
								model.to(__lowerCAmelCase  )
								model.eval()
								__magic_name__		:Any   =   input_ids.unsqueeze(1  ).expand(-1							,       self.num_choices							,       -1  ).contiguous()
								__magic_name__		:Tuple   =   input_mask.unsqueeze(1  ).expand(-1							,       self.num_choices							,       -1  ).contiguous()
								__magic_name__		:Optional[int]   =   model(
								    __lowerCAmelCase							,       attention_mask=__lowerCAmelCase							,       labels=__lowerCAmelCase							,       )
								self.parent.assertEqual(result.logits.shape							,       (self.batch_size, self.num_choices)  )







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:List[Any]   =   self.prepare_config_and_inputs()
								((__magic_name__)  ,					(__magic_name__)  ,					(__magic_name__)  ,					(__magic_name__)  ,					(__magic_name__)  ,					(__magic_name__))		:Tuple   =   config_and_inputs
								__magic_name__		:Dict   =   {'''input_ids''': input_ids, '''attention_mask''': input_mask}
								return config, inputs_dict







@require_torch
class     lowerCamelCase_					(   lowerCamelCase      ,					lowerCamelCase      ,					unittest.TestCase			):
				a__       							=	(
				    (
				        SqueezeBertModel,
				        SqueezeBertForMaskedLM,
				        SqueezeBertForMultipleChoice,
				        SqueezeBertForQuestionAnswering,
				        SqueezeBertForSequenceClassification,
				        SqueezeBertForTokenClassification,
				    )
				    if is_torch_available()
				    else None
				)
				a__       							=	(
				    {
				        '''feature-extraction''': SqueezeBertModel,
				        '''fill-mask''': SqueezeBertForMaskedLM,
				        '''question-answering''': SqueezeBertForQuestionAnswering,
				        '''text-classification''': SqueezeBertForSequenceClassification,
				        '''token-classification''': SqueezeBertForTokenClassification,
				        '''zero-shot''': SqueezeBertForSequenceClassification,
				    }
				    if is_torch_available()
				    else {}
				)
				a__       							=	False
				a__       							=	True
				a__       							=	False







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:Any   =   SqueezeBertModelTester(self  )
								__magic_name__		:Optional[int]   =   ConfigTester(self							,       config_class=__lowerCAmelCase							,       dim=3_7  )







				def       A						(    self  ):
								"""simple docstring"""
								self.config_tester.run_common_tests()







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:Union[str, Any]   =   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_squeezebert_model(*__lowerCAmelCase  )







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:List[str]   =   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_squeezebert_for_masked_lm(*__lowerCAmelCase  )







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:Dict   =   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_squeezebert_for_question_answering(*__lowerCAmelCase  )







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:Optional[int]   =   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_squeezebert_for_sequence_classification(*__lowerCAmelCase  )







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:Tuple   =   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_squeezebert_for_token_classification(*__lowerCAmelCase  )







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:List[Any]   =   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_squeezebert_for_multiple_choice(*__lowerCAmelCase  )







				@slow
				def       A						(    self  ):
								"""simple docstring"""
								for model_name in SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												__magic_name__		:int   =   SqueezeBertModel.from_pretrained(__lowerCAmelCase  )
												self.assertIsNotNone(__lowerCAmelCase  )







@require_sentencepiece
@require_tokenizers
@require_torch
class     lowerCamelCase_					(   unittest.TestCase			):







				@slow
				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:int   =   SqueezeBertForSequenceClassification.from_pretrained('''squeezebert/squeezebert-mnli'''  )

								__magic_name__		:Optional[int]   =   torch.tensor([[1, 2_9_4_1_4, 2_3_2, 3_2_8, 7_4_0, 1_1_4_0, 1_2_6_9_5, 6_9, 1_3, 1_5_8_8, 2]]  )
								__magic_name__		:Tuple   =   model(__lowerCAmelCase  )[0]
								__magic_name__		:Any   =   torch.Size((1, 3)  )
								self.assertEqual(output.shape							,       __lowerCAmelCase  )
								__magic_name__		:List[Any]   =   torch.tensor([[0.6401, -0.0349, -0.6041]]  )
								self.assertTrue(torch.allclose(__lowerCAmelCase							,       __lowerCAmelCase							,       atol=1E-4  )  )









import math

import tensorflow as tf
from packaging import version






def        snake_case__		(    lowerCamelCase_		):
							A      :					Optional[int]      		=					tf.convert_to_tensor(lowerCamelCase_		)
							A      :					Union[str, Any]      		=					0.5 * (1.0 + tf.math.erf(x / tf.cast(tf.sqrt(2.0		)     ,				x.dtype		)		))

							return x * cdf






def        snake_case__		(    lowerCamelCase_		):
							A      :					List[str]      		=					tf.convert_to_tensor(lowerCamelCase_		)
							A      :					Any      		=					tf.cast(math.pi     ,				x.dtype		)
							A      :					int      		=					tf.cast(0.044_715     ,				x.dtype		)
							A      :					Tuple      		=					0.5 * (1.0 + tf.tanh(tf.sqrt(2.0 / pi		) * (x + coeff * tf.pow(lowerCamelCase_     ,				3		))		))

							return x * cdf






def        snake_case__		(    lowerCamelCase_		):
							A      :					Union[str, Any]      		=					tf.convert_to_tensor(lowerCamelCase_		)

							return x * tf.tanh(tf.math.softplus(lowerCamelCase_		)		)






def        snake_case__		(    lowerCamelCase_		):
							A      :					Optional[int]      		=					tf.convert_to_tensor(lowerCamelCase_		)
							A      :					List[Any]      		=					tf.cast(0.044_715     ,				x.dtype		)
							A      :					str      		=					tf.cast(0.7_978_845_608     ,				x.dtype		)

							return 0.5 * x * (1.0 + tf.tanh(x * coeffa * (1.0 + coeffa * x * x)		))






def        snake_case__		(    lowerCamelCase_		):
							A      :					List[str]      		=					tf.convert_to_tensor(lowerCamelCase_		)
							A      :					Any      		=					tf.cast(1.702     ,				x.dtype		)
							return x * tf.math.sigmoid(coeff * x		)






def        snake_case__		(    lowerCamelCase_		):
							return tf.clip_by_value(_gelu(lowerCamelCase_		)     ,				-10     ,				10		)






def        snake_case__		(    lowerCamelCase_     ,				lowerCamelCase_=-1		):
							A		,		A      :					Dict      		=					tf.split(lowerCamelCase_     ,				2     ,				axis=lowerCamelCase_		)
							return a * tf.math.sigmoid(lowerCamelCase_		)


if version.parse(tf.version.VERSION) >= version.parse("2.4"):






		def        snake_case__		(    lowerCamelCase_		):
									return tf.keras.activations.gelu(lowerCamelCase_     ,				approximate=lowerCamelCase_		)

		lowercase			:				Tuple   =     tf.keras.activations.gelu

		lowercase			:				Union[str, Any]   =     approximate_gelu_wrap
else:
		lowercase			:				str   =     _gelu
		lowercase			:				Dict   =     _gelu_new


lowercase			:				Union[str, Any]   =     {
    "gelu": gelu,
    "gelu_10": gelu_aa,
    "gelu_fast": gelu_fast,
    "gelu_new": gelu_new,
    "glu": glu,
    "mish": mish,
    "quick_gelu": quick_gelu,
    "relu": tf.keras.activations.relu,
    "sigmoid": tf.keras.activations.sigmoid,
    "silu": tf.keras.activations.swish,
    "swish": tf.keras.activations.swish,
    "tanh": tf.keras.activations.tanh,
}






def        snake_case__		(    lowerCamelCase_		):
							if activation_string in ACTaFN:
														return ACTaFN[activation_string]
							else:
														raise KeyError(F'function {activation_string} not found in ACT2FN mapping {list(ACTaFN.keys()		)}'		)






