

from __future__ import annotations

import unittest

from transformers import AutoTokenizer, GPTJConfig, is_tf_available
from transformers.testing_utils import require_tf, slow, tooslow

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


if is_tf_available():
 import tensorflow as tf

 from transformers.models.gptj.modeling_tf_gptj import (
     TFGPTJForCausalLM,
     TFGPTJForQuestionAnswering,
     TFGPTJForSequenceClassification,
     TFGPTJModel,
     shape_list,
 )



class 		a_	:



      """simple docstring"""







      def __init__(				self					:							Tuple      ,snake_case					:							List[Any]    ):
           SCREAMING_SNAKE_CASE										=       parent
           SCREAMING_SNAKE_CASE										=       13
           SCREAMING_SNAKE_CASE										=       7
           SCREAMING_SNAKE_CASE										=       True
           SCREAMING_SNAKE_CASE										=       True
           SCREAMING_SNAKE_CASE										=       True
           SCREAMING_SNAKE_CASE										=       True
           SCREAMING_SNAKE_CASE										=       True
           SCREAMING_SNAKE_CASE										=       99
           SCREAMING_SNAKE_CASE										=       32
           SCREAMING_SNAKE_CASE										=       4
           SCREAMING_SNAKE_CASE										=       2
           SCREAMING_SNAKE_CASE										=       4
           SCREAMING_SNAKE_CASE										=       37
           SCREAMING_SNAKE_CASE										=       "gelu"
           SCREAMING_SNAKE_CASE										=       0.1
           SCREAMING_SNAKE_CASE										=       0.1
           SCREAMING_SNAKE_CASE										=       512
           SCREAMING_SNAKE_CASE										=       16
           SCREAMING_SNAKE_CASE										=       2
           SCREAMING_SNAKE_CASE										=       0.02
           SCREAMING_SNAKE_CASE										=       3
           SCREAMING_SNAKE_CASE										=       4
           SCREAMING_SNAKE_CASE										=       None
           SCREAMING_SNAKE_CASE										=       self.vocab_size - 1
           SCREAMING_SNAKE_CASE										=       self.vocab_size - 1
           SCREAMING_SNAKE_CASE										=       self.vocab_size - 1
      def 	_lowerCAmelCase					(				self					:							str    ):
           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
           if self.use_mc_token_ids:
                SCREAMING_SNAKE_CASE										=       ids_tensor([self.batch_size, self.num_choices]      ,self.seq_length    )

           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										=       GPTJConfig(
               vocab_size=self.vocab_size      ,n_embd=self.hidden_size      ,n_layer=self.num_hidden_layers      ,n_head=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      ,n_positions=self.max_position_embeddings      ,type_vocab_size=self.type_vocab_size      ,initializer_range=self.initializer_range      ,bos_token_id=self.bos_token_id      ,eos_token_id=self.eos_token_id      ,pad_token_id=self.pad_token_id      ,rotary_dim=self.rotary_dim      ,return_dict=snake_case      ,)

           SCREAMING_SNAKE_CASE										=       ids_tensor([self.num_hidden_layers, self.num_attention_heads]      ,2    )

           return (
               config,
               input_ids,
               input_mask,
               head_mask,
               token_type_ids,
               mc_token_ids,
               sequence_labels,
               token_labels,
               choice_labels,
           )
      def 	_lowerCAmelCase					(				self					:							Tuple      ,snake_case					:							str      ,snake_case					:							List[str]      ,snake_case					:							Dict      ,snake_case					:							int      ,snake_case					:							List[str]      ,*snake_case					:							int    ):
           SCREAMING_SNAKE_CASE										=       TFGPTJModel(config=snake_case    )
           SCREAMING_SNAKE_CASE										=       {
               "input_ids": input_ids,
               "attention_mask": input_mask,
               "token_type_ids": token_type_ids,
           }
           SCREAMING_SNAKE_CASE										=       model(snake_case    )

           SCREAMING_SNAKE_CASE										=       [input_ids, None, input_mask]  # None is the input for 'past'
           SCREAMING_SNAKE_CASE										=       model(snake_case    )

           SCREAMING_SNAKE_CASE										=       model(snake_case    )

           self.parent.assertEqual(result.last_hidden_state.shape      ,(self.batch_size, self.seq_length, self.hidden_size)    )
      def 	_lowerCAmelCase					(				self					:							Tuple      ,snake_case					:							str      ,snake_case					:							Any      ,snake_case					:							List[str]      ,snake_case					:							str      ,snake_case					:							str      ,*snake_case					:							List[Any]    ):
           SCREAMING_SNAKE_CASE										=       TFGPTJModel(config=snake_case    )

           # first forward pass
           SCREAMING_SNAKE_CASE										=       model(snake_case      ,token_type_ids=snake_case      ,use_cache=snake_case    )
           SCREAMING_SNAKE_CASE										=       model(snake_case      ,token_type_ids=snake_case    )
           SCREAMING_SNAKE_CASE										=       model(snake_case      ,token_type_ids=snake_case      ,use_cache=snake_case    )

           self.parent.assertTrue(len(snake_case    ) == len(snake_case    )    )
           self.parent.assertTrue(len(snake_case    ) == len(snake_case    ) + 1    )

           SCREAMING_SNAKE_CASE										=       outputs.to_tuple()

           # create hypothetical next token and extent to next_input_ids
           SCREAMING_SNAKE_CASE										=       ids_tensor((self.batch_size, 1)      ,config.vocab_size    )
           SCREAMING_SNAKE_CASE										=       ids_tensor([self.batch_size, 1]      ,self.type_vocab_size    )

           # append to next input_ids and token_type_ids
           SCREAMING_SNAKE_CASE										=       tf.concat([input_ids, next_tokens]      ,axis=-1    )
           SCREAMING_SNAKE_CASE										=       tf.concat([token_type_ids, next_token_types]      ,axis=-1    )

           SCREAMING_SNAKE_CASE										=       model(snake_case      ,token_type_ids=snake_case    )["last_hidden_state"]
           SCREAMING_SNAKE_CASE										=       model(snake_case      ,token_type_ids=snake_case      ,past_key_values=snake_case    )[
               "last_hidden_state"
           ]

           # select random slice
           SCREAMING_SNAKE_CASE										=       int(ids_tensor((1,)      ,shape_list(snake_case    )[-1]    )    )
           SCREAMING_SNAKE_CASE										=       output_from_no_past[:, -1, random_slice_idx]
           SCREAMING_SNAKE_CASE										=       output_from_past[:, 0, random_slice_idx]

           # test that outputs are equal for slice
           tf.debugging.assert_near(snake_case      ,snake_case      ,rtol=1e-6    )
      def 	_lowerCAmelCase					(				self					:							str      ,snake_case					:							Tuple      ,snake_case					:							int      ,snake_case					:							Dict      ,snake_case					:							Dict      ,snake_case					:							int      ,*snake_case					:							Optional[Any]    ):
           SCREAMING_SNAKE_CASE										=       TFGPTJModel(config=snake_case    )

           # create attention mask
           SCREAMING_SNAKE_CASE										=       self.seq_length // 2
           SCREAMING_SNAKE_CASE										=       tf.ones((self.batch_size, half_seq_length)      ,dtype=tf.intaa    )
           SCREAMING_SNAKE_CASE										=       tf.zeros((self.batch_size, self.seq_length - half_seq_length)      ,dtype=tf.intaa    )
           SCREAMING_SNAKE_CASE										=       tf.concat([attn_mask_begin, attn_mask_end]      ,axis=1    )

           # first forward pass
           SCREAMING_SNAKE_CASE										=       model(snake_case      ,attention_mask=snake_case    ).to_tuple()

           # create hypothetical next token and extent to next_input_ids
           SCREAMING_SNAKE_CASE										=       ids_tensor((self.batch_size, 1)      ,config.vocab_size    )

           # change a random masked slice from input_ids
           SCREAMING_SNAKE_CASE										=       ids_tensor((1,)      ,snake_case    ).numpy() + 1
           SCREAMING_SNAKE_CASE										=       ids_tensor((self.batch_size, self.seq_length)      ,config.vocab_size    )
           SCREAMING_SNAKE_CASE										=       tf.range(self.seq_length    ) == (self.seq_length - random_seq_idx_to_change)
           SCREAMING_SNAKE_CASE										=       tf.transpose(
               tf.broadcast_to(tf.expand_dims(snake_case      ,-1    )      ,(self.seq_length, self.batch_size)    )    )
           SCREAMING_SNAKE_CASE										=       tf.where(snake_case      ,snake_case      ,snake_case    )

           # append to next input_ids and attn_mask
           SCREAMING_SNAKE_CASE										=       tf.concat([input_ids, next_tokens]      ,axis=-1    )
           SCREAMING_SNAKE_CASE										=       tf.concat([attn_mask, tf.ones((shape_list(snake_case    )[0], 1)      ,dtype=tf.intaa    )]      ,axis=1    )

           # get two different outputs
           SCREAMING_SNAKE_CASE										=       model(snake_case      ,attention_mask=snake_case    )["last_hidden_state"]
           SCREAMING_SNAKE_CASE										=       model(snake_case      ,past_key_values=snake_case      ,attention_mask=snake_case    )[
               "last_hidden_state"
           ]

           # select random slice
           SCREAMING_SNAKE_CASE										=       int(ids_tensor((1,)      ,shape_list(snake_case    )[-1]    )    )
           SCREAMING_SNAKE_CASE										=       output_from_no_past[:, -1, random_slice_idx]
           SCREAMING_SNAKE_CASE										=       output_from_past[:, 0, random_slice_idx]

           # test that outputs are equal for slice
           tf.debugging.assert_near(snake_case      ,snake_case      ,rtol=1e-12    )
      def 	_lowerCAmelCase					(				self					:							Tuple      ,snake_case					:							Optional[int]      ,snake_case					:							Tuple      ,snake_case					:							Union[str, Any]      ,snake_case					:							List[Any]      ,snake_case					:							Any      ,*snake_case					:							Union[str, Any]    ):
           SCREAMING_SNAKE_CASE										=       TFGPTJModel(config=snake_case    )

           SCREAMING_SNAKE_CASE										=       input_ids[:1, :]
           SCREAMING_SNAKE_CASE										=       input_mask[:1, :]
           SCREAMING_SNAKE_CASE										=       token_type_ids[:1, :]
           SCREAMING_SNAKE_CASE										=       1

           # first forward pass
           SCREAMING_SNAKE_CASE										=       model(snake_case      ,attention_mask=snake_case      ,token_type_ids=snake_case      ,use_cache=snake_case    )

           SCREAMING_SNAKE_CASE										=       outputs.to_tuple()

           # create hypothetical next token and extent to next_input_ids
           SCREAMING_SNAKE_CASE										=       ids_tensor((self.batch_size, 3)      ,config.vocab_size    )
           SCREAMING_SNAKE_CASE										=       ids_tensor((self.batch_size, 3)      ,2    )
           SCREAMING_SNAKE_CASE										=       ids_tensor((self.batch_size, 3)      ,self.type_vocab_size    )

           # append to next input_ids and token_type_ids
           SCREAMING_SNAKE_CASE										=       tf.concat([input_ids, next_tokens]      ,axis=-1    )
           SCREAMING_SNAKE_CASE										=       tf.concat([input_mask, next_attn_mask]      ,axis=-1    )
           SCREAMING_SNAKE_CASE										=       tf.concat([token_type_ids, next_token_types]      ,axis=-1    )

           SCREAMING_SNAKE_CASE										=       model(
               snake_case      ,token_type_ids=snake_case      ,attention_mask=snake_case    )["last_hidden_state"]
           SCREAMING_SNAKE_CASE										=       model(
               snake_case      ,token_type_ids=snake_case      ,attention_mask=snake_case      ,past_key_values=snake_case      ,)["last_hidden_state"]
           self.parent.assertTrue(output_from_past.shape[1] == next_tokens.shape[1]    )

           # select random slice
           SCREAMING_SNAKE_CASE										=       int(ids_tensor((1,)      ,shape_list(snake_case    )[-1]    )    )
           SCREAMING_SNAKE_CASE										=       output_from_no_past[:, -3:, random_slice_idx]
           SCREAMING_SNAKE_CASE										=       output_from_past[:, :, random_slice_idx]

           # test that outputs are equal for slice
           tf.debugging.assert_near(snake_case      ,snake_case      ,rtol=1e-3    )
      def 	_lowerCAmelCase					(				self					:							List[str]      ,snake_case					:							List[str]      ,snake_case					:							Tuple      ,snake_case					:							Optional[int]      ,snake_case					:							List[str]      ,snake_case					:							str      ,*snake_case					:							int    ):
           SCREAMING_SNAKE_CASE										=       TFGPTJForCausalLM(config=snake_case    )
           SCREAMING_SNAKE_CASE										=       {
               "input_ids": input_ids,
               "attention_mask": input_mask,
               "token_type_ids": token_type_ids,
           }
           SCREAMING_SNAKE_CASE										=       model(snake_case    )
           self.parent.assertEqual(result.logits.shape      ,(self.batch_size, self.seq_length, self.vocab_size)    )


      def 	_lowerCAmelCase					(				self					:							List[Any]    ):
           SCREAMING_SNAKE_CASE										=       self.prepare_config_and_inputs()

           (
               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_tf
class 		a_	(							__A			,      __A			,      __A			,      unittest.TestCase					):



      """simple docstring"""







      __UpperCAmelCase      		=				(
          (TFGPTJForCausalLM, TFGPTJForSequenceClassification, TFGPTJForQuestionAnswering, TFGPTJModel)
          if is_tf_available()
          else ()
      )

      __UpperCAmelCase      		=				(TFGPTJForCausalLM,) if is_tf_available() else ()
      __UpperCAmelCase      		=				(
          {
              'feature-extraction': TFGPTJModel,
              'question-answering': TFGPTJForQuestionAnswering,
              'text-classification': TFGPTJForSequenceClassification,
              'text-generation': TFGPTJForCausalLM,
              'zero-shot': TFGPTJForSequenceClassification,
          }
          if is_tf_available()
          else {}
      )
      __UpperCAmelCase      		=				False
      __UpperCAmelCase      		=				False
      __UpperCAmelCase      		=				False
      __UpperCAmelCase      		=				False
      def 	_lowerCAmelCase					(				self					:							Optional[Any]      ,snake_case					:							Optional[Any]      ,snake_case					:							List[Any]      ,snake_case					:							List[str]      ,snake_case					:							Optional[Any]      ,snake_case					:							List[str]    ):

           if (
               pipeline_test_casse_name == "QAPipelineTests"
               and tokenizer_name is not None
               and not tokenizer_name.endswith('Fast'    )
           ):
                # `QAPipelineTests` fails for a few models when the slower tokenizer are used.
                # (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
                # TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
                return True

           return False
      def 	_lowerCAmelCase					(				self					:							int    ):
           SCREAMING_SNAKE_CASE										=       TFGPTJModelTester(self    )
           SCREAMING_SNAKE_CASE										=       ConfigTester(self      ,config_class=snake_case      ,n_embd=37    )
      def 	_lowerCAmelCase					(				self					:							List[str]    ):
           self.config_tester.run_common_tests()
      def 	_lowerCAmelCase					(				self					:							Optional[Any]    ):
           SCREAMING_SNAKE_CASE										=       self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_gptj_model(*snake_case    )
      def 	_lowerCAmelCase					(				self					:							Optional[Any]    ):
           SCREAMING_SNAKE_CASE										=       self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_gptj_model_past(*snake_case    )
      def 	_lowerCAmelCase					(				self					:							Optional[Any]    ):
           SCREAMING_SNAKE_CASE										=       self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_gptj_model_attention_mask_past(*snake_case    )
      def 	_lowerCAmelCase					(				self					:							Dict    ):
           SCREAMING_SNAKE_CASE										=       self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_gptj_model_past_large_inputs(*snake_case    )
      def 	_lowerCAmelCase					(				self					:							Dict    ):
           SCREAMING_SNAKE_CASE										=       self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_gptj_lm_head_model(*snake_case    )
      @slow
      @unittest.skipIf(
          not is_tf_available() or len(tf.config.list_physical_devices('GPU'    )    ) > 0      ,'skip testing on GPU for now to avoid GPU OOM.'      ,)
      def 	_lowerCAmelCase					(				self					:							Union[str, Any]    ):
           SCREAMING_SNAKE_CASE										=       TFGPTJModel.from_pretrained('EleutherAI/gpt-j-6B'      ,from_pt=snake_case    )
           self.assertIsNotNone(snake_case    )


      @unittest.skip(reason='Currently, model embeddings are going to undergo a major refactor.'    )
      def 	_lowerCAmelCase					(				self					:							List[str]    ):
           super().test_resize_token_embeddings()







@require_tf
@tooslow
# Marked as @tooslow due to GPU OOM -- but still useful to run locally. Requires ~39GB of RAM.
class 		a_	(							unittest.TestCase					):



      """simple docstring"""







      def 	_lowerCAmelCase					(				self					:							Dict    ):
           SCREAMING_SNAKE_CASE										=       TFGPTJForCausalLM.from_pretrained('EleutherAI/gpt-j-6B'      ,from_pt=snake_case    )
           SCREAMING_SNAKE_CASE										=       tf.convert_to_tensor([[464, 3290]]      ,dtype=tf.intaa    )  # The dog
           # fmt: off
           # The dog is a man's best friend. It is a loyal companion, and it is a friend
           SCREAMING_SNAKE_CASE										=       [464, 3290, 318, 257, 582, 338, 1266, 1545, 13, 632, 318, 257, 9112, 15185, 11, 290, 340, 318, 257, 1545]
           # fmt: on
           SCREAMING_SNAKE_CASE										=       model.generate(snake_case      ,do_sample=snake_case    )
           self.assertListEqual(output_ids[0].numpy().tolist()      ,snake_case    )
      def 	_lowerCAmelCase					(				self					:							Union[str, Any]    ):
           SCREAMING_SNAKE_CASE										=       AutoTokenizer.from_pretrained('EleutherAI/gpt-j-6B'      ,revision='float16'    )
           SCREAMING_SNAKE_CASE										=       TFGPTJForCausalLM.from_pretrained('EleutherAI/gpt-j-6B'      ,revision='float16'      ,from_pt=snake_case    )

           SCREAMING_SNAKE_CASE										=       tokenizer('Today is a nice day and'      ,return_tensors='tf'    )
           # forces the generation to happen on CPU, to avoid GPU-related quirks
           with tf.device(':/CPU:0'    ):
                SCREAMING_SNAKE_CASE										=       model.generate(**snake_case      ,do_sample=snake_case      ,seed=[42, 0]    )
           SCREAMING_SNAKE_CASE										=       tokenizer.decode(output_ids[0]      ,skip_special_tokens=snake_case    )

           SCREAMING_SNAKE_CASE										=       "Today is a nice day and I’m going to go for a walk. I’"
           self.assertEqual(snake_case      ,snake_case    )
      def 	_lowerCAmelCase					(				self					:							Tuple    ):
           SCREAMING_SNAKE_CASE										=       TFGPTJForCausalLM.from_pretrained('EleutherAI/gpt-j-6B'      ,revision='float16'      ,from_pt=snake_case    )
           SCREAMING_SNAKE_CASE										=       AutoTokenizer.from_pretrained('EleutherAI/gpt-j-6B'      ,revision='float16'    )

           SCREAMING_SNAKE_CASE										=       "left"

           # Define PAD Token = EOS Token = 50256
           SCREAMING_SNAKE_CASE										=       tokenizer.eos_token
           SCREAMING_SNAKE_CASE										=       model.config.eos_token_id

           # use different length sentences to test batching
           SCREAMING_SNAKE_CASE										=       [
               "Hello, my dog is a little",
               "Today, I",
           ]
           SCREAMING_SNAKE_CASE										=       [
               "Hello, my dog is a little over a year old and has been diagnosed with hip dysplasia",
               "Today, I’m going to be talking about a topic that’",
           ]
           return model, tokenizer, sentences, expected_output_sentences
      def 	_lowerCAmelCase					(				self					:							Optional[int]    ):
           SCREAMING_SNAKE_CASE										=       self._get_beam_search_test_objects()

           SCREAMING_SNAKE_CASE										=       tokenizer(snake_case      ,return_tensors='tf'      ,padding=snake_case    )
           SCREAMING_SNAKE_CASE										=       model.generate(**snake_case      ,do_sample=snake_case      ,num_beams=2    )
           SCREAMING_SNAKE_CASE										=       tokenizer.batch_decode(snake_case      ,skip_special_tokens=snake_case    )
           self.assertListEqual(snake_case      ,snake_case    )
      def 	_lowerCAmelCase					(				self					:							List[str]    ):
           SCREAMING_SNAKE_CASE										=       self._get_beam_search_test_objects()

           SCREAMING_SNAKE_CASE										=       tokenizer(snake_case      ,return_tensors='tf'      ,padding=snake_case    )
           SCREAMING_SNAKE_CASE										=       tokenizer(sentences[0]      ,return_tensors='tf'    )
           SCREAMING_SNAKE_CASE										=       model.generate(**snake_case      ,do_sample=snake_case      ,num_beams=2    )
           SCREAMING_SNAKE_CASE										=       (
               shape_list(inputs_non_padded['input_ids']    )[-1]
               - tf.reduce_sum(tf.cast(inputs['attention_mask'][-1]      ,tf.intaa    )    ).numpy()
           )
           SCREAMING_SNAKE_CASE										=       tokenizer(sentences[1]      ,return_tensors='tf'    )
           SCREAMING_SNAKE_CASE										=       model.generate(
               **snake_case      ,do_sample=snake_case      ,num_beams=2      ,max_length=model.config.max_length - num_paddings    )
           SCREAMING_SNAKE_CASE										=       tokenizer.decode(output_non_padded[0]      ,skip_special_tokens=snake_case    )
           SCREAMING_SNAKE_CASE										=       tokenizer.decode(output_padded[0]      ,skip_special_tokens=snake_case    )
           self.assertListEqual(snake_case      ,[non_padded_sentence, padded_sentence]    )


      def 	_lowerCAmelCase					(				self					:							List[str]    ):
           SCREAMING_SNAKE_CASE										=       self._get_beam_search_test_objects()

           SCREAMING_SNAKE_CASE										=       tokenizer(snake_case      ,return_tensors='tf'      ,padding=snake_case    )
           SCREAMING_SNAKE_CASE										=       tf.function(model.generate      ,jit_compile=snake_case    )
           SCREAMING_SNAKE_CASE										=       xla_generate(**snake_case      ,do_sample=snake_case      ,num_beams=2    )
           SCREAMING_SNAKE_CASE										=       tokenizer.batch_decode(snake_case      ,skip_special_tokens=snake_case    )
           self.assertListEqual(snake_case      ,snake_case    )




def       snake_case__    (       lowerCAmelCase_,   lowerCAmelCase_,   lowerCAmelCase_      ):





     """simple docstring"""







     if power < 0:
          return -1
     base %= mod
     SCREAMING_SNAKE_CASE										=1

     while power > 0:
          if power & 1:
               SCREAMING_SNAKE_CASE										=(result * base) % mod
          SCREAMING_SNAKE_CASE										=power >> 1
          SCREAMING_SNAKE_CASE										=(base * base) % mod

     return result







def       snake_case__    (       ):





     """simple docstring"""







     print(modular_exponential(3,   200,   13      )      )


if __name__ == "__main__":
 import doctest

 doctest.testmod()

 main()

