


'''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 	a       :
 def __init__(	self ,			__magic_name__ ,			__magic_name__=13 ,			__magic_name__=7 ,			__magic_name__=True ,			__magic_name__=True ,			__magic_name__=True ,			__magic_name__=True ,			__magic_name__=99 ,			__magic_name__=32 ,			__magic_name__=5 ,			__magic_name__=4 ,			__magic_name__=37 ,			__magic_name__="gelu" ,			__magic_name__=0.1 ,			__magic_name__=0.1 ,			__magic_name__=1_28 ,			__magic_name__=32 ,			__magic_name__=16 ,			__magic_name__=2 ,			__magic_name__=0.0_2 ,			__magic_name__=3 ,			__magic_name__=4 ,			__magic_name__=None ,			)   ->							Dict:
      _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 							__UpperCAmelCase						(	self  )   ->							Tuple:
      _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 							__UpperCAmelCase						(	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=__A ,			initializer_range=self.initializer_range ,			)
 def 							__UpperCAmelCase						(	self  )   ->							List[Any]:
      (
          _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 							__UpperCAmelCase						(	self ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__  )   ->							int:
      _a      =							NezhaModel(config=__A  )
      model.to(__A  )
      model.eval()
      _a      =							model(__A ,			attention_mask=__A ,			token_type_ids=__A  )
      _a      =							model(__A ,			token_type_ids=__A  )
      _a      =							model(__A  )
      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 ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			)   ->							Optional[Any]:
      _a      =							True
      _a      =							NezhaModel(__A  )
      model.to(__A  )
      model.eval()
      _a      =							model(
          __A ,			attention_mask=__A ,			token_type_ids=__A ,			encoder_hidden_states=__A ,			encoder_attention_mask=__A ,			)
      _a      =							model(
          __A ,			attention_mask=__A ,			token_type_ids=__A ,			encoder_hidden_states=__A ,			)
      _a      =							model(__A ,			attention_mask=__A ,			token_type_ids=__A  )
      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 ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__  )   ->							Dict:
      _a      =							NezhaForMaskedLM(config=__A  )
      model.to(__A  )
      model.eval()
      _a      =							model(__A ,			attention_mask=__A ,			token_type_ids=__A ,			labels=__A  )
      self.parent.assertEqual(result.logits.shape ,			(self.batch_size, self.seq_length, self.vocab_size)  )
 def 							__UpperCAmelCase						(	self ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__  )   ->							int:
      _a      =							NezhaForNextSentencePrediction(config=__A  )
      model.to(__A  )
      model.eval()
      _a      =							model(
          __A ,			attention_mask=__A ,			token_type_ids=__A ,			labels=__A ,			)
      self.parent.assertEqual(result.logits.shape ,			(self.batch_size, 2)  )
 def 							__UpperCAmelCase						(	self ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__  )   ->							Optional[int]:
      _a      =							NezhaForPreTraining(config=__A  )
      model.to(__A  )
      model.eval()
      _a      =							model(
          __A ,			attention_mask=__A ,			token_type_ids=__A ,			labels=__A ,			next_sentence_label=__A ,			)
      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 ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__  )   ->							List[str]:
      _a      =							NezhaForQuestionAnswering(config=__A  )
      model.to(__A  )
      model.eval()
      _a      =							model(
          __A ,			attention_mask=__A ,			token_type_ids=__A ,			start_positions=__A ,			end_positions=__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 							__UpperCAmelCase						(	self ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__  )   ->							int:
      _a      =							self.num_labels
      _a      =							NezhaForSequenceClassification(__A  )
      model.to(__A  )
      model.eval()
      _a      =							model(__A ,			attention_mask=__A ,			token_type_ids=__A ,			labels=__A  )
      self.parent.assertEqual(result.logits.shape ,			(self.batch_size, self.num_labels)  )
 def 							__UpperCAmelCase						(	self ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__  )   ->							List[Any]:
      _a      =							self.num_labels
      _a      =							NezhaForTokenClassification(config=__A  )
      model.to(__A  )
      model.eval()
      _a      =							model(__A ,			attention_mask=__A ,			token_type_ids=__A ,			labels=__A  )
      self.parent.assertEqual(result.logits.shape ,			(self.batch_size, self.seq_length, self.num_labels)  )
 def 							__UpperCAmelCase						(	self ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__  )   ->							Optional[int]:
      _a      =							self.num_choices
      _a      =							NezhaForMultipleChoice(config=__A  )
      model.to(__A  )
      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(
          __A ,			attention_mask=__A ,			token_type_ids=__A ,			labels=__A ,			)
      self.parent.assertEqual(result.logits.shape ,			(self.batch_size, self.num_choices)  )




 def 							__UpperCAmelCase						(	self  )   ->							Tuple:
      _a      =							self.prepare_config_and_inputs()
      (
          _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 	a       (       lowerCamelCase__					,			lowerCamelCase__					,			lowerCamelCase__					,			unittest.TestCase    ):
 _lowerCAmelCase	   =		(
     (
         NezhaModel,
         NezhaForMaskedLM,
         NezhaForMultipleChoice,
         NezhaForNextSentencePrediction,
         NezhaForPreTraining,
         NezhaForQuestionAnswering,
         NezhaForSequenceClassification,
         NezhaForTokenClassification,
     )
     if is_torch_available()
     else ()
 )
 _lowerCAmelCase	   =		(
     {
         """feature-extraction""": NezhaModel,
         """fill-mask""": NezhaForMaskedLM,
         """question-answering""": NezhaForQuestionAnswering,
         """text-classification""": NezhaForSequenceClassification,
         """token-classification""": NezhaForTokenClassification,
         """zero-shot""": NezhaForSequenceClassification,
     }
     if is_torch_available()
     else {}
 )
 _lowerCAmelCase	   =		True
 def 							__UpperCAmelCase						(	self ,			__magic_name__ ,			__magic_name__ ,			__magic_name__=False  )   ->							str:
      _a      =							super()._prepare_for_class(__A ,			__A ,			return_labels=__A  )

      if return_labels:
           if model_class in get_values(__A  ):
                _a      =							torch.zeros(
                    (self.model_tester.batch_size, self.model_tester.seq_length) ,			dtype=torch.long ,			device=__A  )
                _a      =							torch.zeros(
                    self.model_tester.batch_size ,			dtype=torch.long ,			device=__A  )
      return inputs_dict
 def 							__UpperCAmelCase						(	self  )   ->							str:
      _a      =							NezhaModelTester(self  )
      _a      =							ConfigTester(self ,			config_class=__A ,			hidden_size=37  )
 def 							__UpperCAmelCase						(	self  )   ->							Optional[int]:
      self.config_tester.run_common_tests()
 def 							__UpperCAmelCase						(	self  )   ->							Union[str, Any]:
      _a      =							self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*__A  )
 def 							__UpperCAmelCase						(	self  )   ->							Dict:
      _a      =							self.model_tester.prepare_config_and_inputs_for_decoder()
      self.model_tester.create_and_check_model_as_decoder(*__A  )
 def 							__UpperCAmelCase						(	self  )   ->							Tuple:
      # This regression test was failing with PyTorch < 1.3
      (
          _a						
      )      =							self.model_tester.prepare_config_and_inputs_for_decoder()

      _a      =							None

      self.model_tester.create_and_check_model_as_decoder(
          __A ,			__A ,			__A ,			__A ,			__A ,			__A ,			__A ,			__A ,			__A ,			)
 def 							__UpperCAmelCase						(	self  )   ->							Optional[int]:
      _a      =							self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_masked_lm(*__A  )
 def 							__UpperCAmelCase						(	self  )   ->							Optional[int]:
      _a      =							self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_multiple_choice(*__A  )
 def 							__UpperCAmelCase						(	self  )   ->							List[str]:
      _a      =							self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_next_sequence_prediction(*__A  )
 def 							__UpperCAmelCase						(	self  )   ->							List[Any]:
      _a      =							self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_pretraining(*__A  )
 def 							__UpperCAmelCase						(	self  )   ->							Union[str, Any]:
      _a      =							self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_question_answering(*__A  )
 def 							__UpperCAmelCase						(	self  )   ->							List[Any]:
      _a      =							self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_sequence_classification(*__A  )
 def 							__UpperCAmelCase						(	self  )   ->							Optional[int]:
      _a      =							self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_token_classification(*__A  )
 @slow
 def 							__UpperCAmelCase						(	self  )   ->							Dict:
      for model_name in NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           _a      =							NezhaModel.from_pretrained(__A  )
           self.assertIsNotNone(__A  )




 @slow
 @require_torch_gpu
 def 							__UpperCAmelCase						(	self  )   ->							List[Any]:
      _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=__A  )

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

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





@require_torch
class 	a       (       unittest.TestCase    ):
 @slow
 def 							__UpperCAmelCase						(	self  )   ->							List[str]:
      _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(__A ,			attention_mask=__A  )[0]
      _a      =							torch.Size((1, 6, 7_68)  )
      self.assertEqual(output.shape ,			__A  )
      _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] ,			__A ,			atol=1e-4  )  )




 @slow
 def 							__UpperCAmelCase						(	self  )   ->							Dict:
      _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(__A ,			attention_mask=__A  )[0]
      _a      =							torch.Size((1, 6, 2_11_28)  )
      self.assertEqual(output.shape ,			__A  )
      _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] ,			__A ,			atol=1e-4  )  )





'''simple docstring'''






def 		_A			(lowerCAmelCase__					:list[int]			,  lowerCAmelCase__					:list[int]						)				->					None:




     '''simple docstring'''



     _a      =							len(lowerCAmelCase__						)
     print('The following activities are selected:'						)

     # The first activity is always selected
     _a      =							0
     print(lowerCAmelCase__			,  end=','						)

     # Consider rest of the activities
     for j in range(lowerCAmelCase__						):
          # If this activity has start time greater than
          # or equal to the finish time of previously
          # selected activity, then select it
          if start[j] >= finish[i]:
               print(lowerCAmelCase__			,  end=','						)
               _a      =							j


if __name__ == "__main__":
 import doctest

 doctest.testmod()

 a_   :      List[str]				    =      [1, 3, 0, 5, 8, 5]
 a_   :      str				    =      [2, 4, 6, 7, 9, 9]
 print_max_activities(start, finish)

