






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


  """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__=128   ,	UpperCamelCase__=32   ,	UpperCamelCase__=16   ,	UpperCamelCase__=2   ,	UpperCamelCase__=0.02   ,	UpperCamelCase__=3   ,	UpperCamelCase__=4   ,	UpperCamelCase__=None   ,	):






         """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    _a       (			self	):






         """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    _a       (			self	):






         """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    _a       (			self	):






         """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    _a       (			self   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__	):






         """simple docstring"""


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







  def    _a       (			self   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	):






         """simple docstring"""


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







  def    _a       (			self   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__	):






         """simple docstring"""


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







  def    _a       (			self   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__	):






         """simple docstring"""


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







  def    _a       (			self   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__	):






         """simple docstring"""


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







  def    _a       (			self   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__	):






         """simple docstring"""


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







  def    _a       (			self   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__	):






         """simple docstring"""


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







  def    _a       (			self   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__	):






         """simple docstring"""


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







  def    _a       (			self   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__	):






         """simple docstring"""


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







  def    _a       (			self	):






         """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   __SCREAMING_SNAKE_CASE       (__A							,       __A							,       __A							,       unittest.TestCase       ):


  """simple docstring"""


  _a  : Optional[int]      			=     (
      (
          NezhaModel,
          NezhaForMaskedLM,
          NezhaForMultipleChoice,
          NezhaForNextSentencePrediction,
          NezhaForPreTraining,
          NezhaForQuestionAnswering,
          NezhaForSequenceClassification,
          NezhaForTokenClassification,
      )
      if is_torch_available()
      else ()
  )
  _a  : Optional[Any]      			=     (
      {
          '''feature-extraction''': NezhaModel,
          '''fill-mask''': NezhaForMaskedLM,
          '''question-answering''': NezhaForQuestionAnswering,
          '''text-classification''': NezhaForSequenceClassification,
          '''token-classification''': NezhaForTokenClassification,
          '''zero-shot''': NezhaForSequenceClassification,
      }
      if is_torch_available()
      else {}
  )
  _a  : Optional[Any]      			=     True







  def    _a       (			self   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__=False	):






         """simple docstring"""


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

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







  def    _a       (			self	):






         """simple docstring"""


         a_						     =			NezhaModelTester(self	)
         a_						     =			ConfigTester(self   ,	config_class=UpperCamelCase__   ,	hidden_size=37	)







  def    _a       (			self	):






         """simple docstring"""


         self.config_tester.run_common_tests()







  def    _a       (			self	):






         """simple docstring"""


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







  def    _a       (			self	):






         """simple docstring"""


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







  def    _a       (			self	):






         """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(
             UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	UpperCamelCase__   ,	)







  def    _a       (			self	):






         """simple docstring"""


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







  def    _a       (			self	):






         """simple docstring"""


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







  def    _a       (			self	):






         """simple docstring"""


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







  def    _a       (			self	):






         """simple docstring"""


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







  def    _a       (			self	):






         """simple docstring"""


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







  def    _a       (			self	):






         """simple docstring"""


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







  def    _a       (			self	):






         """simple docstring"""


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







  @slow
  def    _a       (			self	):






         """simple docstring"""


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







  @slow
  @require_torch_gpu
  def    _a       (			self	):






         """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=UpperCamelCase__	)

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

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





@require_torch
class   __SCREAMING_SNAKE_CASE       (unittest.TestCase       ):


  """simple docstring"""


  @slow
  def    _a       (			self	):






         """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(UpperCamelCase__   ,	attention_mask=UpperCamelCase__	)[0]
         a_						     =			torch.Size((1, 6, 768)	)
         self.assertEqual(output.shape   ,	UpperCamelCase__	)
         a_						     =			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    _a       (			self	):






         """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(UpperCamelCase__   ,	attention_mask=UpperCamelCase__	)[0]
         a_						     =			torch.Size((1, 6, 21_128)	)
         self.assertEqual(output.shape   ,	UpperCamelCase__	)
         a_						     =			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	)	)












'''simple docstring'''







from __future__ import annotations

from collections.abc import Iterator
from typing import Generic, TypeVar

__lowerCAmelCase        =							TypeVar("T")




class   __SCREAMING_SNAKE_CASE       (Generic[T]       ):


  """simple docstring"""


  def __init__(			self   ,	UpperCamelCase__	):






         """simple docstring"""


         a_						     =			data
         a_						     =			None







  def __str__(			self	):






         """simple docstring"""


         return f'{self.data}'





class   __SCREAMING_SNAKE_CASE       (Generic[T]       ):


  """simple docstring"""


  def __init__(			self	):






         """simple docstring"""


         a_						     =			None







  def __iter__(			self	):






         """simple docstring"""


         a_						     =			self.top
         while node:
                yield node.data
                a_						     =			node.next







  def __str__(			self	):






         """simple docstring"""


         return "->".join([str(UpperCamelCase__	) for item in self]	)







  def __len__(			self	):






         """simple docstring"""


         return len(tuple(iter(self	)	)	)







  def    _a       (			self	):






         """simple docstring"""


         return self.top is None







  def    _a       (			self   ,	UpperCamelCase__	):






         """simple docstring"""


         a_						     =			Node(UpperCamelCase__	)
         if not self.is_empty():
                a_						     =			self.top
         a_						     =			node







  def    _a       (			self	):






         """simple docstring"""


         if self.is_empty():
                raise IndexError('pop from empty stack'	)
         assert isinstance(self.top   ,	UpperCamelCase__	)
         a_						     =			self.top
         a_						     =			self.top.next
         return pop_node.data







  def    _a       (			self	):






         """simple docstring"""


         if self.is_empty():
                raise IndexError('peek from empty stack'	)

         assert self.top is not None
         return self.top.data







  def    _a       (			self	):






         """simple docstring"""


         a_						     =			None


if __name__ == "__main__":
  from doctest import testmod

  testmod()




