




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






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

         """simple docstring"""
         lowerCAmelCase__      :			Union[str, Any]   =	parent
         lowerCAmelCase__      :			Any   =	batch_size
         lowerCAmelCase__      :			Optional[int]   =	seq_length
         lowerCAmelCase__      :			int   =	is_training
         lowerCAmelCase__      :			Optional[int]   =	use_input_mask
         lowerCAmelCase__      :			List[Any]   =	use_token_type_ids
         lowerCAmelCase__      :			int   =	use_labels
         lowerCAmelCase__      :			Tuple   =	vocab_size
         lowerCAmelCase__      :			int   =	hidden_size
         lowerCAmelCase__      :			List[str]   =	num_hidden_layers
         lowerCAmelCase__      :			Tuple   =	num_attention_heads
         lowerCAmelCase__      :			Union[str, Any]   =	intermediate_size
         lowerCAmelCase__      :			Optional[int]   =	hidden_act
         lowerCAmelCase__      :			Any   =	hidden_dropout_prob
         lowerCAmelCase__      :			List[str]   =	attention_probs_dropout_prob
         lowerCAmelCase__      :			int   =	max_position_embeddings
         lowerCAmelCase__      :			Any   =	type_vocab_size
         lowerCAmelCase__      :			Union[str, Any]   =	type_sequence_label_size
         lowerCAmelCase__      :			Optional[int]   =	initializer_range
         lowerCAmelCase__      :			Tuple   =	num_labels
         lowerCAmelCase__      :			Optional[Any]   =	num_choices
         lowerCAmelCase__      :			str   =	scope






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

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

         lowerCAmelCase__      :			int   =	None
         if self.use_input_mask:
               lowerCAmelCase__      :			Tuple   =	random_attention_mask([self.batch_size, self.seq_length]   )

         lowerCAmelCase__      :			str   =	None
         if self.use_token_type_ids:
               lowerCAmelCase__      :			List[Any]   =	ids_tensor([self.batch_size, self.seq_length]   ,     self.type_vocab_size   )

         lowerCAmelCase__      :			List[str]   =	None
         lowerCAmelCase__      :			Tuple   =	None
         lowerCAmelCase__      :			int   =	None
         if self.use_labels:
               lowerCAmelCase__      :			Any   =	ids_tensor([self.batch_size]   ,     self.type_sequence_label_size   )
               lowerCAmelCase__      :			Tuple   =	ids_tensor([self.batch_size, self.seq_length]   ,     self.num_labels   )
               lowerCAmelCase__      :			int   =	ids_tensor([self.batch_size]   ,     self.num_choices   )

         lowerCAmelCase__      :			Dict   =	self.get_config()

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






   def 	_lowerCAmelCase   (		self       :		str   )			->						str:

         """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=UpperCamelCase   ,     initializer_range=self.initializer_range   ,     )






   def 	_lowerCAmelCase   (		self       :		Optional[int]   )			->						int:

         """simple docstring"""
         (
             (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   
         )      :			Dict   =	self.prepare_config_and_inputs()

         lowerCAmelCase__      :			List[str]   =	True
         lowerCAmelCase__      :			Optional[Any]   =	floats_tensor([self.batch_size, self.seq_length, self.hidden_size]   )
         lowerCAmelCase__      :			str   =	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 	_lowerCAmelCase   (		self       :		List[Any]   ,     UpperCamelCase       :		List[Any]   ,     UpperCamelCase       :		Any   ,     UpperCamelCase       :		Union[str, Any]   ,     UpperCamelCase       :		Dict   ,     UpperCamelCase       :		Any   ,     UpperCamelCase       :		Optional[Any]   ,     UpperCamelCase       :		int   )			->						Tuple:

         """simple docstring"""
         lowerCAmelCase__      :			List[str]   =	NezhaModel(config=UpperCamelCase   )
         model.to(UpperCamelCase   )
         model.eval()
         lowerCAmelCase__      :			Dict   =	model(UpperCamelCase   ,     attention_mask=UpperCamelCase   ,     token_type_ids=UpperCamelCase   )
         lowerCAmelCase__      :			List[Any]   =	model(UpperCamelCase   ,     token_type_ids=UpperCamelCase   )
         lowerCAmelCase__      :			Any   =	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 	_lowerCAmelCase   (		self       :		str   ,     UpperCamelCase       :		Union[str, Any]   ,     UpperCamelCase       :		List[str]   ,     UpperCamelCase       :		str   ,     UpperCamelCase       :		Dict   ,     UpperCamelCase       :		str   ,     UpperCamelCase       :		Optional[Any]   ,     UpperCamelCase       :		Any   ,     UpperCamelCase       :		int   ,     UpperCamelCase       :		Union[str, Any]   ,     )			->						Optional[int]:

         """simple docstring"""
         lowerCAmelCase__      :			Tuple   =	True
         lowerCAmelCase__      :			List[str]   =	NezhaModel(UpperCamelCase   )
         model.to(UpperCamelCase   )
         model.eval()
         lowerCAmelCase__      :			str   =	model(
             UpperCamelCase   ,     attention_mask=UpperCamelCase   ,     token_type_ids=UpperCamelCase   ,     encoder_hidden_states=UpperCamelCase   ,     encoder_attention_mask=UpperCamelCase   ,     )
         lowerCAmelCase__      :			Tuple   =	model(
             UpperCamelCase   ,     attention_mask=UpperCamelCase   ,     token_type_ids=UpperCamelCase   ,     encoder_hidden_states=UpperCamelCase   ,     )
         lowerCAmelCase__      :			Union[str, Any]   =	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 	_lowerCAmelCase   (		self       :		Any   ,     UpperCamelCase       :		Optional[Any]   ,     UpperCamelCase       :		List[str]   ,     UpperCamelCase       :		Tuple   ,     UpperCamelCase       :		str   ,     UpperCamelCase       :		Optional[int]   ,     UpperCamelCase       :		Any   ,     UpperCamelCase       :		Union[str, Any]   )			->						List[str]:

         """simple docstring"""
         lowerCAmelCase__      :			List[str]   =	NezhaForMaskedLM(config=UpperCamelCase   )
         model.to(UpperCamelCase   )
         model.eval()
         lowerCAmelCase__      :			List[Any]   =	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 	_lowerCAmelCase   (		self       :		Tuple   ,     UpperCamelCase       :		Optional[Any]   ,     UpperCamelCase       :		List[Any]   ,     UpperCamelCase       :		Optional[int]   ,     UpperCamelCase       :		Optional[int]   ,     UpperCamelCase       :		List[str]   ,     UpperCamelCase       :		Optional[int]   ,     UpperCamelCase       :		List[Any]   )			->						Optional[int]:

         """simple docstring"""
         lowerCAmelCase__      :			Tuple   =	NezhaForNextSentencePrediction(config=UpperCamelCase   )
         model.to(UpperCamelCase   )
         model.eval()
         lowerCAmelCase__      :			str   =	model(
             UpperCamelCase   ,     attention_mask=UpperCamelCase   ,     token_type_ids=UpperCamelCase   ,     labels=UpperCamelCase   ,     )
         self.parent.assertEqual(result.logits.shape   ,     (self.batch_size, 2)   )






   def 	_lowerCAmelCase   (		self       :		Optional[Any]   ,     UpperCamelCase       :		List[Any]   ,     UpperCamelCase       :		str   ,     UpperCamelCase       :		Optional[Any]   ,     UpperCamelCase       :		Optional[Any]   ,     UpperCamelCase       :		List[str]   ,     UpperCamelCase       :		Optional[Any]   ,     UpperCamelCase       :		List[str]   )			->						Tuple:

         """simple docstring"""
         lowerCAmelCase__      :			int   =	NezhaForPreTraining(config=UpperCamelCase   )
         model.to(UpperCamelCase   )
         model.eval()
         lowerCAmelCase__      :			str   =	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 	_lowerCAmelCase   (		self       :		Tuple   ,     UpperCamelCase       :		List[Any]   ,     UpperCamelCase       :		int   ,     UpperCamelCase       :		Tuple   ,     UpperCamelCase       :		Dict   ,     UpperCamelCase       :		str   ,     UpperCamelCase       :		List[str]   ,     UpperCamelCase       :		List[Any]   )			->						List[Any]:

         """simple docstring"""
         lowerCAmelCase__      :			Optional[int]   =	NezhaForQuestionAnswering(config=UpperCamelCase   )
         model.to(UpperCamelCase   )
         model.eval()
         lowerCAmelCase__      :			str   =	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 	_lowerCAmelCase   (		self       :		Dict   ,     UpperCamelCase       :		Tuple   ,     UpperCamelCase       :		List[str]   ,     UpperCamelCase       :		int   ,     UpperCamelCase       :		Union[str, Any]   ,     UpperCamelCase       :		List[str]   ,     UpperCamelCase       :		str   ,     UpperCamelCase       :		Tuple   )			->						List[str]:

         """simple docstring"""
         lowerCAmelCase__      :			List[Any]   =	self.num_labels
         lowerCAmelCase__      :			Optional[int]   =	NezhaForSequenceClassification(UpperCamelCase   )
         model.to(UpperCamelCase   )
         model.eval()
         lowerCAmelCase__      :			Any   =	model(UpperCamelCase   ,     attention_mask=UpperCamelCase   ,     token_type_ids=UpperCamelCase   ,     labels=UpperCamelCase   )
         self.parent.assertEqual(result.logits.shape   ,     (self.batch_size, self.num_labels)   )






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

         """simple docstring"""
         lowerCAmelCase__      :			List[str]   =	self.num_labels
         lowerCAmelCase__      :			int   =	NezhaForTokenClassification(config=UpperCamelCase   )
         model.to(UpperCamelCase   )
         model.eval()
         lowerCAmelCase__      :			Dict   =	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 	_lowerCAmelCase   (		self       :		Any   ,     UpperCamelCase       :		Optional[int]   ,     UpperCamelCase       :		Optional[Any]   ,     UpperCamelCase       :		Tuple   ,     UpperCamelCase       :		Optional[Any]   ,     UpperCamelCase       :		List[str]   ,     UpperCamelCase       :		Tuple   ,     UpperCamelCase       :		int   )			->						Optional[int]:

         """simple docstring"""
         lowerCAmelCase__      :			Union[str, Any]   =	self.num_choices
         lowerCAmelCase__      :			Tuple   =	NezhaForMultipleChoice(config=UpperCamelCase   )
         model.to(UpperCamelCase   )
         model.eval()
         lowerCAmelCase__      :			str   =	input_ids.unsqueeze(1   ).expand(-1   ,     self.num_choices   ,     -1   ).contiguous()
         lowerCAmelCase__      :			Union[str, Any]   =	token_type_ids.unsqueeze(1   ).expand(-1   ,     self.num_choices   ,     -1   ).contiguous()
         lowerCAmelCase__      :			List[str]   =	input_mask.unsqueeze(1   ).expand(-1   ,     self.num_choices   ,     -1   ).contiguous()
         lowerCAmelCase__      :			Optional[Any]   =	model(
             UpperCamelCase   ,     attention_mask=UpperCamelCase   ,     token_type_ids=UpperCamelCase   ,     labels=UpperCamelCase   ,     )
         self.parent.assertEqual(result.logits.shape   ,     (self.batch_size, self.num_choices)   )






   def 	_lowerCAmelCase   (		self       :		Union[str, Any]   )			->						Tuple:

         """simple docstring"""
         lowerCAmelCase__      :			List[str]   =	self.prepare_config_and_inputs()
         (
             (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   
         )      :			Union[str, Any]   =	config_and_inputs
         lowerCAmelCase__      :			int   =	{"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
         return config, inputs_dict






@require_torch
class _lowerCamelCase    (					a_       ,	a_       ,	a_       ,	unittest.TestCase						):
   _lowerCamelCase    :Optional[int]     				=     (
       (
           NezhaModel,
           NezhaForMaskedLM,
           NezhaForMultipleChoice,
           NezhaForNextSentencePrediction,
           NezhaForPreTraining,
           NezhaForQuestionAnswering,
           NezhaForSequenceClassification,
           NezhaForTokenClassification,
       )
       if is_torch_available()
       else ()
   )
   _lowerCamelCase    :Dict     				=     (
       {
           "feature-extraction": NezhaModel,
           "fill-mask": NezhaForMaskedLM,
           "question-answering": NezhaForQuestionAnswering,
           "text-classification": NezhaForSequenceClassification,
           "token-classification": NezhaForTokenClassification,
           "zero-shot": NezhaForSequenceClassification,
       }
       if is_torch_available()
       else {}
   )
   _lowerCamelCase    :Dict     				=     True






   def 	_lowerCAmelCase   (		self       :		Dict   ,     UpperCamelCase       :		Optional[Any]   ,     UpperCamelCase       :		Optional[int]   ,     UpperCamelCase       :		int=False   )			->						Optional[int]:

         """simple docstring"""
         lowerCAmelCase__      :			Dict   =	super()._prepare_for_class(UpperCamelCase   ,     UpperCamelCase   ,     return_labels=UpperCamelCase   )

         if return_labels:
               if model_class in get_values(UpperCamelCase   ):
                     lowerCAmelCase__      :			int   =	torch.zeros(
                         (self.model_tester.batch_size, self.model_tester.seq_length)   ,     dtype=torch.long   ,     device=UpperCamelCase   )
                     lowerCAmelCase__      :			Any   =	torch.zeros(
                         self.model_tester.batch_size   ,     dtype=torch.long   ,     device=UpperCamelCase   )
         return inputs_dict






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

         """simple docstring"""
         lowerCAmelCase__      :			Dict   =	NezhaModelTester(self   )
         lowerCAmelCase__      :			Any   =	ConfigTester(self   ,     config_class=UpperCamelCase   ,     hidden_size=37   )






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

         """simple docstring"""
         self.config_tester.run_common_tests()






   def 	_lowerCAmelCase   (		self       :		Tuple   )			->						List[str]:

         """simple docstring"""
         lowerCAmelCase__      :			int   =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*UpperCamelCase   )






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

         """simple docstring"""
         lowerCAmelCase__      :			Union[str, Any]   =	self.model_tester.prepare_config_and_inputs_for_decoder()
         self.model_tester.create_and_check_model_as_decoder(*UpperCamelCase   )






   def 	_lowerCAmelCase   (		self       :		Dict   )			->						Union[str, Any]:

         """simple docstring"""
         # This regression test was failing with PyTorch < 1.3
         (
             (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   
         )      :			Optional[int]   =	self.model_tester.prepare_config_and_inputs_for_decoder()

         lowerCAmelCase__      :			str   =	None

         self.model_tester.create_and_check_model_as_decoder(
             UpperCamelCase   ,     UpperCamelCase   ,     UpperCamelCase   ,     UpperCamelCase   ,     UpperCamelCase   ,     UpperCamelCase   ,     UpperCamelCase   ,     UpperCamelCase   ,     UpperCamelCase   ,     )






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

         """simple docstring"""
         lowerCAmelCase__      :			str   =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_lm(*UpperCamelCase   )






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

         """simple docstring"""
         lowerCAmelCase__      :			Tuple   =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_multiple_choice(*UpperCamelCase   )






   def 	_lowerCAmelCase   (		self       :		int   )			->						Dict:

         """simple docstring"""
         lowerCAmelCase__      :			str   =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_next_sequence_prediction(*UpperCamelCase   )






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

         """simple docstring"""
         lowerCAmelCase__      :			List[str]   =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_pretraining(*UpperCamelCase   )






   def 	_lowerCAmelCase   (		self       :		int   )			->						Tuple:

         """simple docstring"""
         lowerCAmelCase__      :			Optional[int]   =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_question_answering(*UpperCamelCase   )






   def 	_lowerCAmelCase   (		self       :		int   )			->						Optional[int]:

         """simple docstring"""
         lowerCAmelCase__      :			int   =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_sequence_classification(*UpperCamelCase   )






   def 	_lowerCAmelCase   (		self       :		List[str]   )			->						List[str]:

         """simple docstring"""
         lowerCAmelCase__      :			Dict   =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_token_classification(*UpperCamelCase   )






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

         """simple docstring"""
         for model_name in NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               lowerCAmelCase__      :			Tuple   =	NezhaModel.from_pretrained(UpperCamelCase   )
               self.assertIsNotNone(UpperCamelCase   )






   @slow
   @require_torch_gpu
   def 	_lowerCAmelCase   (		self       :		Optional[int]   )			->						Dict:

         """simple docstring"""
         lowerCAmelCase__ ,   lowerCAmelCase__      :			List[Any]   =	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

               lowerCAmelCase__      :			List[Any]   =	True
               lowerCAmelCase__      :			Any   =	model_class(config=UpperCamelCase   )

               lowerCAmelCase__      :			List[Any]   =	self._prepare_for_class(UpperCamelCase   ,     UpperCamelCase   )
               lowerCAmelCase__      :			int   =	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"""   )   )
                     lowerCAmelCase__      :			Any   =	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						):






   @slow
   def 	_lowerCAmelCase   (		self       :		Optional[Any]   )			->						Dict:

         """simple docstring"""
         lowerCAmelCase__      :			List[str]   =	NezhaModel.from_pretrained("""sijunhe/nezha-cn-base"""   )
         lowerCAmelCase__      :			Optional[int]   =	torch.tensor([[0, 1, 2, 3, 4, 5]]   )
         lowerCAmelCase__      :			List[Any]   =	torch.tensor([[0, 1, 1, 1, 1, 1]]   )
         with torch.no_grad():
               lowerCAmelCase__      :			List[Any]   =	model(UpperCamelCase   ,     attention_mask=UpperCamelCase   )[0]
         lowerCAmelCase__      :			Any   =	torch.Size((1, 6, 7_68)   )
         self.assertEqual(output.shape   ,     UpperCamelCase   )
         lowerCAmelCase__      :			Dict   =	torch.tensor([[[0.0685, 0.2441, 0.1102], [0.0600, 0.1906, 0.1349], [0.0221, 0.0819, 0.0586]]]   )

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






   @slow
   def 	_lowerCAmelCase   (		self       :		str   )			->						Optional[Any]:

         """simple docstring"""
         lowerCAmelCase__      :			Dict   =	NezhaForMaskedLM.from_pretrained("""sijunhe/nezha-cn-base"""   )
         lowerCAmelCase__      :			Optional[int]   =	torch.tensor([[0, 1, 2, 3, 4, 5]]   )
         lowerCAmelCase__      :			Optional[int]   =	torch.tensor([[1, 1, 1, 1, 1, 1]]   )
         with torch.no_grad():
               lowerCAmelCase__      :			Any   =	model(UpperCamelCase   ,     attention_mask=UpperCamelCase   )[0]
         lowerCAmelCase__      :			List[str]   =	torch.Size((1, 6, 2_11_28)   )
         self.assertEqual(output.shape   ,     UpperCamelCase   )
         lowerCAmelCase__      :			Optional[Any]   =	torch.tensor(
             [[-2.7939, -1.7902, -2.2189], [-2.8585, -1.8908, -2.3723], [-2.6499, -1.7750, -2.2558]]   )

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











