



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


	'''simple docstring'''




	def __init__(   self							,  lowerCAmelCase_							,  lowerCAmelCase_=1_3							,  lowerCAmelCase_=7							,  lowerCAmelCase_=True							,  lowerCAmelCase_=True							,  lowerCAmelCase_=True							,  lowerCAmelCase_=True							,  lowerCAmelCase_=9_9							,  lowerCAmelCase_=3_2							,  lowerCAmelCase_=5							,  lowerCAmelCase_=4							,  lowerCAmelCase_=3_7							,  lowerCAmelCase_="gelu"							,  lowerCAmelCase_=0.1							,  lowerCAmelCase_=0.1							,  lowerCAmelCase_=1_2_8							,  lowerCAmelCase_=3_2							,  lowerCAmelCase_=1_6							,  lowerCAmelCase_=2							,  lowerCAmelCase_=0.0_2							,  lowerCAmelCase_=3							,  lowerCAmelCase_=4							,  lowerCAmelCase_=None							,  ) ->      Optional[Any]:



						"""simple docstring"""







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




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



						"""simple docstring"""







						a_       		=ids_tensor([self.batch_size, self.seq_length]							,  self.vocab_size)

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

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

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

						a_       		=self.get_config()

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




	def       lowercase_  (   self) ->      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=lowerCAmelCase_							,  initializer_range=self.initializer_range							,  )




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



						"""simple docstring"""







						(
						    (
						    a_						
						)		,						(
						    a_						
						)		,						(
						    a_						
						)		,						(
						    a_						
						)		,						(
						    a_						
						)		,						(
						    a_						
						)		,						(
						    a_						
						)		,												
						)       		=self.prepare_config_and_inputs()

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

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




	def       lowercase_  (   self							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_) ->      int:



						"""simple docstring"""







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




	def       lowercase_  (   self							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  ) ->      int:



						"""simple docstring"""







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




	def       lowercase_  (   self							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_) ->      Optional[int]:



						"""simple docstring"""







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




	def       lowercase_  (   self							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_) ->      Optional[Any]:



						"""simple docstring"""







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




	def       lowercase_  (   self							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_) ->      Optional[int]:



						"""simple docstring"""







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




	def       lowercase_  (   self							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_) ->      Dict:



						"""simple docstring"""







						a_       		=NezhaForQuestionAnswering(config=lowerCAmelCase_)
						model.to(lowerCAmelCase_)
						model.eval()
						a_       		=model(
						    lowerCAmelCase_							,  attention_mask=lowerCAmelCase_							,  token_type_ids=lowerCAmelCase_							,  start_positions=lowerCAmelCase_							,  end_positions=lowerCAmelCase_							,  )
						self.parent.assertEqual(result.start_logits.shape							,  (self.batch_size, self.seq_length))
						self.parent.assertEqual(result.end_logits.shape							,  (self.batch_size, self.seq_length))




	def       lowercase_  (   self							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_) ->      List[Any]:



						"""simple docstring"""







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




	def       lowercase_  (   self							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_) ->      Tuple:



						"""simple docstring"""







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




	def       lowercase_  (   self							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_) ->      Dict:



						"""simple docstring"""







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




	def       lowercase_  (   self) ->      int:



						"""simple docstring"""







						a_       		=self.prepare_config_and_inputs()
						(
						    (
						    a_						
						)		,						(
						    a_						
						)		,						(
						    a_						
						)		,						(
						    a_						
						)		,						(
						    a_						
						)		,						(
						    a_						
						)		,						(
						    a_						
						)		,												
						)       		=config_and_inputs
						a_       		={"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
						return config, inputs_dict







@require_torch
class 	UpperCAmelCase	(		__a					,	__a					,	__a					,	unittest.TestCase):


	'''simple docstring'''




	__magic_name__					: List[Any]  =      (
	    (
	        NezhaModel,
	        NezhaForMaskedLM,
	        NezhaForMultipleChoice,
	        NezhaForNextSentencePrediction,
	        NezhaForPreTraining,
	        NezhaForQuestionAnswering,
	        NezhaForSequenceClassification,
	        NezhaForTokenClassification,
	    )
	    if is_torch_available()
	    else ()
	)
	__magic_name__					: 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 {}
	)
	__magic_name__					: List[str]  =      True




	def       lowercase_  (   self							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_=False) ->      Optional[int]:



						"""simple docstring"""







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

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




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



						"""simple docstring"""







						a_       		=NezhaModelTester(self)
						a_       		=ConfigTester(self							,  config_class=lowerCAmelCase_							,  hidden_size=3_7)




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



						"""simple docstring"""







						self.config_tester.run_common_tests()




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



						"""simple docstring"""







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




	def       lowercase_  (   self) ->      Tuple:



						"""simple docstring"""







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




	def       lowercase_  (   self) ->      Dict:



						"""simple docstring"""







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

						a_       		=None

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




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



						"""simple docstring"""







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




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



						"""simple docstring"""







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




	def       lowercase_  (   self) ->      str:



						"""simple docstring"""







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




	def       lowercase_  (   self) ->      Tuple:



						"""simple docstring"""







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




	def       lowercase_  (   self) ->      int:



						"""simple docstring"""







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




	def       lowercase_  (   self) ->      str:



						"""simple docstring"""







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




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



						"""simple docstring"""







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




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



						"""simple docstring"""







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




	@slow
	@require_torch_gpu
	def       lowercase_  (   self) ->      List[str]:



						"""simple docstring"""







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

											a_       		=True
											a_       		=model_class(config=lowerCAmelCase_)

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

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







@require_torch
class 	UpperCAmelCase	(		unittest.TestCase):


	'''simple docstring'''




	@slow
	def       lowercase_  (   self) ->      str:



						"""simple docstring"""







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

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




	@slow
	def       lowercase_  (   self) ->      Tuple:



						"""simple docstring"""







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

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







'''simple docstring'''


from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_torch_available,
)


lowercase							       =			{
    '''configuration_vision_encoder_decoder''': ['''VisionEncoderDecoderConfig''', '''VisionEncoderDecoderOnnxConfig''']
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  lowercase							       =			['''VisionEncoderDecoderModel''']

try:
  if not is_tf_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  lowercase							       =			['''TFVisionEncoderDecoderModel''']

try:
  if not is_flax_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  lowercase							       =			['''FlaxVisionEncoderDecoderModel''']

if TYPE_CHECKING:
  from .configuration_vision_encoder_decoder import VisionEncoderDecoderConfig, VisionEncoderDecoderOnnxConfig

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_vision_encoder_decoder import VisionEncoderDecoderModel

  try:
    if not is_tf_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_tf_vision_encoder_decoder import TFVisionEncoderDecoderModel

  try:
    if not is_flax_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_flax_vision_encoder_decoder import FlaxVisionEncoderDecoderModel

else:
  import sys

  lowercase							       =			_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)


