


"""simple docstring"""


import os
import tempfile
import unittest

from transformers import NezhaConfig, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_torch_gpu, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
		import torch

		from transformers import (
		    MODEL_FOR_PRETRAINING_MAPPING,
		    NezhaForMaskedLM,
		    NezhaForMultipleChoice,
		    NezhaForNextSentencePrediction,
		    NezhaForPreTraining,
		    NezhaForQuestionAnswering,
		    NezhaForSequenceClassification,
		    NezhaForTokenClassification,
		    NezhaModel,
		)
		from transformers.models.nezha.modeling_nezha import NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST
class snake_case      :







		def __init__(					self      :       int    ,   a__      :       List[Any]    ,   a__      :       Optional[Any]=13    ,   a__      :       List[Any]=7    ,   a__      :       List[str]=True    ,   a__      :       Any=True    ,   a__      :       List[Any]=True    ,   a__      :       Dict=True    ,   a__      :       str=99    ,   a__      :       List[str]=32    ,   a__      :       Union[str, Any]=5    ,   a__      :       Dict=4    ,   a__      :       List[str]=37    ,   a__      :       Tuple="gelu"    ,   a__      :       Optional[int]=0.1    ,   a__      :       Union[str, Any]=0.1    ,   a__      :       Any=1_28    ,   a__      :       int=32    ,   a__      :       Dict=16    ,   a__      :       Union[str, Any]=2    ,   a__      :       List[str]=0.0_2    ,   a__      :       Union[str, Any]=3    ,   a__      :       int=4    ,   a__      :       Tuple=None    ,   )       ->						Tuple:





						'''simple docstring'''







						_A					  =			parent
						_A					  =			batch_size
						_A					  =			seq_length
						_A					  =			is_training
						_A					  =			use_input_mask
						_A					  =			use_token_type_ids
						_A					  =			use_labels
						_A					  =			vocab_size
						_A					  =			hidden_size
						_A					  =			num_hidden_layers
						_A					  =			num_attention_heads
						_A					  =			intermediate_size
						_A					  =			hidden_act
						_A					  =			hidden_dropout_prob
						_A					  =			attention_probs_dropout_prob
						_A					  =			max_position_embeddings
						_A					  =			type_vocab_size
						_A					  =			type_sequence_label_size
						_A					  =			initializer_range
						_A					  =			num_labels
						_A					  =			num_choices
						_A					  =			scope







		def  a_ (					self      :       List[Any]		)       ->						Optional[Any]:





						'''simple docstring'''







						_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					  =			self.get_config()

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







		def  a_ (					self      :       Any		)       ->						List[Any]:





						'''simple docstring'''







						return NezhaConfig(
						    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    ,   is_decoder=lowerCAmelCase_    ,   initializer_range=self.initializer_range    ,   )







		def  a_ (					self      :       Tuple		)       ->						List[Any]:





						'''simple docstring'''







						(
						    (
						    _A    
						)  ,		(
						    _A    
						)  ,		(
						    _A    
						)  ,		(
						    _A    
						)  ,		(
						    _A    
						)  ,		(
						    _A    
						)  ,		(
						    _A    
						)  ,		    
						)					  =			self.prepare_config_and_inputs()

						_A					  =			True
						_A					  =			floats_tensor([self.batch_size, self.seq_length, self.hidden_size]		)
						_A					  =			ids_tensor([self.batch_size, self.seq_length]    ,   vocab_size=2		)

						return (
						    config,
						    input_ids,
						    token_type_ids,
						    input_mask,
						    sequence_labels,
						    token_labels,
						    choice_labels,
						    encoder_hidden_states,
						    encoder_attention_mask,
						)







		def  a_ (					self      :       Dict    ,   a__      :       Dict    ,   a__      :       int    ,   a__      :       Union[str, Any]    ,   a__      :       str    ,   a__      :       str    ,   a__      :       int    ,   a__      :       int		)       ->						Optional[int]:





						'''simple docstring'''







						_A					  =			NezhaModel(config=lowerCAmelCase_		)
						model.to(lowerCAmelCase_		)
						model.eval()
						_A					  =			model(lowerCAmelCase_    ,   attention_mask=lowerCAmelCase_    ,   token_type_ids=lowerCAmelCase_		)
						_A					  =			model(lowerCAmelCase_    ,   token_type_ids=lowerCAmelCase_		)
						_A					  =			model(lowerCAmelCase_		)
						self.parent.assertEqual(result.last_hidden_state.shape    ,   (self.batch_size, self.seq_length, self.hidden_size)		)
						self.parent.assertEqual(result.pooler_output.shape    ,   (self.batch_size, self.hidden_size)		)







		def  a_ (					self      :       Optional[int]    ,   a__      :       Dict    ,   a__      :       Union[str, Any]    ,   a__      :       List[Any]    ,   a__      :       Optional[Any]    ,   a__      :       str    ,   a__      :       int    ,   a__      :       List[Any]    ,   a__      :       Union[str, Any]    ,   a__      :       Tuple    ,   )       ->						Optional[int]:





						'''simple docstring'''







						_A					  =			True
						_A					  =			NezhaModel(lowerCAmelCase_		)
						model.to(lowerCAmelCase_		)
						model.eval()
						_A					  =			model(
						    lowerCAmelCase_    ,   attention_mask=lowerCAmelCase_    ,   token_type_ids=lowerCAmelCase_    ,   encoder_hidden_states=lowerCAmelCase_    ,   encoder_attention_mask=lowerCAmelCase_    ,   )
						_A					  =			model(
						    lowerCAmelCase_    ,   attention_mask=lowerCAmelCase_    ,   token_type_ids=lowerCAmelCase_    ,   encoder_hidden_states=lowerCAmelCase_    ,   )
						_A					  =			model(lowerCAmelCase_    ,   attention_mask=lowerCAmelCase_    ,   token_type_ids=lowerCAmelCase_		)
						self.parent.assertEqual(result.last_hidden_state.shape    ,   (self.batch_size, self.seq_length, self.hidden_size)		)
						self.parent.assertEqual(result.pooler_output.shape    ,   (self.batch_size, self.hidden_size)		)







		def  a_ (					self      :       Optional[Any]    ,   a__      :       Any    ,   a__      :       List[str]    ,   a__      :       Any    ,   a__      :       int    ,   a__      :       Union[str, Any]    ,   a__      :       Any    ,   a__      :       int		)       ->						int:





						'''simple docstring'''







						_A					  =			NezhaForMaskedLM(config=lowerCAmelCase_		)
						model.to(lowerCAmelCase_		)
						model.eval()
						_A					  =			model(lowerCAmelCase_    ,   attention_mask=lowerCAmelCase_    ,   token_type_ids=lowerCAmelCase_    ,   labels=lowerCAmelCase_		)
						self.parent.assertEqual(result.logits.shape    ,   (self.batch_size, self.seq_length, self.vocab_size)		)







		def  a_ (					self      :       Any    ,   a__      :       Union[str, Any]    ,   a__      :       Dict    ,   a__      :       Any    ,   a__      :       str    ,   a__      :       Optional[Any]    ,   a__      :       Tuple    ,   a__      :       Any		)       ->						Dict:





						'''simple docstring'''







						_A					  =			NezhaForNextSentencePrediction(config=lowerCAmelCase_		)
						model.to(lowerCAmelCase_		)
						model.eval()
						_A					  =			model(
						    lowerCAmelCase_    ,   attention_mask=lowerCAmelCase_    ,   token_type_ids=lowerCAmelCase_    ,   labels=lowerCAmelCase_    ,   )
						self.parent.assertEqual(result.logits.shape    ,   (self.batch_size, 2)		)







		def  a_ (					self      :       Any    ,   a__      :       List[str]    ,   a__      :       int    ,   a__      :       Any    ,   a__      :       Union[str, Any]    ,   a__      :       List[Any]    ,   a__      :       Union[str, Any]    ,   a__      :       Union[str, Any]		)       ->						Optional[int]:





						'''simple docstring'''







						_A					  =			NezhaForPreTraining(config=lowerCAmelCase_		)
						model.to(lowerCAmelCase_		)
						model.eval()
						_A					  =			model(
						    lowerCAmelCase_    ,   attention_mask=lowerCAmelCase_    ,   token_type_ids=lowerCAmelCase_    ,   labels=lowerCAmelCase_    ,   next_sentence_label=lowerCAmelCase_    ,   )
						self.parent.assertEqual(result.prediction_logits.shape    ,   (self.batch_size, self.seq_length, self.vocab_size)		)
						self.parent.assertEqual(result.seq_relationship_logits.shape    ,   (self.batch_size, 2)		)







		def  a_ (					self      :       Dict    ,   a__      :       Dict    ,   a__      :       Dict    ,   a__      :       Any    ,   a__      :       Optional[int]    ,   a__      :       Any    ,   a__      :       int    ,   a__      :       Any		)       ->						Any:





						'''simple docstring'''







						_A					  =			NezhaForQuestionAnswering(config=lowerCAmelCase_		)
						model.to(lowerCAmelCase_		)
						model.eval()
						_A					  =			model(
						    lowerCAmelCase_    ,   attention_mask=lowerCAmelCase_    ,   token_type_ids=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      :       Optional[int]    ,   a__      :       Tuple    ,   a__      :       Dict    ,   a__      :       Tuple    ,   a__      :       List[str]    ,   a__      :       Dict    ,   a__      :       str    ,   a__      :       int		)       ->						Optional[int]:





						'''simple docstring'''







						_A					  =			self.num_labels
						_A					  =			NezhaForSequenceClassification(lowerCAmelCase_		)
						model.to(lowerCAmelCase_		)
						model.eval()
						_A					  =			model(lowerCAmelCase_    ,   attention_mask=lowerCAmelCase_    ,   token_type_ids=lowerCAmelCase_    ,   labels=lowerCAmelCase_		)
						self.parent.assertEqual(result.logits.shape    ,   (self.batch_size, self.num_labels)		)







		def  a_ (					self      :       Tuple    ,   a__      :       int    ,   a__      :       List[str]    ,   a__      :       List[Any]    ,   a__      :       Tuple    ,   a__      :       List[str]    ,   a__      :       int    ,   a__      :       Optional[int]		)       ->						Optional[int]:





						'''simple docstring'''







						_A					  =			self.num_labels
						_A					  =			NezhaForTokenClassification(config=lowerCAmelCase_		)
						model.to(lowerCAmelCase_		)
						model.eval()
						_A					  =			model(lowerCAmelCase_    ,   attention_mask=lowerCAmelCase_    ,   token_type_ids=lowerCAmelCase_    ,   labels=lowerCAmelCase_		)
						self.parent.assertEqual(result.logits.shape    ,   (self.batch_size, self.seq_length, self.num_labels)		)







		def  a_ (					self      :       Tuple    ,   a__      :       Optional[Any]    ,   a__      :       Tuple    ,   a__      :       Optional[Any]    ,   a__      :       Optional[Any]    ,   a__      :       Dict    ,   a__      :       Tuple    ,   a__      :       Optional[Any]		)       ->						Tuple:





						'''simple docstring'''







						_A					  =			self.num_choices
						_A					  =			NezhaForMultipleChoice(config=lowerCAmelCase_		)
						model.to(lowerCAmelCase_		)
						model.eval()
						_A					  =			input_ids.unsqueeze(1		).expand(-1    ,   self.num_choices    ,   -1		).contiguous()
						_A					  =			token_type_ids.unsqueeze(1		).expand(-1    ,   self.num_choices    ,   -1		).contiguous()
						_A					  =			input_mask.unsqueeze(1		).expand(-1    ,   self.num_choices    ,   -1		).contiguous()
						_A					  =			model(
						    lowerCAmelCase_    ,   attention_mask=lowerCAmelCase_    ,   token_type_ids=lowerCAmelCase_    ,   labels=lowerCAmelCase_    ,   )
						self.parent.assertEqual(result.logits.shape    ,   (self.batch_size, self.num_choices)		)







		def  a_ (					self      :       Optional[Any]		)       ->						Optional[Any]:





						'''simple docstring'''







						_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_torch
