"""simple docstring"""






import os
import tempfile
import unittest

from transformers import NezhaConfig, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_torch_gpu, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
       import torch

       from transformers import (
           MODEL_FOR_PRETRAINING_MAPPING,
           NezhaForMaskedLM,
           NezhaForMultipleChoice,
           NezhaForNextSentencePrediction,
           NezhaForPreTraining,
           NezhaForQuestionAnswering,
           NezhaForSequenceClassification,
           NezhaForTokenClassification,
           NezhaModel,
       )
       from transformers.models.nezha.modeling_nezha import NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST





class 					_A		:

      def __init__(		self						,			__lowerCAmelCase						,			__lowerCAmelCase=13						,			__lowerCAmelCase=7						,			__lowerCAmelCase=True						,			__lowerCAmelCase=True						,			__lowerCAmelCase=True						,			__lowerCAmelCase=True						,			__lowerCAmelCase=99						,			__lowerCAmelCase=32						,			__lowerCAmelCase=5						,			__lowerCAmelCase=4						,			__lowerCAmelCase=37						,			__lowerCAmelCase="gelu"						,			__lowerCAmelCase=0.1						,			__lowerCAmelCase=0.1						,			__lowerCAmelCase=128						,			__lowerCAmelCase=32						,			__lowerCAmelCase=16						,			__lowerCAmelCase=2						,			__lowerCAmelCase=0.0_2						,			__lowerCAmelCase=3						,			__lowerCAmelCase=4						,			__lowerCAmelCase=None						,			):







            """simple docstring"""



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

      def 							A__			(		self		):







            """simple docstring"""



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

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

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

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

            lowercase								=      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=__lowerCAmelCase						,			initializer_range=self.initializer_range						,			)

      def 							A__			(		self		):







            """simple docstring"""



            (
                (
                lowercase
            )				,				(
                lowercase
            )				,				(
                lowercase
            )				,				(
                lowercase
            )				,				(
                lowercase
            )				,				(
                lowercase
            )				,				(
                lowercase
            )				,				
            )								=      self.prepare_config_and_inputs()

            lowercase								=      True
            lowercase								=      floats_tensor([self.batch_size, self.seq_length, self.hidden_size]		)
            lowercase								=      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						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase		):







            """simple docstring"""



            lowercase								=      NezhaModel(config=__lowerCAmelCase		)
            model.to(__lowerCAmelCase		)
            model.eval()
            lowercase								=      model(__lowerCAmelCase						,			attention_mask=__lowerCAmelCase						,			token_type_ids=__lowerCAmelCase		)
            lowercase								=      model(__lowerCAmelCase						,			token_type_ids=__lowerCAmelCase		)
            lowercase								=      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 							A__			(		self						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			):







            """simple docstring"""



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







            """simple docstring"""



            lowercase								=      NezhaForMaskedLM(config=__lowerCAmelCase		)
            model.to(__lowerCAmelCase		)
            model.eval()
            lowercase								=      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 							A__			(		self						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase		):







            """simple docstring"""



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

      def 							A__			(		self						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase		):







            """simple docstring"""



            lowercase								=      NezhaForPreTraining(config=__lowerCAmelCase		)
            model.to(__lowerCAmelCase		)
            model.eval()
            lowercase								=      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 							A__			(		self						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase		):







            """simple docstring"""



            lowercase								=      NezhaForQuestionAnswering(config=__lowerCAmelCase		)
            model.to(__lowerCAmelCase		)
            model.eval()
            lowercase								=      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 							A__			(		self						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase		):







            """simple docstring"""



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

      def 							A__			(		self						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase		):







            """simple docstring"""



            lowercase								=      self.num_labels
            lowercase								=      NezhaForTokenClassification(config=__lowerCAmelCase		)
            model.to(__lowerCAmelCase		)
            model.eval()
            lowercase								=      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 							A__			(		self						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase		):







            """simple docstring"""



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







      def 							A__			(		self		):







            """simple docstring"""



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






