

'''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 :
   def __init__( self			:      Union[str, Any]     ,SCREAMING_SNAKE_CASE__			:      Optional[Any]     ,SCREAMING_SNAKE_CASE__			:      Optional[Any]=13     ,SCREAMING_SNAKE_CASE__			:      List[str]=7     ,SCREAMING_SNAKE_CASE__			:      int=True     ,SCREAMING_SNAKE_CASE__			:      Union[str, Any]=True     ,SCREAMING_SNAKE_CASE__			:      str=True     ,SCREAMING_SNAKE_CASE__			:      Dict=True     ,SCREAMING_SNAKE_CASE__			:      List[Any]=99     ,SCREAMING_SNAKE_CASE__			:      int=32     ,SCREAMING_SNAKE_CASE__			:      Optional[Any]=2     ,SCREAMING_SNAKE_CASE__			:      Optional[int]=4     ,SCREAMING_SNAKE_CASE__			:      List[str]=37     ,SCREAMING_SNAKE_CASE__			:      List[Any]="gelu"     ,SCREAMING_SNAKE_CASE__			:      List[str]=0.1     ,SCREAMING_SNAKE_CASE__			:      Union[str, Any]=0.1     ,SCREAMING_SNAKE_CASE__			:      int=512     ,SCREAMING_SNAKE_CASE__			:      Tuple=16     ,SCREAMING_SNAKE_CASE__			:      Union[str, Any]=2     ,SCREAMING_SNAKE_CASE__			:      Union[str, Any]=0.02     ,SCREAMING_SNAKE_CASE__			:      List[Any]=3     ,SCREAMING_SNAKE_CASE__			:      List[str]=4     ,SCREAMING_SNAKE_CASE__			:      Tuple=None     ,):
     SCREAMING_SNAKE_CASE:List[str]						      =					parent
     SCREAMING_SNAKE_CASE:Optional[int]						      =					13
     SCREAMING_SNAKE_CASE:Union[str, Any]						      =					7
     SCREAMING_SNAKE_CASE:List[Any]						      =					True
     SCREAMING_SNAKE_CASE:List[Any]						      =					True
     SCREAMING_SNAKE_CASE:List[Any]						      =					True
     SCREAMING_SNAKE_CASE:Union[str, Any]						      =					True
     SCREAMING_SNAKE_CASE:List[str]						      =					99
     SCREAMING_SNAKE_CASE:Dict						      =					32
     SCREAMING_SNAKE_CASE:Union[str, Any]						      =					2
     SCREAMING_SNAKE_CASE:Dict						      =					4
     SCREAMING_SNAKE_CASE:int						      =					37
     SCREAMING_SNAKE_CASE:List[Any]						      =					"gelu"
     SCREAMING_SNAKE_CASE:List[str]						      =					0.1
     SCREAMING_SNAKE_CASE:List[str]						      =					0.1
     SCREAMING_SNAKE_CASE:str						      =					512
     SCREAMING_SNAKE_CASE:Optional[Any]						      =					16
     SCREAMING_SNAKE_CASE:str						      =					2
     SCREAMING_SNAKE_CASE:Dict						      =					0.02
     SCREAMING_SNAKE_CASE:Optional[Any]						      =					3
     SCREAMING_SNAKE_CASE:Optional[int]						      =					4
     SCREAMING_SNAKE_CASE:int						      =					None
   def     __UpperCamelCase						( self			:      List[Any]							):
     SCREAMING_SNAKE_CASE:str						      =					ids_tensor([self.batch_size, self.seq_length]     ,self.vocab_size							)

     SCREAMING_SNAKE_CASE:List[str]						      =					None
     if self.use_input_mask:
       SCREAMING_SNAKE_CASE:Tuple						      =					random_attention_mask([self.batch_size, self.seq_length]							)

     SCREAMING_SNAKE_CASE:Union[str, Any]						      =					None
     if self.use_token_type_ids:
       SCREAMING_SNAKE_CASE:Optional[int]						      =					ids_tensor([self.batch_size, self.seq_length]     ,self.type_vocab_size							)

     SCREAMING_SNAKE_CASE:int						      =					None
     SCREAMING_SNAKE_CASE:str						      =					None
     SCREAMING_SNAKE_CASE:Dict						      =					None
     if self.use_labels:
       SCREAMING_SNAKE_CASE:Dict						      =					ids_tensor([self.batch_size]     ,self.type_sequence_label_size							)
       SCREAMING_SNAKE_CASE:Tuple						      =					ids_tensor([self.batch_size, self.seq_length]     ,self.num_labels							)
       SCREAMING_SNAKE_CASE:int						      =					ids_tensor([self.batch_size]     ,self.num_choices							)

     SCREAMING_SNAKE_CASE:Union[str, Any]						      =					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=SCREAMING_SNAKE_CASE__     ,)

     return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
   def     __UpperCamelCase						( self			:      List[str]     ,SCREAMING_SNAKE_CASE__			:      Tuple     ,SCREAMING_SNAKE_CASE__			:      Dict     ,SCREAMING_SNAKE_CASE__			:      str     ,SCREAMING_SNAKE_CASE__			:      List[Any]     ,SCREAMING_SNAKE_CASE__			:      str     ,SCREAMING_SNAKE_CASE__			:      Any     ,SCREAMING_SNAKE_CASE__			:      List[Any]							):
     SCREAMING_SNAKE_CASE:List[str]						      =					TFRoFormerModel(config=SCREAMING_SNAKE_CASE__							)
     SCREAMING_SNAKE_CASE:int						      =					{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}

     SCREAMING_SNAKE_CASE:Union[str, Any]						      =					[input_ids, input_mask]
     SCREAMING_SNAKE_CASE:str						      =					model(SCREAMING_SNAKE_CASE__							)

     SCREAMING_SNAKE_CASE:Tuple						      =					model(SCREAMING_SNAKE_CASE__							)

     self.parent.assertEqual(result.last_hidden_state.shape     ,(self.batch_size, self.seq_length, self.hidden_size)							)
   def     __UpperCamelCase						( self			:      List[str]     ,SCREAMING_SNAKE_CASE__			:      Optional[int]     ,SCREAMING_SNAKE_CASE__			:      Optional[Any]     ,SCREAMING_SNAKE_CASE__			:      Optional[int]     ,SCREAMING_SNAKE_CASE__			:      Union[str, Any]     ,SCREAMING_SNAKE_CASE__			:      Dict     ,SCREAMING_SNAKE_CASE__			:      Any     ,SCREAMING_SNAKE_CASE__			:      Optional[int]							):
     SCREAMING_SNAKE_CASE:Any						      =					True
     SCREAMING_SNAKE_CASE:Union[str, Any]						      =					TFRoFormerForCausalLM(config=SCREAMING_SNAKE_CASE__							)
     SCREAMING_SNAKE_CASE:Optional[Any]						      =					{
         "input_ids": input_ids,
         "attention_mask": input_mask,
         "token_type_ids": token_type_ids,
     }
     SCREAMING_SNAKE_CASE:Union[str, Any]						      =					model(SCREAMING_SNAKE_CASE__							)["logits"]
     self.parent.assertListEqual(
         list(prediction_scores.numpy().shape							)     ,[self.batch_size, self.seq_length, self.vocab_size]							)
   def     __UpperCamelCase						( self			:      Optional[int]     ,SCREAMING_SNAKE_CASE__			:      Union[str, Any]     ,SCREAMING_SNAKE_CASE__			:      int     ,SCREAMING_SNAKE_CASE__			:      List[str]     ,SCREAMING_SNAKE_CASE__			:      Dict     ,SCREAMING_SNAKE_CASE__			:      List[str]     ,SCREAMING_SNAKE_CASE__			:      List[str]     ,SCREAMING_SNAKE_CASE__			:      List[Any]							):
     SCREAMING_SNAKE_CASE:int						      =					TFRoFormerForMaskedLM(config=SCREAMING_SNAKE_CASE__							)
     SCREAMING_SNAKE_CASE:Dict						      =					{
         "input_ids": input_ids,
         "attention_mask": input_mask,
         "token_type_ids": token_type_ids,
     }
     SCREAMING_SNAKE_CASE:Optional[int]						      =					model(SCREAMING_SNAKE_CASE__							)
     self.parent.assertEqual(result.logits.shape     ,(self.batch_size, self.seq_length, self.vocab_size)							)
   def     __UpperCamelCase						( self			:      Dict     ,SCREAMING_SNAKE_CASE__			:      str     ,SCREAMING_SNAKE_CASE__			:      Optional[Any]     ,SCREAMING_SNAKE_CASE__			:      str     ,SCREAMING_SNAKE_CASE__			:      str     ,SCREAMING_SNAKE_CASE__			:      Union[str, Any]     ,SCREAMING_SNAKE_CASE__			:      List[Any]     ,SCREAMING_SNAKE_CASE__			:      str							):
     SCREAMING_SNAKE_CASE:Optional[Any]						      =					self.num_labels
     SCREAMING_SNAKE_CASE:int						      =					TFRoFormerForSequenceClassification(config=SCREAMING_SNAKE_CASE__							)
     SCREAMING_SNAKE_CASE:Optional[Any]						      =					{
         "input_ids": input_ids,
         "attention_mask": input_mask,
         "token_type_ids": token_type_ids,
     }

     SCREAMING_SNAKE_CASE:int						      =					model(SCREAMING_SNAKE_CASE__							)
     self.parent.assertEqual(result.logits.shape     ,(self.batch_size, self.num_labels)							)
   def     __UpperCamelCase						( self			:      Optional[Any]     ,SCREAMING_SNAKE_CASE__			:      str     ,SCREAMING_SNAKE_CASE__			:      Optional[int]     ,SCREAMING_SNAKE_CASE__			:      str     ,SCREAMING_SNAKE_CASE__			:      Tuple     ,SCREAMING_SNAKE_CASE__			:      Optional[int]     ,SCREAMING_SNAKE_CASE__			:      int     ,SCREAMING_SNAKE_CASE__			:      List[str]							):
     SCREAMING_SNAKE_CASE:Tuple						      =					self.num_choices
     SCREAMING_SNAKE_CASE:Any						      =					TFRoFormerForMultipleChoice(config=SCREAMING_SNAKE_CASE__							)
     SCREAMING_SNAKE_CASE:Optional[int]						      =					tf.tile(tf.expand_dims(SCREAMING_SNAKE_CASE__     ,1							)     ,(1, self.num_choices, 1)							)
     SCREAMING_SNAKE_CASE:Optional[int]						      =					tf.tile(tf.expand_dims(SCREAMING_SNAKE_CASE__     ,1							)     ,(1, self.num_choices, 1)							)
     SCREAMING_SNAKE_CASE:Dict						      =					tf.tile(tf.expand_dims(SCREAMING_SNAKE_CASE__     ,1							)     ,(1, self.num_choices, 1)							)
     SCREAMING_SNAKE_CASE:str						      =					{
         "input_ids": multiple_choice_inputs_ids,
         "attention_mask": multiple_choice_input_mask,
         "token_type_ids": multiple_choice_token_type_ids,
     }
     SCREAMING_SNAKE_CASE:int						      =					model(SCREAMING_SNAKE_CASE__							)
     self.parent.assertEqual(result.logits.shape     ,(self.batch_size, self.num_choices)							)
   def     __UpperCamelCase						( self			:      Dict     ,SCREAMING_SNAKE_CASE__			:      int     ,SCREAMING_SNAKE_CASE__			:      List[Any]     ,SCREAMING_SNAKE_CASE__			:      str     ,SCREAMING_SNAKE_CASE__			:      Any     ,SCREAMING_SNAKE_CASE__			:      List[str]     ,SCREAMING_SNAKE_CASE__			:      List[str]     ,SCREAMING_SNAKE_CASE__			:      Union[str, Any]							):
     SCREAMING_SNAKE_CASE:List[Any]						      =					self.num_labels
     SCREAMING_SNAKE_CASE:Dict						      =					TFRoFormerForTokenClassification(config=SCREAMING_SNAKE_CASE__							)
     SCREAMING_SNAKE_CASE:Tuple						      =					{
         "input_ids": input_ids,
         "attention_mask": input_mask,
         "token_type_ids": token_type_ids,
     }
     SCREAMING_SNAKE_CASE:List[Any]						      =					model(SCREAMING_SNAKE_CASE__							)
     self.parent.assertEqual(result.logits.shape     ,(self.batch_size, self.seq_length, self.num_labels)							)
   def     __UpperCamelCase						( self			:      int     ,SCREAMING_SNAKE_CASE__			:      Dict     ,SCREAMING_SNAKE_CASE__			:      int     ,SCREAMING_SNAKE_CASE__			:      Optional[Any]     ,SCREAMING_SNAKE_CASE__			:      str     ,SCREAMING_SNAKE_CASE__			:      Any     ,SCREAMING_SNAKE_CASE__			:      List[str]     ,SCREAMING_SNAKE_CASE__			:      Optional[Any]							):
     SCREAMING_SNAKE_CASE:str						      =					TFRoFormerForQuestionAnswering(config=SCREAMING_SNAKE_CASE__							)
     SCREAMING_SNAKE_CASE:Any						      =					{
         "input_ids": input_ids,
         "attention_mask": input_mask,
         "token_type_ids": token_type_ids,
     }

     SCREAMING_SNAKE_CASE:Any						      =					model(SCREAMING_SNAKE_CASE__							)
     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     __UpperCamelCase						( self			:      int							):
     SCREAMING_SNAKE_CASE:List[Any]						      =					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
     )      ,    
     ):List[str]						      =					config_and_inputs
     SCREAMING_SNAKE_CASE:Optional[int]						      =					{"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
     return config, inputs_dict





@require_tf
class 							_snake_case (       _a	,  _a	,  unittest.TestCase						):
   _A       :     str       =					(
       (
           TFRoFormerModel,
           TFRoFormerForCausalLM,
           TFRoFormerForMaskedLM,
           TFRoFormerForQuestionAnswering,
           TFRoFormerForSequenceClassification,
           TFRoFormerForTokenClassification,
           TFRoFormerForMultipleChoice,
       )
       if is_tf_available()
       else ()
   )
   _A       :     Union[str, Any]       =					(
       {
           '''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 {}
   )

   _A       :     List[Any]       =					False
   _A       :     Any       =					False
   def     __UpperCamelCase						( self			:      List[Any]     ,SCREAMING_SNAKE_CASE__			:      int     ,SCREAMING_SNAKE_CASE__			:      Any     ,SCREAMING_SNAKE_CASE__			:      str     ,SCREAMING_SNAKE_CASE__			:      Optional[int]     ,SCREAMING_SNAKE_CASE__			:      Optional[int]							):
     if pipeline_test_casse_name == "TextGenerationPipelineTests":
       return True

     return False
   def     __UpperCamelCase						( self			:      List[Any]							):
     SCREAMING_SNAKE_CASE:Optional[int]						      =					TFRoFormerModelTester(self							)
     SCREAMING_SNAKE_CASE:Any						      =					ConfigTester(self     ,config_class=SCREAMING_SNAKE_CASE__     ,hidden_size=37							)
   def     __UpperCamelCase						( self			:      Tuple							):
     self.config_tester.run_common_tests()
   def     __UpperCamelCase						( self			:      Dict							):
     SCREAMING_SNAKE_CASE:Union[str, Any]						      =					self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE__							)
   def     __UpperCamelCase						( self			:      List[Any]							):
     SCREAMING_SNAKE_CASE:Any						      =					self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_masked_lm(*SCREAMING_SNAKE_CASE__							)
   def     __UpperCamelCase						( self			:      Tuple							):
     SCREAMING_SNAKE_CASE:Optional[Any]						      =					self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_lm_head(*SCREAMING_SNAKE_CASE__							)
   def     __UpperCamelCase						( self			:      int							):
     SCREAMING_SNAKE_CASE:Any						      =					self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_multiple_choice(*SCREAMING_SNAKE_CASE__							)
   def     __UpperCamelCase						( self			:      Optional[int]							):
     SCREAMING_SNAKE_CASE:Union[str, Any]						      =					self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_question_answering(*SCREAMING_SNAKE_CASE__							)
   def     __UpperCamelCase						( self			:      Any							):
     SCREAMING_SNAKE_CASE:Tuple						      =					self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_sequence_classification(*SCREAMING_SNAKE_CASE__							)
   def     __UpperCamelCase						( self			:      List[Any]							):
     SCREAMING_SNAKE_CASE:int						      =					self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_token_classification(*SCREAMING_SNAKE_CASE__							)







   @slow
   def     __UpperCamelCase						( self			:      Optional[Any]							):
     SCREAMING_SNAKE_CASE:List[str]						      =					TFRoFormerModel.from_pretrained("junnyu/roformer_chinese_base"							)
     self.assertIsNotNone(SCREAMING_SNAKE_CASE__							)





