



'''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 __future__ import annotations






def  UpperCAmelCase_       (		lowercase__       ,	lowercase__       ):


     '''simple docstring'''







     print(F"""Vertex\tShortest Distance from vertex {src}"""       )
     for i, d in enumerate(lowercase__       ):
          print(F"""{i}\t\t{d}"""       )






def  UpperCAmelCase_       (		lowercase__       ,	lowercase__       ,	lowercase__       ):


     '''simple docstring'''







     for j in range(lowercase__       ):
          a_		,						a_		,						a_       		=(graph[j][k] for k in ["src", "dst", "weight"])
          if distance[u] != float("inf"       ) and distance[u] + w < distance[v]:
               return True
     return False






def  UpperCAmelCase_       (		lowercase__       ,	lowercase__       ,	lowercase__       ,	lowercase__       ):


     '''simple docstring'''







     a_       		=[float("inf"       )] * vertex_count
     a_       		=0.0

     for _ in range(vertex_count - 1       ):
          for j in range(lowercase__       ):
               a_		,						a_		,						a_       		=(graph[j][k] for k in ["src", "dst", "weight"])

               if distance[u] != float("inf"       ) and distance[u] + w < distance[v]:
                    a_       		=distance[u] + w

     a_       		=check_negative_cycle(lowercase__       ,	lowercase__       ,	lowercase__       )
     if negative_cycle_exists:
          raise Exception("Negative cycle found"       )

     return distance


if __name__ == "__main__":
  import doctest

  doctest.testmod()

  lowercase							       =			int(input('''Enter number of vertices: ''').strip())
  lowercase							       =			int(input('''Enter number of edges: ''').strip())

  lowercase							       =			[{} for _ in range(E)]

  for i in range(E):
    print('''Edge ''', i + 1)
    lowercase       ,      lowercase       ,      lowercase							       =			(
        int(x)
        for x in input('''Enter source, destination, weight: ''').strip().split(''' ''')
    )
    lowercase							       =			{'''src''': src, '''dst''': dest, '''weight''': weight}

  lowercase							       =			int(input('''\nEnter shortest path source:''').strip())
  lowercase							       =			bellman_ford(graph, V, E, source)
  print_distance(shortest_distance, 0)