@require_torch
class 					_A		(			lowerCAmelCase    ,       lowerCAmelCase    ,       lowerCAmelCase    ,       unittest.TestCase      ):
      snake_case__     :  Union[str, Any]				    =      (
          (
              NezhaModel,
              NezhaForMaskedLM,
              NezhaForMultipleChoice,
              NezhaForNextSentencePrediction,
              NezhaForPreTraining,
              NezhaForQuestionAnswering,
              NezhaForSequenceClassification,
              NezhaForTokenClassification,
          )
          if is_torch_available()
          else ()
      )
      snake_case__     :  Any				    =      (
          {
              'feature-extraction': NezhaModel,
              'fill-mask': NezhaForMaskedLM,
              'question-answering': NezhaForQuestionAnswering,
              'text-classification': NezhaForSequenceClassification,
              'token-classification': NezhaForTokenClassification,
              'zero-shot': NezhaForSequenceClassification,
          }
          if is_torch_available()
          else {}
      )
      snake_case__     :  int				    =      True

      def 							A__			(		self						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase=False		):







            """simple docstring"""



            lowercase								=      super()._prepare_for_class(__lowerCAmelCase						,			__lowerCAmelCase						,			return_labels=__lowerCAmelCase		)

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

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      NezhaModelTester(self		)
            lowercase								=      ConfigTester(self						,			config_class=__lowerCAmelCase						,			hidden_size=37		)

      def 							A__			(		self		):







            """simple docstring"""



            self.config_tester.run_common_tests()

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*__lowerCAmelCase		)

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      self.model_tester.prepare_config_and_inputs_for_decoder()
            self.model_tester.create_and_check_model_as_decoder(*__lowerCAmelCase		)

      def 							A__			(		self		):







            """simple docstring"""



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

            lowercase								=      None

            self.model_tester.create_and_check_model_as_decoder(
                __lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			)

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_masked_lm(*__lowerCAmelCase		)

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_multiple_choice(*__lowerCAmelCase		)

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_next_sequence_prediction(*__lowerCAmelCase		)

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_pretraining(*__lowerCAmelCase		)

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_question_answering(*__lowerCAmelCase		)

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_sequence_classification(*__lowerCAmelCase		)

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_token_classification(*__lowerCAmelCase		)

      @slow
      def 							A__			(		self		):







            """simple docstring"""



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







      @slow
      @require_torch_gpu
      def 							A__			(		self		):







            """simple docstring"""



            lowercase				,				lowercase								=      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

                  lowercase								=      True
                  lowercase								=      model_class(config=__lowerCAmelCase		)

                  lowercase								=      self._prepare_for_class(__lowerCAmelCase						,			__lowerCAmelCase		)
                  lowercase								=      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"""		)		)
                        lowercase								=      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 					_A		(			unittest.TestCase      ):

      @slow
      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      NezhaModel.from_pretrained("""sijunhe/nezha-cn-base"""		)
            lowercase								=      torch.tensor([[0, 1, 2, 3, 4, 5]]		)
            lowercase								=      torch.tensor([[0, 1, 1, 1, 1, 1]]		)
            with torch.no_grad():
                  lowercase								=      model(__lowerCAmelCase						,			attention_mask=__lowerCAmelCase		)[0]
            lowercase								=      torch.Size((1, 6, 768)		)
            self.assertEqual(output.shape						,			__lowerCAmelCase		)
            lowercase								=      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 							A__			(		self		):







            """simple docstring"""



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






def      UpperCAmelCase__			(							lowerCAmelCase__	:int = 5_0						)					->       int:
      '''simple docstring'''


      lowercase								=      [1] * (length + 1)

      for row_length in range(3   ,						length + 1						):
            for block_length in range(3   ,						row_length + 1						):
                  for block_start in range(row_length - block_length						):
                        ways_number[row_length] += ways_number[
                            row_length - block_start - block_length - 1
                        ]

                  ways_number[row_length] += 1

      return ways_number[length]


if __name__ == "__main__":
       print(F"""{solution() = }""")