@require_tf
class 							_snake_case (       unittest.TestCase						):
   @slow
   def     __UpperCamelCase						( self			:      List[str]							):
     SCREAMING_SNAKE_CASE:Dict						      =					TFRoFormerForMaskedLM.from_pretrained("junnyu/roformer_chinese_base"							)
     SCREAMING_SNAKE_CASE:Any						      =					tf.constant([[0, 1, 2, 3, 4, 5]]							)
     SCREAMING_SNAKE_CASE:Dict						      =					model(SCREAMING_SNAKE_CASE__							)[0]

     # TODO Replace vocab size
     SCREAMING_SNAKE_CASE:Union[str, Any]						      =					50_000

     SCREAMING_SNAKE_CASE:List[Any]						      =					[1, 6, vocab_size]
     self.assertEqual(output.shape     ,SCREAMING_SNAKE_CASE__							)

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

     # TODO Replace values below with what was printed above.
     SCREAMING_SNAKE_CASE:List[str]						      =					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]     ,SCREAMING_SNAKE_CASE__     ,atol=1e-4							)





@require_tf
class 							_snake_case (       unittest.TestCase						):
   _A       :     int       =					1E-4
   def     __UpperCamelCase						( self			:      Optional[int]							):
     SCREAMING_SNAKE_CASE:Any						      =					tf.constant([[4, 10]]							)
     SCREAMING_SNAKE_CASE:Dict						      =					TFRoFormerSinusoidalPositionalEmbedding(num_positions=6     ,embedding_dim=6							)

     SCREAMING_SNAKE_CASE:Union[str, Any]						      =					emba(input_ids.shape							)
     SCREAMING_SNAKE_CASE:List[str]						      =					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(SCREAMING_SNAKE_CASE__     ,SCREAMING_SNAKE_CASE__     ,atol=self.tolerance							)







   def     __UpperCamelCase						( self			:      int							):
     SCREAMING_SNAKE_CASE:List[Any]						      =					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],
         ]							)
     SCREAMING_SNAKE_CASE:List[Any]						      =					TFRoFormerSinusoidalPositionalEmbedding(num_positions=512     ,embedding_dim=512							)
     emba([2, 16, 512]							)
     SCREAMING_SNAKE_CASE:Optional[Any]						      =					emba.weight[:3, :5]

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





