





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


    '''simple docstring'''







    def __init__(       self   ,				A_   ,				A_=13   ,				A_=7   ,				A_=True   ,				A_=True   ,				A_=True   ,				A_=True   ,				A_=99   ,				A_=32   ,				A_=5   ,				A_=4   ,				A_=37   ,				A_="gelu"   ,				A_=0.1   ,				A_=0.1   ,				A_=1_28   ,				A_=32   ,				A_=16   ,				A_=2   ,				A_=0.02   ,				A_=3   ,				A_=4   ,				A_=None   ,				):





        '''simple docstring'''

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



    def  lowercase_					(       self     ):





        '''simple docstring'''

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

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

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

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

        SCREAMING_SNAKE_CASE__											=			self.get_config()

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



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



    def  lowercase_					(       self     ):





        '''simple docstring'''

        (
            (
            SCREAMING_SNAKE_CASE__
        )				,		(
            SCREAMING_SNAKE_CASE__
        )				,		(
            SCREAMING_SNAKE_CASE__
        )				,		(
            SCREAMING_SNAKE_CASE__
        )				,		(
            SCREAMING_SNAKE_CASE__
        )				,		(
            SCREAMING_SNAKE_CASE__
        )				,		(
            SCREAMING_SNAKE_CASE__
        )				,		
        )											=			self.prepare_config_and_inputs()

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

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



    def  lowercase_					(       self   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			NezhaModel(config=A_     )
        model.to(A_     )
        model.eval()
        SCREAMING_SNAKE_CASE__											=			model(A_   ,				attention_mask=A_   ,				token_type_ids=A_     )
        SCREAMING_SNAKE_CASE__											=			model(A_   ,				token_type_ids=A_     )
        SCREAMING_SNAKE_CASE__											=			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  lowercase_					(       self   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			True
        SCREAMING_SNAKE_CASE__											=			NezhaModel(A_     )
        model.to(A_     )
        model.eval()
        SCREAMING_SNAKE_CASE__											=			model(
            A_   ,				attention_mask=A_   ,				token_type_ids=A_   ,				encoder_hidden_states=A_   ,				encoder_attention_mask=A_   ,				)
        SCREAMING_SNAKE_CASE__											=			model(
            A_   ,				attention_mask=A_   ,				token_type_ids=A_   ,				encoder_hidden_states=A_   ,				)
        SCREAMING_SNAKE_CASE__											=			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  lowercase_					(       self   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			NezhaForMaskedLM(config=A_     )
        model.to(A_     )
        model.eval()
        SCREAMING_SNAKE_CASE__											=			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  lowercase_					(       self   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_     ):





        '''simple docstring'''

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



    def  lowercase_					(       self   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			NezhaForPreTraining(config=A_     )
        model.to(A_     )
        model.eval()
        SCREAMING_SNAKE_CASE__											=			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  lowercase_					(       self   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			NezhaForQuestionAnswering(config=A_     )
        model.to(A_     )
        model.eval()
        SCREAMING_SNAKE_CASE__											=			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  lowercase_					(       self   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_     ):





        '''simple docstring'''

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



    def  lowercase_					(       self   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.num_labels
        SCREAMING_SNAKE_CASE__											=			NezhaForTokenClassification(config=A_     )
        model.to(A_     )
        model.eval()
        SCREAMING_SNAKE_CASE__											=			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  lowercase_					(       self   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_     ):





        '''simple docstring'''

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




    def  lowercase_					(       self     ):





        '''simple docstring'''

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





@require_torch
class 					__snake_case	(  __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     unittest.TestCase    ):


    '''simple docstring'''







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



    def  lowercase_					(       self   ,				A_   ,				A_   ,				A_=False     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			super()._prepare_for_class(A_   ,				A_   ,				return_labels=A_     )

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



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			NezhaModelTester(self     )
        SCREAMING_SNAKE_CASE__											=			ConfigTester(self   ,				config_class=A_   ,				hidden_size=37     )



    def  lowercase_					(       self     ):





        '''simple docstring'''

        self.config_tester.run_common_tests()



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*A_     )



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.model_tester.prepare_config_and_inputs_for_decoder()
        self.model_tester.create_and_check_model_as_decoder(*A_     )



    def  lowercase_					(       self     ):





        '''simple docstring'''

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

        SCREAMING_SNAKE_CASE__											=			None

        self.model_tester.create_and_check_model_as_decoder(
            A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				)



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_masked_lm(*A_     )



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_multiple_choice(*A_     )



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_next_sequence_prediction(*A_     )



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_pretraining(*A_     )



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_question_answering(*A_     )



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_sequence_classification(*A_     )



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_token_classification(*A_     )



    @slow
    def  lowercase_					(       self     ):





        '''simple docstring'''

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




    @slow
    @require_torch_gpu
    def  lowercase_					(       self     ):





        '''simple docstring'''

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

            SCREAMING_SNAKE_CASE__											=			True
            SCREAMING_SNAKE_CASE__											=			model_class(config=A_     )

            SCREAMING_SNAKE_CASE__											=			self._prepare_for_class(A_   ,				A_     )
            SCREAMING_SNAKE_CASE__											=			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'''     )     )
                SCREAMING_SNAKE_CASE__											=			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 					__snake_case	(  unittest.TestCase    ):


    '''simple docstring'''







    @slow
    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			NezhaModel.from_pretrained('''sijunhe/nezha-cn-base'''     )
        SCREAMING_SNAKE_CASE__											=			torch.tensor([[0, 1, 2, 3, 4, 5]]     )
        SCREAMING_SNAKE_CASE__											=			torch.tensor([[0, 1, 1, 1, 1, 1]]     )
        with torch.no_grad():
            SCREAMING_SNAKE_CASE__											=			model(A_   ,				attention_mask=A_     )[0]
        SCREAMING_SNAKE_CASE__											=			torch.Size((1, 6, 7_68)     )
        self.assertEqual(output.shape   ,				A_     )
        SCREAMING_SNAKE_CASE__											=			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]   ,				A_   ,				atol=1E-4     )     )




    @slow
    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			NezhaForMaskedLM.from_pretrained('''sijunhe/nezha-cn-base'''     )
        SCREAMING_SNAKE_CASE__											=			torch.tensor([[0, 1, 2, 3, 4, 5]]     )
        SCREAMING_SNAKE_CASE__											=			torch.tensor([[1, 1, 1, 1, 1, 1]]     )
        with torch.no_grad():
            SCREAMING_SNAKE_CASE__											=			model(A_   ,				attention_mask=A_     )[0]
        SCREAMING_SNAKE_CASE__											=			torch.Size((1, 6, 2_11_28)     )
        self.assertEqual(output.shape   ,				A_     )
        SCREAMING_SNAKE_CASE__											=			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]   ,				A_   ,				atol=1E-4     )     )







import qiskit





def  __magic_name__  (				lowercase				,       lowercase				)				-> qiskit.result.counts.Counts:

							"""simple docstring"""



							lowercase_	:   Dict  				=     qiskit.Aer.get_backend("""aer_simulator"""				)

							# Create a Quantum Circuit acting on the q register
							lowercase_	:   str  				=     qiskit.QuantumCircuit(lowercase				,       lowercase				)

							# Map the quantum measurement to the classical bits
							circuit.measure([0]				,       [0]				)

							# Execute the circuit on the simulator
							lowercase_	:   List[Any]  				=     qiskit.execute(lowercase				,       lowercase				,       shots=1000				)

							# Return the histogram data of the results of the experiment.
							return job.result().get_counts(lowercase				)


if __name__ == "__main__":
							print(F'''Total count for various states are: {single_qubit_measure(1, 1)}''')