"""simple docstring"""


import json
import os
from functools import lru_cache
from typing import TYPE_CHECKING, List, Optional, Tuple

import regex as re

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


if TYPE_CHECKING:
  from transformers.pipelines.conversational import Conversation

_A													=      logging.get_logger(__name__)


_A													=      {
    """vocab_file""": """vocab.json""",
    """merges_file""": """merges.txt""",
    """tokenizer_config_file""": """tokenizer_config.json""",
}

_A													=      {
    """vocab_file""": {"""facebook/blenderbot-3B""": """https://huggingface.co/facebook/blenderbot-3B/resolve/main/vocab.json"""},
    """merges_file""": {"""facebook/blenderbot-3B""": """https://huggingface.co/facebook/blenderbot-3B/resolve/main/merges.txt"""},
    """tokenizer_config_file""": {
        """facebook/blenderbot-3B""": """https://huggingface.co/facebook/blenderbot-3B/resolve/main/tokenizer_config.json"""
    },
}

_A													=      {"""facebook/blenderbot-3B""": 1_2_8}



@lru_cache()
# Copied from transformers.models.roberta.tokenization_roberta.bytes_to_unicode
def 	lowercase_				(			)						->    Tuple:
      lowerCAmelCase__      :			int   =	(
          list(range(ord("""!"""				)    ,		ord("""~"""				) + 1				)				) + list(range(ord("""¡"""				)    ,		ord("""¬"""				) + 1				)				) + list(range(ord("""®"""				)    ,		ord("""ÿ"""				) + 1				)				)
      )
      lowerCAmelCase__      :			Any   =	bs[:]
      lowerCAmelCase__      :			Optional[int]   =	0
      for b in range(2**8				):
            if b not in bs:
                  bs.append(__UpperCAmelCase				)
                  cs.append(2**8 + n				)
                  n += 1
      lowerCAmelCase__      :			Dict   =	[chr(__UpperCAmelCase				) for n in cs]
      return dict(zip(__UpperCAmelCase    ,		__UpperCAmelCase				)				)