class snake_case      (  __UpperCAmelCase     ,				__UpperCAmelCase     ,				__UpperCAmelCase     ,				unittest.TestCase):
		__UpperCamelCase           =			(
		    (
		        NezhaModel,
		        NezhaForMaskedLM,
		        NezhaForMultipleChoice,
		        NezhaForNextSentencePrediction,
		        NezhaForPreTraining,
		        NezhaForQuestionAnswering,
		        NezhaForSequenceClassification,
		        NezhaForTokenClassification,
		    )
		    if is_torch_available()
		    else ()
		)
		__UpperCamelCase           =			(
		    {
		        'feature-extraction': NezhaModel,
		        'fill-mask': NezhaForMaskedLM,
		        'question-answering': NezhaForQuestionAnswering,
		        'text-classification': NezhaForSequenceClassification,
		        'token-classification': NezhaForTokenClassification,
		        'zero-shot': NezhaForSequenceClassification,
		    }
		    if is_torch_available()
		    else {}
		)
		__UpperCamelCase           =			True







		def  a_ (					self      :       int    ,   a__      :       str    ,   a__      :       int    ,   a__      :       int=False		)       ->						int:





						'''simple docstring'''







						_A					  =			super()._prepare_for_class(lowerCAmelCase_    ,   lowerCAmelCase_    ,   return_labels=lowerCAmelCase_		)

						if return_labels:
										if model_class in get_values(lowerCAmelCase_		):
														_A					  =			torch.zeros(
														    (self.model_tester.batch_size, self.model_tester.seq_length)    ,   dtype=torch.long    ,   device=lowerCAmelCase_		)
														_A					  =			torch.zeros(
														    self.model_tester.batch_size    ,   dtype=torch.long    ,   device=lowerCAmelCase_		)
						return inputs_dict







		def  a_ (					self      :       Optional[int]		)       ->						Optional[Any]:





						'''simple docstring'''







						_A					  =			NezhaModelTester(self		)
						_A					  =			ConfigTester(self    ,   config_class=lowerCAmelCase_    ,   hidden_size=37		)







		def  a_ (					self      :       Union[str, Any]		)       ->						Optional[int]:





						'''simple docstring'''







						self.config_tester.run_common_tests()







		def  a_ (					self      :       List[str]		)       ->						Union[str, Any]:





						'''simple docstring'''







						_A					  =			self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*lowerCAmelCase_		)







		def  a_ (					self      :       str		)       ->						Optional[int]:





						'''simple docstring'''







						_A					  =			self.model_tester.prepare_config_and_inputs_for_decoder()
						self.model_tester.create_and_check_model_as_decoder(*lowerCAmelCase_		)







		def  a_ (					self      :       str		)       ->						Tuple:





						'''simple docstring'''







						(
						    (
						    _A    
						)  ,		(
						    _A    
						)  ,		(
						    _A    
						)  ,		(
						    _A    
						)  ,		(
						    _A    
						)  ,		(
						    _A    
						)  ,		(
						    _A    
						)  ,		(
						    _A    
						)  ,		(
						    _A    
						)  ,		    
						)					  =			self.model_tester.prepare_config_and_inputs_for_decoder()

						_A					  =			None

						self.model_tester.create_and_check_model_as_decoder(
						    lowerCAmelCase_    ,   lowerCAmelCase_    ,   lowerCAmelCase_    ,   lowerCAmelCase_    ,   lowerCAmelCase_    ,   lowerCAmelCase_    ,   lowerCAmelCase_    ,   lowerCAmelCase_    ,   lowerCAmelCase_    ,   )







		def  a_ (					self      :       List[Any]		)       ->						int:





						'''simple docstring'''







						_A					  =			self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_masked_lm(*lowerCAmelCase_		)







		def  a_ (					self      :       int		)       ->						Union[str, Any]:





						'''simple docstring'''







						_A					  =			self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_multiple_choice(*lowerCAmelCase_		)







		def  a_ (					self      :       int		)       ->						Union[str, Any]:





						'''simple docstring'''







						_A					  =			self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_next_sequence_prediction(*lowerCAmelCase_		)







		def  a_ (					self      :       Optional[Any]		)       ->						Optional[Any]:





						'''simple docstring'''







						_A					  =			self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_pretraining(*lowerCAmelCase_		)







		def  a_ (					self      :       Any		)       ->						List[str]:





						'''simple docstring'''







						_A					  =			self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_question_answering(*lowerCAmelCase_		)







		def  a_ (					self      :       Tuple		)       ->						int:





						'''simple docstring'''







						_A					  =			self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_sequence_classification(*lowerCAmelCase_		)







		def  a_ (					self      :       Union[str, Any]		)       ->						Optional[Any]:





						'''simple docstring'''







						_A					  =			self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_token_classification(*lowerCAmelCase_		)







		@slow
		def  a_ (					self      :       int		)       ->						Any:





						'''simple docstring'''







						for model_name in NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										_A					  =			NezhaModel.from_pretrained(lowerCAmelCase_		)
										self.assertIsNotNone(lowerCAmelCase_		)







		@slow
		@require_torch_gpu
		def  a_ (					self      :       Union[str, Any]		)       ->						Optional[int]:





						'''simple docstring'''







						_A  ,		_A					  =			self.model_tester.prepare_config_and_inputs_for_common()
						for model_class in self.all_model_classes:
										# NezhaForMultipleChoice behaves incorrectly in JIT environments.
										if model_class == NezhaForMultipleChoice:
														return

										_A					  =			True
										_A					  =			model_class(config=lowerCAmelCase_		)

										_A					  =			self._prepare_for_class(lowerCAmelCase_    ,   lowerCAmelCase_		)
										_A					  =			torch.jit.trace(
										    lowerCAmelCase_    ,   (inputs_dict["input_ids"].to("cpu"		), inputs_dict["attention_mask"].to("cpu"		))		)

										with tempfile.TemporaryDirectory() as tmp:
														torch.jit.save(lowerCAmelCase_    ,   os.path.join(lowerCAmelCase_    ,   "bert.pt"		)		)
														_A					  =			torch.jit.load(os.path.join(lowerCAmelCase_    ,   "bert.pt"		)    ,   map_location=lowerCAmelCase_		)
														loaded(inputs_dict["input_ids"].to(lowerCAmelCase_		)    ,   inputs_dict["attention_mask"].to(lowerCAmelCase_		)		)