@require_tf
class 							_snake_case (       unittest.TestCase						):
   _A       :     Any       =					1E-4
   def     __UpperCamelCase						( self			:      Dict							):
     # 2,12,16,64
     SCREAMING_SNAKE_CASE:Dict						      =					tf.reshape(tf.range(2 * 12 * 16 * 64     ,dtype=tf.floataa							)     ,shape=(2, 12, 16, 64)							) / 100

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

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

     SCREAMING_SNAKE_CASE      ,    SCREAMING_SNAKE_CASE:str						      =					TFRoFormerSelfAttention.apply_rotary_position_embeddings(
         SCREAMING_SNAKE_CASE__     ,SCREAMING_SNAKE_CASE__     ,SCREAMING_SNAKE_CASE__							)

     SCREAMING_SNAKE_CASE:Tuple						      =					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],
         ]							)
     SCREAMING_SNAKE_CASE:Optional[int]						      =					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]     ,SCREAMING_SNAKE_CASE__     ,atol=self.tolerance							)
     tf.debugging.assert_near(key_layer[0, 0, :6, :8]     ,SCREAMING_SNAKE_CASE__     ,atol=self.tolerance							)









'''simple docstring'''

def    A_  ( snake_case = 100 ):
  SCREAMING_SNAKE_CASE:Dict						      =					0
  SCREAMING_SNAKE_CASE:Optional[int]						      =					0
  for i in range(1      ,       n + 1 ):
    sum_of_squares += i**2
    sum_of_ints += i
  return sum_of_ints**2 - sum_of_squares


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






