


'''simple docstring'''

from __future__ import annotations

import unittest

from transformers import RoFormerConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
     import tensorflow as tf

     from transformers import (
         TFRoFormerForCausalLM,
         TFRoFormerForMaskedLM,
         TFRoFormerForMultipleChoice,
         TFRoFormerForQuestionAnswering,
         TFRoFormerForSequenceClassification,
         TFRoFormerForTokenClassification,
         TFRoFormerModel,
     )
     from transformers.models.roformer.modeling_tf_roformer import (
         TFRoFormerSelfAttention,
         TFRoFormerSinusoidalPositionalEmbedding,
     )





class 	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=2     ,    UpperCamelCase=4     ,    UpperCamelCase=37     ,    UpperCamelCase="gelu"     ,    UpperCamelCase=0.1     ,    UpperCamelCase=0.1     ,    UpperCamelCase=512     ,    UpperCamelCase=16     ,    UpperCamelCase=2     ,    UpperCamelCase=0.02     ,    UpperCamelCase=3     ,    UpperCamelCase=4     ,    UpperCamelCase=None     ,    ):







   """simple docstring"""
   lowerCamelCase_						=    parent
   lowerCamelCase_						=    13
   lowerCamelCase_						=    7
   lowerCamelCase_						=    True
   lowerCamelCase_						=    True
   lowerCamelCase_						=    True
   lowerCamelCase_						=    True
   lowerCamelCase_						=    99
   lowerCamelCase_						=    32
   lowerCamelCase_						=    2
   lowerCamelCase_						=    4
   lowerCamelCase_						=    37
   lowerCamelCase_						=    "gelu"
   lowerCamelCase_						=    0.1
   lowerCamelCase_						=    0.1
   lowerCamelCase_						=    512
   lowerCamelCase_						=    16
   lowerCamelCase_						=    2
   lowerCamelCase_						=    0.02
   lowerCamelCase_						=    3
   lowerCamelCase_						=    4
   lowerCamelCase_						=    None






  def     snake_case						(       self	):







   """simple docstring"""
   lowerCamelCase_						=    ids_tensor([self.batch_size, self.seq_length]     ,    self.vocab_size	)

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

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

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

   lowerCamelCase_						=    RoFormerConfig(
       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     ,    initializer_range=self.initializer_range     ,    return_dict=_UpperCamelCase     ,    )

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






  def     snake_case						(       self     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase	):







   """simple docstring"""
   lowerCamelCase_						=    TFRoFormerModel(config=_UpperCamelCase	)
   lowerCamelCase_						=    {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}

   lowerCamelCase_						=    [input_ids, input_mask]
   lowerCamelCase_						=    model(_UpperCamelCase	)

   lowerCamelCase_						=    model(_UpperCamelCase	)

   self.parent.assertEqual(result.last_hidden_state.shape     ,    (self.batch_size, self.seq_length, self.hidden_size)	)






  def     snake_case						(       self     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase	):







   """simple docstring"""
   lowerCamelCase_						=    True
   lowerCamelCase_						=    TFRoFormerForCausalLM(config=_UpperCamelCase	)
   lowerCamelCase_						=    {
       "input_ids": input_ids,
       "attention_mask": input_mask,
       "token_type_ids": token_type_ids,
   }
   lowerCamelCase_						=    model(_UpperCamelCase	)["logits"]
   self.parent.assertListEqual(
       list(prediction_scores.numpy().shape	)     ,    [self.batch_size, self.seq_length, self.vocab_size]	)






  def     snake_case						(       self     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase	):







   """simple docstring"""
   lowerCamelCase_						=    TFRoFormerForMaskedLM(config=_UpperCamelCase	)
   lowerCamelCase_						=    {
       "input_ids": input_ids,
       "attention_mask": input_mask,
       "token_type_ids": token_type_ids,
   }
   lowerCamelCase_						=    model(_UpperCamelCase	)
   self.parent.assertEqual(result.logits.shape     ,    (self.batch_size, self.seq_length, self.vocab_size)	)






  def     snake_case						(       self     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase	):







   """simple docstring"""
   lowerCamelCase_						=    self.num_labels
   lowerCamelCase_						=    TFRoFormerForSequenceClassification(config=_UpperCamelCase	)
   lowerCamelCase_						=    {
       "input_ids": input_ids,
       "attention_mask": input_mask,
       "token_type_ids": token_type_ids,
   }

   lowerCamelCase_						=    model(_UpperCamelCase	)
   self.parent.assertEqual(result.logits.shape     ,    (self.batch_size, self.num_labels)	)






  def     snake_case						(       self     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase	):







   """simple docstring"""
   lowerCamelCase_						=    self.num_choices
   lowerCamelCase_						=    TFRoFormerForMultipleChoice(config=_UpperCamelCase	)
   lowerCamelCase_						=    tf.tile(tf.expand_dims(_UpperCamelCase     ,    1	)     ,    (1, self.num_choices, 1)	)
   lowerCamelCase_						=    tf.tile(tf.expand_dims(_UpperCamelCase     ,    1	)     ,    (1, self.num_choices, 1)	)
   lowerCamelCase_						=    tf.tile(tf.expand_dims(_UpperCamelCase     ,    1	)     ,    (1, self.num_choices, 1)	)
   lowerCamelCase_						=    {
       "input_ids": multiple_choice_inputs_ids,
       "attention_mask": multiple_choice_input_mask,
       "token_type_ids": multiple_choice_token_type_ids,
   }
   lowerCamelCase_						=    model(_UpperCamelCase	)
   self.parent.assertEqual(result.logits.shape     ,    (self.batch_size, self.num_choices)	)






  def     snake_case						(       self     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase	):







   """simple docstring"""
   lowerCamelCase_						=    self.num_labels
   lowerCamelCase_						=    TFRoFormerForTokenClassification(config=_UpperCamelCase	)
   lowerCamelCase_						=    {
       "input_ids": input_ids,
       "attention_mask": input_mask,
       "token_type_ids": token_type_ids,
   }
   lowerCamelCase_						=    model(_UpperCamelCase	)
   self.parent.assertEqual(result.logits.shape     ,    (self.batch_size, self.seq_length, self.num_labels)	)






  def     snake_case						(       self     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase	):







   """simple docstring"""
   lowerCamelCase_						=    TFRoFormerForQuestionAnswering(config=_UpperCamelCase	)
   lowerCamelCase_						=    {
       "input_ids": input_ids,
       "attention_mask": input_mask,
       "token_type_ids": token_type_ids,
   }

   lowerCamelCase_						=    model(_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     snake_case						(       self	):







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





@require_tf
class 	snake_case       (       snake_case__     ,		snake_case__     ,		unittest.TestCase     ):





  """simple docstring"""




  _lowerCamelCase						       =    (
      (
          TFRoFormerModel,
          TFRoFormerForCausalLM,
          TFRoFormerForMaskedLM,
          TFRoFormerForQuestionAnswering,
          TFRoFormerForSequenceClassification,
          TFRoFormerForTokenClassification,
          TFRoFormerForMultipleChoice,
      )
      if is_tf_available()
      else ()
  )
  _lowerCamelCase						       =    (
      {
          "feature-extraction": TFRoFormerModel,
          "fill-mask": TFRoFormerForMaskedLM,
          "question-answering": TFRoFormerForQuestionAnswering,
          "text-classification": TFRoFormerForSequenceClassification,
          "text-generation": TFRoFormerForCausalLM,
          "token-classification": TFRoFormerForTokenClassification,
          "zero-shot": TFRoFormerForSequenceClassification,
      }
      if is_tf_available()
      else {}
  )

  _lowerCamelCase						       =    False
  _lowerCamelCase						       =    False






  def     snake_case						(       self     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase	):







   """simple docstring"""


   if pipeline_test_casse_name == "TextGenerationPipelineTests":
    return True

   return False






  def     snake_case						(       self	):







   """simple docstring"""
   lowerCamelCase_						=    TFRoFormerModelTester(self	)
   lowerCamelCase_						=    ConfigTester(self     ,    config_class=_UpperCamelCase     ,    hidden_size=37	)






  def     snake_case						(       self	):







   """simple docstring"""
   self.config_tester.run_common_tests()






  def     snake_case						(       self	):







   """simple docstring"""
   lowerCamelCase_						=    self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_model(*_UpperCamelCase	)






  def     snake_case						(       self	):







   """simple docstring"""
   lowerCamelCase_						=    self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_masked_lm(*_UpperCamelCase	)






  def     snake_case						(       self	):







   """simple docstring"""
   lowerCamelCase_						=    self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_lm_head(*_UpperCamelCase	)






  def     snake_case						(       self	):







   """simple docstring"""
   lowerCamelCase_						=    self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_multiple_choice(*_UpperCamelCase	)






  def     snake_case						(       self	):







   """simple docstring"""
   lowerCamelCase_						=    self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_question_answering(*_UpperCamelCase	)






  def     snake_case						(       self	):







   """simple docstring"""
   lowerCamelCase_						=    self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_sequence_classification(*_UpperCamelCase	)






  def     snake_case						(       self	):







   """simple docstring"""
   lowerCamelCase_						=    self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_token_classification(*_UpperCamelCase	)







  @slow
  def     snake_case						(       self	):







   """simple docstring"""
   lowerCamelCase_						=    TFRoFormerModel.from_pretrained("junnyu/roformer_chinese_base"	)
   self.assertIsNotNone(_UpperCamelCase	)





@require_tf
class 	snake_case       (       unittest.TestCase     ):





  """simple docstring"""




  @slow
  def     snake_case						(       self	):







   """simple docstring"""
   lowerCamelCase_						=    TFRoFormerForMaskedLM.from_pretrained("junnyu/roformer_chinese_base"	)
   lowerCamelCase_						=    tf.constant([[0, 1, 2, 3, 4, 5]]	)
   lowerCamelCase_						=    model(_UpperCamelCase	)[0]

   # TODO Replace vocab size
   lowerCamelCase_						=    5_0000

   lowerCamelCase_						=    [1, 6, vocab_size]
   self.assertEqual(output.shape     ,    _UpperCamelCase	)

   print(output[:, :3, :3]	)

   # TODO Replace values below with what was printed above.
   lowerCamelCase_						=    tf.constant(
       [
           [
               [-0.12_053_341, -1.0_264_901, 0.29_221_946],
               [-1.5_133_783, 0.197_433, 0.15_190_607],
               [-5.0_135_403, -3.900_256, -0.84_038_764],
           ]
       ]	)
   tf.debugging.assert_near(output[:, :3, :3]     ,    _UpperCamelCase     ,    atol=1e-4	)





@require_tf
class 	snake_case       (       unittest.TestCase     ):





  """simple docstring"""




  _lowerCamelCase						       =    1e-4






  def     snake_case						(       self	):







   """simple docstring"""
   lowerCamelCase_						=    tf.constant([[4, 10]]	)
   lowerCamelCase_						=    TFRoFormerSinusoidalPositionalEmbedding(num_positions=6     ,    embedding_dim=6	)

   lowerCamelCase_						=    emba(input_ids.shape	)
   lowerCamelCase_						=    tf.constant(
       [[0.0_000, 0.0_000, 0.0_000, 1.0_000, 1.0_000, 1.0_000], [0.8_415, 0.0_464, 0.0_022, 0.5_403, 0.9_989, 1.0_000]]	)

   tf.debugging.assert_near(_UpperCamelCase     ,    _UpperCamelCase     ,    atol=self.tolerance	)







  def     snake_case						(       self	):







   """simple docstring"""
   lowerCamelCase_						=    tf.constant(
       [
           [0.0_000, 0.0_000, 0.0_000, 0.0_000, 0.0_000],
           [0.8_415, 0.8_219, 0.8_020, 0.7_819, 0.7_617],
           [0.9_093, 0.9_364, 0.9_581, 0.9_749, 0.9_870],
       ]	)
   lowerCamelCase_						=    TFRoFormerSinusoidalPositionalEmbedding(num_positions=512     ,    embedding_dim=512	)
   emba([2, 16, 512]	)
   lowerCamelCase_						=    emba.weight[:3, :5]

   tf.debugging.assert_near(_UpperCamelCase     ,    _UpperCamelCase     ,    atol=self.tolerance	)





@require_tf
class 	snake_case       (       unittest.TestCase     ):





  """simple docstring"""




  _lowerCamelCase						       =    1e-4






  def     snake_case						(       self	):







   """simple docstring"""
   lowerCamelCase_						=    tf.reshape(tf.range(2 * 12 * 16 * 64     ,    dtype=tf.floataa	)     ,    shape=(2, 12, 16, 64)	) / 100

   lowerCamelCase_						=    -tf.reshape(tf.range(2 * 12 * 16 * 64     ,    dtype=tf.floataa	)     ,    shape=(2, 12, 16, 64)	) / 100

   lowerCamelCase_						=    TFRoFormerSinusoidalPositionalEmbedding(num_positions=32     ,    embedding_dim=64	)
   lowerCamelCase_						=    embed_positions([2, 16, 768]	)[None, None, :, :]

   lowerCamelCase_					,lowerCamelCase_						=    TFRoFormerSelfAttention.apply_rotary_position_embeddings(
       _UpperCamelCase     ,    _UpperCamelCase     ,    _UpperCamelCase	)

   lowerCamelCase_						=    tf.constant(
       [
           [0.0_000, 0.0_100, 0.0_200, 0.0_300, 0.0_400, 0.0_500, 0.0_600, 0.0_700],
           [-0.2_012, 0.8_897, 0.0_263, 0.9_401, 0.2_074, 0.9_463, 0.3_481, 0.9_343],
           [-1.7_057, 0.6_271, -1.2_145, 1.3_897, -0.6_303, 1.7_647, -0.1_173, 1.8_985],
           [-2.1_731, -1.6_397, -2.7_358, 0.2_854, -2.1_840, 1.7_183, -1.3_018, 2.4_871],
           [0.2_717, -3.6_173, -2.9_206, -2.1_988, -3.6_638, 0.3_858, -2.9_155, 2.2_980],
           [3.9_859, -2.1_580, -0.7_984, -4.4_904, -4.1_181, -2.0_252, -4.4_782, 1.1_253],
       ]	)
   lowerCamelCase_						=    tf.constant(
       [
           [0.0_000, -0.0_100, -0.0_200, -0.0_300, -0.0_400, -0.0_500, -0.0_600, -0.0_700],
           [0.2_012, -0.8_897, -0.0_263, -0.9_401, -0.2_074, -0.9_463, -0.3_481, -0.9_343],
           [1.7_057, -0.6_271, 1.2_145, -1.3_897, 0.6_303, -1.7_647, 0.1_173, -1.8_985],
           [2.1_731, 1.6_397, 2.7_358, -0.2_854, 2.1_840, -1.7_183, 1.3_018, -2.4_871],
           [-0.2_717, 3.6_173, 2.9_206, 2.1_988, 3.6_638, -0.3_858, 2.9_155, -2.2_980],
           [-3.9_859, 2.1_580, 0.7_984, 4.4_904, 4.1_181, 2.0_252, 4.4_782, -1.1_253],
       ]	)

   tf.debugging.assert_near(query_layer[0, 0, :6, :8]     ,    _UpperCamelCase     ,    atol=self.tolerance	)
   tf.debugging.assert_near(key_layer[0, 0, :6, :8]     ,    _UpperCamelCase     ,    atol=self.tolerance	)






from __future__ import annotations







def 						lowerCamelCase__      ( __A    :list[float]	,__A    :Union[str, Any]		):


       """simple docstring"""




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







def 						lowerCamelCase__      ( __A    :list[dict[str, int]]	,__A    :list[float]	,__A    :int		):


       """simple docstring"""




       for j in range(__A		):
              __snake_case	,    __snake_case	,    __snake_case       	=							(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 						lowerCamelCase__      ( __A    :list[dict[str, int]]	,__A    :int	,__A    :int	,__A    :int		):


       """simple docstring"""




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

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

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

       __snake_case       	=							check_negative_cycle(__A	,__A	,__A		)
       if negative_cycle_exists:
              raise Exception("""Negative cycle found"""		)

       return distance


if __name__ == "__main__":
    import doctest

    doctest.testmod()

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

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

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

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