@require_torch
class snake_case      (  unittest.TestCase):







		@slow
		def  a_ (					self      :       Any		)       ->						str:





						'''simple docstring'''







						_A					  =			NezhaModel.from_pretrained("sijunhe/nezha-cn-base"		)
						_A					  =			torch.tensor([[0, 1, 2, 3, 4, 5]]		)
						_A					  =			torch.tensor([[0, 1, 1, 1, 1, 1]]		)
						with torch.no_grad():
										_A					  =			model(lowerCAmelCase_    ,   attention_mask=lowerCAmelCase_		)[0]
						_A					  =			torch.Size((1, 6, 7_68)		)
						self.assertEqual(output.shape    ,   lowerCAmelCase_		)
						_A					  =			torch.tensor([[[0.0_6_8_5, 0.2_4_4_1, 0.1_1_0_2], [0.0_6_0_0, 0.1_9_0_6, 0.1_3_4_9], [0.0_2_2_1, 0.0_8_1_9, 0.0_5_8_6]]]		)

						self.assertTrue(torch.allclose(output[:, 1:4, 1:4]    ,   lowerCAmelCase_    ,   atol=1E-4		)		)







		@slow
		def  a_ (					self      :       int		)       ->						Tuple:





						'''simple docstring'''







						_A					  =			NezhaForMaskedLM.from_pretrained("sijunhe/nezha-cn-base"		)
						_A					  =			torch.tensor([[0, 1, 2, 3, 4, 5]]		)
						_A					  =			torch.tensor([[1, 1, 1, 1, 1, 1]]		)
						with torch.no_grad():
										_A					  =			model(lowerCAmelCase_    ,   attention_mask=lowerCAmelCase_		)[0]
						_A					  =			torch.Size((1, 6, 2_11_28)		)
						self.assertEqual(output.shape    ,   lowerCAmelCase_		)
						_A					  =			torch.tensor(
						    [[-2.7_9_3_9, -1.7_9_0_2, -2.2_1_8_9], [-2.8_5_8_5, -1.8_9_0_8, -2.3_7_2_3], [-2.6_4_9_9, -1.7_7_5_0, -2.2_5_5_8]]		)

						self.assertTrue(torch.allclose(output[:, 1:4, 1:4]    ,   lowerCAmelCase_    ,   atol=1E-4		)		)



"""simple docstring"""


def      a__ (				__lowercase     ,			__lowercase   )	->	int:
				while a != 0:
								_A  ,		_A					  =			b % a, a
				return b






def      a__ (				__lowercase     ,			__lowercase   )	->	int:
				if gcd(__lowercase     ,			__lowercase   ) != 1:
								_A					  =			f"""mod inverse of {a!r} and {m!r} does not exist"""
								raise ValueError(__lowercase   )
				_A  ,		_A  ,		_A					  =			1, 0, a
				_A  ,		_A  ,		_A					  =			0, 1, m
				while va != 0:
								_A					  =			ua // va
								_A  ,		_A  ,		_A  ,		_A  ,		_A  ,		_A					  =			(ua - q * va), (ua - q * va), (ua - q * va), va, va, va
				return ua % m