def 	lowercase_				(			__UpperCAmelCase				)						->    List[Any]:
      lowerCAmelCase__      :			List[Any]   =	set()
      lowerCAmelCase__      :			Union[str, Any]   =	word[0]
      for char in word[1:]:
            pairs.add((prev_char, char)				)
            lowerCAmelCase__      :			Optional[Any]   =	char
      return pairs


class _lowerCamelCase    (					a_						):
   _lowerCamelCase    :Optional[Any]     				=     VOCAB_FILES_NAMES
   _lowerCamelCase    :List[Any]     				=     PRETRAINED_VOCAB_FILES_MAP
   _lowerCamelCase    :Union[str, Any]     				=     PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
   _lowerCamelCase    :Optional[Any]     				=     ["input_ids", "attention_mask"]






   def __init__(		self       :		Any   ,     UpperCamelCase       :		str   ,     UpperCamelCase       :		Tuple   ,     UpperCamelCase       :		Any="replace"   ,     UpperCamelCase       :		Optional[Any]="<s>"   ,     UpperCamelCase       :		Union[str, Any]="</s>"   ,     UpperCamelCase       :		Optional[int]="</s>"   ,     UpperCamelCase       :		str="<s>"   ,     UpperCamelCase       :		int="<unk>"   ,     UpperCamelCase       :		int="<pad>"   ,     UpperCamelCase       :		Dict="<mask>"   ,     UpperCamelCase       :		Optional[int]=False   ,     **UpperCamelCase       :		Optional[Any]   ,     )			->						Any:

         """simple docstring"""
         lowerCAmelCase__      :			Union[str, Any]   =	AddedToken(UpperCamelCase   ,     lstrip=UpperCamelCase   ,     rstrip=UpperCamelCase   ) if isinstance(UpperCamelCase   ,     UpperCamelCase   ) else bos_token
         lowerCAmelCase__      :			int   =	AddedToken(UpperCamelCase   ,     lstrip=UpperCamelCase   ,     rstrip=UpperCamelCase   ) if isinstance(UpperCamelCase   ,     UpperCamelCase   ) else eos_token
         lowerCAmelCase__      :			Dict   =	AddedToken(UpperCamelCase   ,     lstrip=UpperCamelCase   ,     rstrip=UpperCamelCase   ) if isinstance(UpperCamelCase   ,     UpperCamelCase   ) else sep_token
         lowerCAmelCase__      :			Union[str, Any]   =	AddedToken(UpperCamelCase   ,     lstrip=UpperCamelCase   ,     rstrip=UpperCamelCase   ) if isinstance(UpperCamelCase   ,     UpperCamelCase   ) else cls_token
         lowerCAmelCase__      :			int   =	AddedToken(UpperCamelCase   ,     lstrip=UpperCamelCase   ,     rstrip=UpperCamelCase   ) if isinstance(UpperCamelCase   ,     UpperCamelCase   ) else unk_token
         lowerCAmelCase__      :			Union[str, Any]   =	AddedToken(UpperCamelCase   ,     lstrip=UpperCamelCase   ,     rstrip=UpperCamelCase   ) if isinstance(UpperCamelCase   ,     UpperCamelCase   ) else pad_token

         # Mask token behave like a normal word, i.e. include the space before it
         lowerCAmelCase__      :			Union[str, Any]   =	AddedToken(UpperCamelCase   ,     lstrip=UpperCamelCase   ,     rstrip=UpperCamelCase   ) if isinstance(UpperCamelCase   ,     UpperCamelCase   ) else mask_token

         super().__init__(
             errors=UpperCamelCase   ,     bos_token=UpperCamelCase   ,     eos_token=UpperCamelCase   ,     unk_token=UpperCamelCase   ,     sep_token=UpperCamelCase   ,     cls_token=UpperCamelCase   ,     pad_token=UpperCamelCase   ,     mask_token=UpperCamelCase   ,     add_prefix_space=UpperCamelCase   ,     **UpperCamelCase   ,     )

         with open(UpperCamelCase   ,     encoding="""utf-8"""   ) as vocab_handle:
               lowerCAmelCase__      :			Any   =	json.load(UpperCamelCase   )
         lowerCAmelCase__      :			Union[str, Any]   =	{v: k for k, v in self.encoder.items()}
         lowerCAmelCase__      :			Dict   =	errors  # how to handle errors in decoding
         lowerCAmelCase__      :			Union[str, Any]   =	bytes_to_unicode()
         lowerCAmelCase__      :			List[str]   =	{v: k for k, v in self.byte_encoder.items()}
         with open(UpperCamelCase   ,     encoding="""utf-8"""   ) as merges_handle:
               lowerCAmelCase__      :			Optional[int]   =	merges_handle.read().split("""\n"""   )[1:-1]
         lowerCAmelCase__      :			Dict   =	[tuple(merge.split()   ) for merge in bpe_merges]
         lowerCAmelCase__      :			Any   =	dict(zip(UpperCamelCase   ,     range(len(UpperCamelCase   )   )   )   )
         lowerCAmelCase__      :			Union[str, Any]   =	{}
         lowerCAmelCase__      :			Dict   =	add_prefix_space

         # Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
         lowerCAmelCase__      :			Tuple   =	re.compile(r"""'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+"""   )






   @property
   # Copied from transformers.models.roberta.tokenization_roberta.RobertaTokenizer.vocab_size with Roberta->Blenderbot, RoBERTa->Blenderbot
   def 	_lowerCAmelCase   (		self       :		List[str]   )			->						Union[str, Any]:

         """simple docstring"""
         return len(self.encoder   )






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

         """simple docstring"""
         return dict(self.encoder   ,     **self.added_tokens_encoder   )






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

         """simple docstring"""
         if token in self.cache:
               return self.cache[token]
         lowerCAmelCase__      :			Union[str, Any]   =	tuple(UpperCamelCase   )
         lowerCAmelCase__      :			List[str]   =	get_pairs(UpperCamelCase   )

         if not pairs:
               return token

         while True:
               lowerCAmelCase__      :			List[str]   =	min(UpperCamelCase   ,     key=lambda UpperCamelCase   : self.bpe_ranks.get(UpperCamelCase   ,     float("""inf"""   )   )   )
               if bigram not in self.bpe_ranks:
                     break
               lowerCAmelCase__ ,   lowerCAmelCase__      :			str   =	bigram
               lowerCAmelCase__      :			List[str]   =	[]
               lowerCAmelCase__      :			List[str]   =	0
               while i < len(UpperCamelCase   ):
                     try:
                           lowerCAmelCase__      :			Optional[Any]   =	word.index(UpperCamelCase   ,     UpperCamelCase   )
                     except ValueError:
                           new_word.extend(word[i:]   )
                           break
                     else:
                           new_word.extend(word[i:j]   )
                           lowerCAmelCase__      :			List[str]   =	j

                     if word[i] == first and i < len(UpperCamelCase   ) - 1 and word[i + 1] == second:
                           new_word.append(first + second   )
                           i += 2
                     else:
                           new_word.append(word[i]   )
                           i += 1
               lowerCAmelCase__      :			List[Any]   =	tuple(UpperCamelCase   )
               lowerCAmelCase__      :			Tuple   =	new_word
               if len(UpperCamelCase   ) == 1:
                     break
               else:
                     lowerCAmelCase__      :			Any   =	get_pairs(UpperCamelCase   )
         lowerCAmelCase__      :			Tuple   =	""" """.join(UpperCamelCase   )
         lowerCAmelCase__      :			Tuple   =	word
         return word






   def 	_lowerCAmelCase   (		self       :		Union[str, Any]   ,     UpperCamelCase       :		List[str]   )			->						Optional[Any]:

         """simple docstring"""
         lowerCAmelCase__      :			Tuple   =	[]
         for token in re.findall(self.pat   ,     UpperCamelCase   ):
               lowerCAmelCase__      :			List[Any]   =	"""""".join(
                   self.byte_encoder[b] for b in token.encode("""utf-8"""   )   )  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
               bpe_tokens.extend(bpe_token for bpe_token in self.bpe(UpperCamelCase   ).split(""" """   )   )
         return bpe_tokens






   def 	_lowerCAmelCase   (		self       :		Optional[Any]   ,     UpperCamelCase       :		Union[str, Any]   )			->						Dict:

         """simple docstring"""
         return self.encoder.get(UpperCamelCase   ,     self.encoder.get(self.unk_token   )   )






   def 	_lowerCAmelCase   (		self       :		Union[str, Any]   ,     UpperCamelCase       :		Optional[Any]   )			->						Tuple:

         """simple docstring"""
         return self.decoder.get(UpperCamelCase   )






   def 	_lowerCAmelCase   (		self       :		List[Any]   ,     UpperCamelCase       :		Optional[int]   )			->						Optional[int]:

         """simple docstring"""
         lowerCAmelCase__      :			List[str]   =	"""""".join(UpperCamelCase   )
         lowerCAmelCase__      :			List[str]   =	bytearray([self.byte_decoder[c] for c in text]   ).decode("""utf-8"""   ,     errors=self.errors   )
         return text






   def 	_lowerCAmelCase   (		self       :		List[str]   ,     UpperCamelCase       :		str   ,     UpperCamelCase       :		Optional[str] = None   )			->						Tuple[str]:

         """simple docstring"""
         if not os.path.isdir(UpperCamelCase   ):
               logger.error(f"""Vocabulary path ({save_directory}) should be a directory"""   )
               return
         lowerCAmelCase__      :			Union[str, Any]   =	os.path.join(
             UpperCamelCase   ,     (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""]   )
         lowerCAmelCase__      :			int   =	os.path.join(
             UpperCamelCase   ,     (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""merges_file"""]   )

         with open(UpperCamelCase   ,     """w"""   ,     encoding="""utf-8"""   ) as f:
               f.write(json.dumps(self.encoder   ,     indent=2   ,     sort_keys=UpperCamelCase   ,     ensure_ascii=UpperCamelCase   ) + """\n"""   )

         lowerCAmelCase__      :			Optional[Any]   =	0
         with open(UpperCamelCase   ,     """w"""   ,     encoding="""utf-8"""   ) as writer:
               writer.write("""#version: 0.2\n"""   )
               for bpe_tokens, token_index in sorted(self.bpe_ranks.items()   ,     key=lambda UpperCamelCase   : kv[1]   ):
                     if index != token_index:
                           logger.warning(
                               f"""Saving vocabulary to {merge_file}: BPE merge indices are not consecutive."""
                               """ Please check that the tokenizer is not corrupted!"""   )
                           lowerCAmelCase__      :			Dict   =	token_index
                     writer.write(""" """.join(UpperCamelCase   ) + """\n"""   )
                     index += 1

         return vocab_file, merge_file






   def 	_lowerCAmelCase   (		self       :		Dict   ,     UpperCamelCase       :		List[int]   ,     UpperCamelCase       :		Optional[List[int]] = None   ,     UpperCamelCase       :		bool = False   )			->						List[int]:

         """simple docstring"""
         if already_has_special_tokens:
               return super().get_special_tokens_mask(
                   token_ids_a=UpperCamelCase   ,     token_ids_a=UpperCamelCase   ,     already_has_special_tokens=UpperCamelCase   )

         if token_ids_a is None:
               return [1] + ([0] * len(UpperCamelCase   )) + [1]
         return [1] + ([0] * len(UpperCamelCase   )) + [1, 1] + ([0] * len(UpperCamelCase   )) + [1]






   def 	_lowerCAmelCase   (		self       :		Optional[int]   ,     UpperCamelCase       :		List[int]   ,     UpperCamelCase       :		Optional[List[int]] = None   )			->						List[int]:

         """simple docstring"""
         lowerCAmelCase__      :			Union[str, Any]   =	[self.sep_token_id]
         lowerCAmelCase__      :			List[str]   =	[self.cls_token_id]

         if token_ids_a is None:
               return len(cls + token_ids_a + sep   ) * [0]
         return len(cls + token_ids_a + sep + sep + token_ids_a + sep   ) * [0]






   def 	_lowerCAmelCase   (		self       :		Union[str, Any]   ,     UpperCamelCase       :		Any   ,     UpperCamelCase       :		Optional[int]=False   ,     **UpperCamelCase       :		Union[str, Any]   )			->						str:

         """simple docstring"""
         lowerCAmelCase__      :			int   =	kwargs.pop("""add_prefix_space"""   ,     self.add_prefix_space   )
         if (is_split_into_words or add_prefix_space) and (len(UpperCamelCase   ) > 0 and not text[0].isspace()):
               lowerCAmelCase__      :			Tuple   =	""" """ + text
         return (text, kwargs)






   def 	_lowerCAmelCase   (		self       :		Optional[Any]   ,     UpperCamelCase       :		List[int]   ,     UpperCamelCase       :		Optional[List[int]] = None   )			->						Any:

         """simple docstring"""
         return token_ids_a + [self.eos_token_id]






   def 	_lowerCAmelCase   (		self       :		str   ,     UpperCamelCase       :		"Conversation"   )			->						List[int]:

         """simple docstring"""
         lowerCAmelCase__      :			List[str]   =	[]
         for is_user, text in conversation.iter_texts():
               if is_user:
                     # We need to space prefix as it's being done within blenderbot
                     inputs.append(""" """ + text   )
               else:
                     # Generated responses should contain them already.
                     inputs.append(UpperCamelCase   )

         lowerCAmelCase__      :			Union[str, Any]   =	"""  """.join(UpperCamelCase   )
         lowerCAmelCase__      :			Union[str, Any]   =	self.encode(UpperCamelCase   )
         if len(UpperCamelCase   ) > self.model_max_length:
               lowerCAmelCase__      :			List[str]   =	input_ids[-self.model_max_length :]
               logger.warning(f"""Trimmed input from conversation as it was longer than {self.model_max_length} tokens."""   )
         return input_ids





