"""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     UpperCamelCase__:





						def __init__(       self		,__UpperCAmelCase		,__UpperCAmelCase=13		,__UpperCAmelCase=7		,__UpperCAmelCase=True		,__UpperCAmelCase=True		,__UpperCAmelCase=True		,__UpperCAmelCase=True		,__UpperCAmelCase=99		,__UpperCAmelCase=32		,__UpperCAmelCase=5		,__UpperCAmelCase=4		,__UpperCAmelCase=37		,__UpperCAmelCase="gelu"		,__UpperCAmelCase=0.1		,__UpperCAmelCase=0.1		,__UpperCAmelCase=1_28		,__UpperCAmelCase=32		,__UpperCAmelCase=16		,__UpperCAmelCase=2		,__UpperCAmelCase=0.0_2		,__UpperCAmelCase=3		,__UpperCAmelCase=4		,__UpperCAmelCase=None		,)					->				List[Any]:
													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 				snake_case__	(       self     )					->				List[Any]:
													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 				snake_case__	(       self     )					->				Optional[Any]:
													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=__UpperCAmelCase		,initializer_range=self.initializer_range		,)





						def 				snake_case__	(       self     )					->				List[str]:
													(
													    (
													    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 				snake_case__	(       self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase     )					->				Optional[Any]:
													A__	     =							NezhaModel(config=__UpperCAmelCase     )
													model.to(__UpperCAmelCase     )
													model.eval()
													A__	     =							model(__UpperCAmelCase		,attention_mask=__UpperCAmelCase		,token_type_ids=__UpperCAmelCase     )
													A__	     =							model(__UpperCAmelCase		,token_type_ids=__UpperCAmelCase     )
													A__	     =							model(__UpperCAmelCase     )
													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 				snake_case__	(       self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,)					->				Union[str, Any]:
													A__	     =							True
													A__	     =							NezhaModel(__UpperCAmelCase     )
													model.to(__UpperCAmelCase     )
													model.eval()
													A__	     =							model(
													    __UpperCAmelCase		,attention_mask=__UpperCAmelCase		,token_type_ids=__UpperCAmelCase		,encoder_hidden_states=__UpperCAmelCase		,encoder_attention_mask=__UpperCAmelCase		,)
													A__	     =							model(
													    __UpperCAmelCase		,attention_mask=__UpperCAmelCase		,token_type_ids=__UpperCAmelCase		,encoder_hidden_states=__UpperCAmelCase		,)
													A__	     =							model(__UpperCAmelCase		,attention_mask=__UpperCAmelCase		,token_type_ids=__UpperCAmelCase     )
													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 				snake_case__	(       self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase     )					->				Optional[Any]:
													A__	     =							NezhaForMaskedLM(config=__UpperCAmelCase     )
													model.to(__UpperCAmelCase     )
													model.eval()
													A__	     =							model(__UpperCAmelCase		,attention_mask=__UpperCAmelCase		,token_type_ids=__UpperCAmelCase		,labels=__UpperCAmelCase     )
													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     )					->				Dict:
													A__	     =							NezhaForNextSentencePrediction(config=__UpperCAmelCase     )
													model.to(__UpperCAmelCase     )
													model.eval()
													A__	     =							model(
													    __UpperCAmelCase		,attention_mask=__UpperCAmelCase		,token_type_ids=__UpperCAmelCase		,labels=__UpperCAmelCase		,)
													self.parent.assertEqual(result.logits.shape		,(self.batch_size, 2)     )





						def 				snake_case__	(       self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase     )					->				List[Any]:
													A__	     =							NezhaForPreTraining(config=__UpperCAmelCase     )
													model.to(__UpperCAmelCase     )
													model.eval()
													A__	     =							model(
													    __UpperCAmelCase		,attention_mask=__UpperCAmelCase		,token_type_ids=__UpperCAmelCase		,labels=__UpperCAmelCase		,next_sentence_label=__UpperCAmelCase		,)
													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 				snake_case__	(       self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase     )					->				List[str]:
													A__	     =							NezhaForQuestionAnswering(config=__UpperCAmelCase     )
													model.to(__UpperCAmelCase     )
													model.eval()
													A__	     =							model(
													    __UpperCAmelCase		,attention_mask=__UpperCAmelCase		,token_type_ids=__UpperCAmelCase		,start_positions=__UpperCAmelCase		,end_positions=__UpperCAmelCase		,)
													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		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase     )					->				Dict:
													A__	     =							self.num_labels
													A__	     =							NezhaForSequenceClassification(__UpperCAmelCase     )
													model.to(__UpperCAmelCase     )
													model.eval()
													A__	     =							model(__UpperCAmelCase		,attention_mask=__UpperCAmelCase		,token_type_ids=__UpperCAmelCase		,labels=__UpperCAmelCase     )
													self.parent.assertEqual(result.logits.shape		,(self.batch_size, self.num_labels)     )





						def 				snake_case__	(       self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase     )					->				Optional[Any]:
													A__	     =							self.num_labels
													A__	     =							NezhaForTokenClassification(config=__UpperCAmelCase     )
													model.to(__UpperCAmelCase     )
													model.eval()
													A__	     =							model(__UpperCAmelCase		,attention_mask=__UpperCAmelCase		,token_type_ids=__UpperCAmelCase		,labels=__UpperCAmelCase     )
													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     )					->				Dict:
													A__	     =							self.num_choices
													A__	     =							NezhaForMultipleChoice(config=__UpperCAmelCase     )
													model.to(__UpperCAmelCase     )
													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(
													    __UpperCAmelCase		,attention_mask=__UpperCAmelCase		,token_type_ids=__UpperCAmelCase		,labels=__UpperCAmelCase		,)
													self.parent.assertEqual(result.logits.shape		,(self.batch_size, self.num_choices)     )





						def 				snake_case__	(       self     )					->				List[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_torch
class     UpperCamelCase__(			__A		,						__A		,						__A		,						unittest.TestCase ):
						lowerCAmelCase__  :						Union[str, Any]													=		(
						    (
						        NezhaModel,
						        NezhaForMaskedLM,
						        NezhaForMultipleChoice,
						        NezhaForNextSentencePrediction,
						        NezhaForPreTraining,
						        NezhaForQuestionAnswering,
						        NezhaForSequenceClassification,
						        NezhaForTokenClassification,
						    )
						    if is_torch_available()
						    else ()
						)
						lowerCAmelCase__  :						List[Any]													=		(
						    {
						        'feature-extraction': NezhaModel,
						        'fill-mask': NezhaForMaskedLM,
						        'question-answering': NezhaForQuestionAnswering,
						        'text-classification': NezhaForSequenceClassification,
						        'token-classification': NezhaForTokenClassification,
						        'zero-shot': NezhaForSequenceClassification,
						    }
						    if is_torch_available()
						    else {}
						)
						lowerCAmelCase__  :						List[str]													=		True





						def 				snake_case__	(       self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase=False     )					->				Any:
													A__	     =							super()._prepare_for_class(__UpperCAmelCase		,__UpperCAmelCase		,return_labels=__UpperCAmelCase     )

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





						def 				snake_case__	(       self     )					->				int:
													A__	     =							NezhaModelTester(self     )
													A__	     =							ConfigTester(self		,config_class=__UpperCAmelCase		,hidden_size=37     )





						def 				snake_case__	(       self     )					->				str:
													self.config_tester.run_common_tests()





						def 				snake_case__	(       self     )					->				Optional[int]:
													A__	     =							self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_model(*__UpperCAmelCase     )





						def 				snake_case__	(       self     )					->				Optional[int]:
													A__	     =							self.model_tester.prepare_config_and_inputs_for_decoder()
													self.model_tester.create_and_check_model_as_decoder(*__UpperCAmelCase     )





						def 				snake_case__	(       self     )					->				Dict:
													# This regression test was failing with PyTorch < 1.3
													(
													    (
													    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(
													    __UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,)





						def 				snake_case__	(       self     )					->				Dict:
													A__	     =							self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_masked_lm(*__UpperCAmelCase     )





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





						def 				snake_case__	(       self     )					->				Tuple:
													A__	     =							self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_next_sequence_prediction(*__UpperCAmelCase     )





						def 				snake_case__	(       self     )					->				Dict:
													A__	     =							self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_pretraining(*__UpperCAmelCase     )





						def 				snake_case__	(       self     )					->				Optional[Any]:
													A__	     =							self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_question_answering(*__UpperCAmelCase     )





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





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





						@slow
						def 				snake_case__	(       self     )					->				Optional[Any]:
													for model_name in NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																				A__	     =							NezhaModel.from_pretrained(__UpperCAmelCase     )
																				self.assertIsNotNone(__UpperCAmelCase     )





						@slow
						@require_torch_gpu
						def 				snake_case__	(       self     )					->				Optional[int]:
													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=__UpperCAmelCase     )

																				A__	     =							self._prepare_for_class(__UpperCAmelCase		,__UpperCAmelCase     )
																				A__	     =							torch.jit.trace(
																				    __UpperCAmelCase		,(inputs_dict['input_ids'].to('cpu'     ), inputs_dict['attention_mask'].to('cpu'     ))     )

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






@require_torch
class     UpperCamelCase__(			unittest.TestCase ):





						@slow
						def 				snake_case__	(       self     )					->				Optional[Any]:
													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(__UpperCAmelCase		,attention_mask=__UpperCAmelCase     )[0]
													A__	     =							torch.Size((1, 6, 7_68)     )
													self.assertEqual(output.shape		,__UpperCAmelCase     )
													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]		,__UpperCAmelCase		,atol=1e-4     )     )





						@slow
						def 				snake_case__	(       self     )					->				Union[str, Any]:
													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(__UpperCAmelCase		,attention_mask=__UpperCAmelCase     )[0]
													A__	     =							torch.Size((1, 6, 2_11_28)     )
													self.assertEqual(output.shape		,__UpperCAmelCase     )
													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]		,__UpperCAmelCase		,atol=1e-4     )     )






"""simple docstring"""




import unittest

import torch
from torch import nn

from diffusers.models.activations import get_activation
class     UpperCamelCase__(			unittest.TestCase ):





						def 				snake_case__	(       self     )					->				str:
													A__	     =							get_activation('swish'     )

													self.assertIsInstance(__UpperCAmelCase		,nn.SiLU     )

													self.assertEqual(act(torch.tensor(-1_00		,dtype=torch.floataa     )     ).item()		,0     )
													self.assertNotEqual(act(torch.tensor(-1		,dtype=torch.floataa     )     ).item()		,0     )
													self.assertEqual(act(torch.tensor(0		,dtype=torch.floataa     )     ).item()		,0     )
													self.assertEqual(act(torch.tensor(20		,dtype=torch.floataa     )     ).item()		,20     )





						def 				snake_case__	(       self     )					->				Optional[Any]:
													A__	     =							get_activation('silu'     )

													self.assertIsInstance(__UpperCAmelCase		,nn.SiLU     )

													self.assertEqual(act(torch.tensor(-1_00		,dtype=torch.floataa     )     ).item()		,0     )
													self.assertNotEqual(act(torch.tensor(-1		,dtype=torch.floataa     )     ).item()		,0     )
													self.assertEqual(act(torch.tensor(0		,dtype=torch.floataa     )     ).item()		,0     )
													self.assertEqual(act(torch.tensor(20		,dtype=torch.floataa     )     ).item()		,20     )





						def 				snake_case__	(       self     )					->				List[str]:
													A__	     =							get_activation('mish'     )

													self.assertIsInstance(__UpperCAmelCase		,nn.Mish     )

													self.assertEqual(act(torch.tensor(-2_00		,dtype=torch.floataa     )     ).item()		,0     )
													self.assertNotEqual(act(torch.tensor(-1		,dtype=torch.floataa     )     ).item()		,0     )
													self.assertEqual(act(torch.tensor(0		,dtype=torch.floataa     )     ).item()		,0     )
													self.assertEqual(act(torch.tensor(20		,dtype=torch.floataa     )     ).item()		,20     )





						def 				snake_case__	(       self     )					->				List[str]:
													A__	     =							get_activation('gelu'     )

													self.assertIsInstance(__UpperCAmelCase		,nn.GELU     )

													self.assertEqual(act(torch.tensor(-1_00		,dtype=torch.floataa     )     ).item()		,0     )
													self.assertNotEqual(act(torch.tensor(-1		,dtype=torch.floataa     )     ).item()		,0     )
													self.assertEqual(act(torch.tensor(0		,dtype=torch.floataa     )     ).item()		,0     )
													self.assertEqual(act(torch.tensor(20		,dtype=torch.floataa     )     ).item()		,20     )





