


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 lowerCAmelCase_						:

 '''simple docstring'''

 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.02		,				_UpperCAmelCase=3		,				_UpperCAmelCase=4		,				_UpperCAmelCase=None		,				):
       snake_case_	=				parent
       snake_case_	=				batch_size
       snake_case_	=				seq_length
       snake_case_	=				is_training
       snake_case_	=				use_input_mask
       snake_case_	=				use_token_type_ids
       snake_case_	=				use_labels
       snake_case_	=				vocab_size
       snake_case_	=				hidden_size
       snake_case_	=				num_hidden_layers
       snake_case_	=				num_attention_heads
       snake_case_	=				intermediate_size
       snake_case_	=				hidden_act
       snake_case_	=				hidden_dropout_prob
       snake_case_	=				attention_probs_dropout_prob
       snake_case_	=				max_position_embeddings
       snake_case_	=				type_vocab_size
       snake_case_	=				type_sequence_label_size
       snake_case_	=				initializer_range
       snake_case_	=				num_labels
       snake_case_	=				num_choices
       snake_case_	=				scope



 def 						UpperCamelCase__					(     self ):
       snake_case_	=				ids_tensor([self.batch_size, self.seq_length]		,				self.vocab_size )

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

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

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

       snake_case_	=				self.get_config()

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



 def 						UpperCamelCase__					(     self ):
       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 						UpperCamelCase__					(     self ):
       (
           (
           snake_case_
       )	,   (
           snake_case_
       )	,   (
           snake_case_
       )	,   (
           snake_case_
       )	,   (
           snake_case_
       )	,   (
           snake_case_
       )	,   (
           snake_case_
       )	,   
       )	=				self.prepare_config_and_inputs()

       snake_case_	=				True
       snake_case_	=				floats_tensor([self.batch_size, self.seq_length, self.hidden_size] )
       snake_case_	=				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 						UpperCamelCase__					(     self		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase ):
       snake_case_	=				NezhaModel(config=_UpperCAmelCase )
       model.to(_UpperCAmelCase )
       model.eval()
       snake_case_	=				model(_UpperCAmelCase		,				attention_mask=_UpperCAmelCase		,				token_type_ids=_UpperCAmelCase )
       snake_case_	=				model(_UpperCAmelCase		,				token_type_ids=_UpperCAmelCase )
       snake_case_	=				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 						UpperCamelCase__					(     self		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				):
       snake_case_	=				True
       snake_case_	=				NezhaModel(_UpperCAmelCase )
       model.to(_UpperCAmelCase )
       model.eval()
       snake_case_	=				model(
           _UpperCAmelCase		,				attention_mask=_UpperCAmelCase		,				token_type_ids=_UpperCAmelCase		,				encoder_hidden_states=_UpperCAmelCase		,				encoder_attention_mask=_UpperCAmelCase		,				)
       snake_case_	=				model(
           _UpperCAmelCase		,				attention_mask=_UpperCAmelCase		,				token_type_ids=_UpperCAmelCase		,				encoder_hidden_states=_UpperCAmelCase		,				)
       snake_case_	=				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 						UpperCamelCase__					(     self		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase ):
       snake_case_	=				NezhaForMaskedLM(config=_UpperCAmelCase )
       model.to(_UpperCAmelCase )
       model.eval()
       snake_case_	=				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 						UpperCamelCase__					(     self		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase ):
       snake_case_	=				NezhaForNextSentencePrediction(config=_UpperCAmelCase )
       model.to(_UpperCAmelCase )
       model.eval()
       snake_case_	=				model(
           _UpperCAmelCase		,				attention_mask=_UpperCAmelCase		,				token_type_ids=_UpperCAmelCase		,				labels=_UpperCAmelCase		,				)
       self.parent.assertEqual(result.logits.shape		,				(self.batch_size, 2) )



 def 						UpperCamelCase__					(     self		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase ):
       snake_case_	=				NezhaForPreTraining(config=_UpperCAmelCase )
       model.to(_UpperCAmelCase )
       model.eval()
       snake_case_	=				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 						UpperCamelCase__					(     self		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase ):
       snake_case_	=				NezhaForQuestionAnswering(config=_UpperCAmelCase )
       model.to(_UpperCAmelCase )
       model.eval()
       snake_case_	=				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 						UpperCamelCase__					(     self		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase ):
       snake_case_	=				self.num_labels
       snake_case_	=				NezhaForSequenceClassification(_UpperCAmelCase )
       model.to(_UpperCAmelCase )
       model.eval()
       snake_case_	=				model(_UpperCAmelCase		,				attention_mask=_UpperCAmelCase		,				token_type_ids=_UpperCAmelCase		,				labels=_UpperCAmelCase )
       self.parent.assertEqual(result.logits.shape		,				(self.batch_size, self.num_labels) )



 def 						UpperCamelCase__					(     self		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase ):
       snake_case_	=				self.num_labels
       snake_case_	=				NezhaForTokenClassification(config=_UpperCAmelCase )
       model.to(_UpperCAmelCase )
       model.eval()
       snake_case_	=				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 						UpperCamelCase__					(     self		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase ):
       snake_case_	=				self.num_choices
       snake_case_	=				NezhaForMultipleChoice(config=_UpperCAmelCase )
       model.to(_UpperCAmelCase )
       model.eval()
       snake_case_	=				input_ids.unsqueeze(1 ).expand(-1		,				self.num_choices		,				-1 ).contiguous()
       snake_case_	=				token_type_ids.unsqueeze(1 ).expand(-1		,				self.num_choices		,				-1 ).contiguous()
       snake_case_	=				input_mask.unsqueeze(1 ).expand(-1		,				self.num_choices		,				-1 ).contiguous()
       snake_case_	=				model(
           _UpperCAmelCase		,				attention_mask=_UpperCAmelCase		,				token_type_ids=_UpperCAmelCase		,				labels=_UpperCAmelCase		,				)
       self.parent.assertEqual(result.logits.shape		,				(self.batch_size, self.num_choices) )





 def 						UpperCamelCase__					(     self ):
       snake_case_	=				self.prepare_config_and_inputs()
       (
           (
           snake_case_
       )	,   (
           snake_case_
       )	,   (
           snake_case_
       )	,   (
           snake_case_
       )	,   (
           snake_case_
       )	,   (
           snake_case_
       )	,   (
           snake_case_
       )	,   
       )	=				config_and_inputs
       snake_case_	=				{'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
       return config, inputs_dict







@require_torch
class lowerCAmelCase_						(			lowerCamelCase__ ,						lowerCamelCase__ ,						lowerCamelCase__ ,						unittest.TestCase	):

 '''simple docstring'''

 __snake_case												=  (
     (
         NezhaModel,
         NezhaForMaskedLM,
         NezhaForMultipleChoice,
         NezhaForNextSentencePrediction,
         NezhaForPreTraining,
         NezhaForQuestionAnswering,
         NezhaForSequenceClassification,
         NezhaForTokenClassification,
     )
     if is_torch_available()
     else ()
 )
 __snake_case												=  (
     {
         "feature-extraction": NezhaModel,
         "fill-mask": NezhaForMaskedLM,
         "question-answering": NezhaForQuestionAnswering,
         "text-classification": NezhaForSequenceClassification,
         "token-classification": NezhaForTokenClassification,
         "zero-shot": NezhaForSequenceClassification,
     }
     if is_torch_available()
     else {}
 )
 __snake_case												=  True



 def 						UpperCamelCase__					(     self		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase=False ):
       snake_case_	=				super()._prepare_for_class(_UpperCAmelCase		,				_UpperCAmelCase		,				return_labels=_UpperCAmelCase )

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



 def 						UpperCamelCase__					(     self ):
       snake_case_	=				NezhaModelTester(self )
       snake_case_	=				ConfigTester(self		,				config_class=_UpperCAmelCase		,				hidden_size=37 )



 def 						UpperCamelCase__					(     self ):
       self.config_tester.run_common_tests()



 def 						UpperCamelCase__					(     self ):
       snake_case_	=				self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*_UpperCAmelCase )



 def 						UpperCamelCase__					(     self ):
       snake_case_	=				self.model_tester.prepare_config_and_inputs_for_decoder()
       self.model_tester.create_and_check_model_as_decoder(*_UpperCAmelCase )



 def 						UpperCamelCase__					(     self ):
       # This regression test was failing with PyTorch < 1.3
       (
           (
           snake_case_
       )	,   (
           snake_case_
       )	,   (
           snake_case_
       )	,   (
           snake_case_
       )	,   (
           snake_case_
       )	,   (
           snake_case_
       )	,   (
           snake_case_
       )	,   (
           snake_case_
       )	,   (
           snake_case_
       )	,   
       )	=				self.model_tester.prepare_config_and_inputs_for_decoder()

       snake_case_	=				None

       self.model_tester.create_and_check_model_as_decoder(
           _UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase		,				)



 def 						UpperCamelCase__					(     self ):
       snake_case_	=				self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_masked_lm(*_UpperCAmelCase )



 def 						UpperCamelCase__					(     self ):
       snake_case_	=				self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_multiple_choice(*_UpperCAmelCase )



 def 						UpperCamelCase__					(     self ):
       snake_case_	=				self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_next_sequence_prediction(*_UpperCAmelCase )



 def 						UpperCamelCase__					(     self ):
       snake_case_	=				self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_pretraining(*_UpperCAmelCase )



 def 						UpperCamelCase__					(     self ):
       snake_case_	=				self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_question_answering(*_UpperCAmelCase )



 def 						UpperCamelCase__					(     self ):
       snake_case_	=				self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_sequence_classification(*_UpperCAmelCase )



 def 						UpperCamelCase__					(     self ):
       snake_case_	=				self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_token_classification(*_UpperCAmelCase )



 @slow
 def 						UpperCamelCase__					(     self ):
       for model_name in NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             snake_case_	=				NezhaModel.from_pretrained(_UpperCAmelCase )
             self.assertIsNotNone(_UpperCAmelCase )





 @slow
 @require_torch_gpu
 def 						UpperCamelCase__					(     self ):
       snake_case_	,   snake_case_	=				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

             snake_case_	=				True
             snake_case_	=				model_class(config=_UpperCAmelCase )

             snake_case_	=				self._prepare_for_class(_UpperCAmelCase		,				_UpperCAmelCase )
             snake_case_	=				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''' ) )
                   snake_case_	=				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 lowerCAmelCase_						(			unittest.TestCase	):

 '''simple docstring'''

 @slow
 def 						UpperCamelCase__					(     self ):
       snake_case_	=				NezhaModel.from_pretrained('''sijunhe/nezha-cn-base''' )
       snake_case_	=				torch.tensor([[0, 1, 2, 3, 4, 5]] )
       snake_case_	=				torch.tensor([[0, 1, 1, 1, 1, 1]] )
       with torch.no_grad():
             snake_case_	=				model(_UpperCAmelCase		,				attention_mask=_UpperCAmelCase )[0]
       snake_case_	=				torch.Size((1, 6, 7_68) )
       self.assertEqual(output.shape		,				_UpperCAmelCase )
       snake_case_	=				torch.tensor([[[0.0_685, 0.2_441, 0.1_102], [0.0_600, 0.1_906, 0.1_349], [0.0_221, 0.0_819, 0.0_586]]] )

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





 @slow
 def 						UpperCamelCase__					(     self ):
       snake_case_	=				NezhaForMaskedLM.from_pretrained('''sijunhe/nezha-cn-base''' )
       snake_case_	=				torch.tensor([[0, 1, 2, 3, 4, 5]] )
       snake_case_	=				torch.tensor([[1, 1, 1, 1, 1, 1]] )
       with torch.no_grad():
             snake_case_	=				model(_UpperCAmelCase		,				attention_mask=_UpperCAmelCase )[0]
       snake_case_	=				torch.Size((1, 6, 2_11_28) )
       self.assertEqual(output.shape		,				_UpperCAmelCase )
       snake_case_	=				torch.tensor(
           [[-2.7_939, -1.7_902, -2.2_189], [-2.8_585, -1.8_908, -2.3_723], [-2.6_499, -1.7_750, -2.2_558]] )

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



def 	__lowerCAmelCase   (SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE )->  int:




      """simple docstring"""

      return x if y == 0 else greatest_common_divisor(SCREAMING_SNAKE_CASE , x % y )






def 	__lowerCAmelCase   (SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE )->  int:




      """simple docstring"""

      return (x * y) // greatest_common_divisor(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE )






def 	__lowerCAmelCase   (SCREAMING_SNAKE_CASE = 20 )->  int:




      """simple docstring"""

      snake_case_	=				1
      for i in range(1 , n + 1 ):
            snake_case_	=				lcm(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE )
      return g


if __name__ == "__main__":
   print(f'''{solution() = }''')