


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     lowerCamelCase__		:






			"""simple docstring"""






			def __init__(							self ,  snake_case       ):

						'''simple docstring'''


						UpperCamelCase__   =    parent
						UpperCamelCase__   =    13
						UpperCamelCase__   =    7
						UpperCamelCase__   =    True
						UpperCamelCase__   =    True
						UpperCamelCase__   =    True
						UpperCamelCase__   =    True
						UpperCamelCase__   =    True
						UpperCamelCase__   =    99
						UpperCamelCase__   =    32
						UpperCamelCase__   =    4
						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
						UpperCamelCase__   =    self.vocab_size - 1
						UpperCamelCase__   =    self.vocab_size - 1
						UpperCamelCase__   =    self.vocab_size - 1




			def 			snake_case__			(							self       ):

						'''simple docstring'''


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

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

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

						UpperCamelCase__   =    None
						if self.use_mc_token_ids:
									UpperCamelCase__   =    ids_tensor([self.batch_size, self.num_choices] ,  self.seq_length       )

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

						UpperCamelCase__   =    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 ,  )

						UpperCamelCase__   =    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 			snake_case__			(							self ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  *snake_case       ):

						'''simple docstring'''


						UpperCamelCase__   =    TFGPTJModel(config=snake_case       )
						UpperCamelCase__   =    {
						    "input_ids": input_ids,
						    "attention_mask": input_mask,
						    "token_type_ids": token_type_ids,
						}
						UpperCamelCase__   =    model(snake_case       )

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

						UpperCamelCase__   =    model(snake_case       )

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




			def 			snake_case__			(							self ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  *snake_case       ):

						'''simple docstring'''


						UpperCamelCase__   =    TFGPTJModel(config=snake_case       )

						# first forward pass
						UpperCamelCase__   =    model(snake_case ,  token_type_ids=snake_case ,  use_cache=snake_case       )
						UpperCamelCase__   =    model(snake_case ,  token_type_ids=snake_case       )
						UpperCamelCase__   =    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       )

						UpperCamelCase__, UpperCamelCase__   =    outputs.to_tuple()

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

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

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

						# select random slice
						UpperCamelCase__   =    int(ids_tensor((1,) ,  shape_list(snake_case       )[-1]       )       )
						UpperCamelCase__   =    output_from_no_past[:, -1, random_slice_idx]
						UpperCamelCase__   =    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 			snake_case__			(							self ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  *snake_case       ):

						'''simple docstring'''


						UpperCamelCase__   =    TFGPTJModel(config=snake_case       )

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

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

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

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

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

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

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

						# test that outputs are equal for slice
						tf.debugging.assert_near(snake_case ,  snake_case ,  rtol=1E-1_2       )




			def 			snake_case__			(							self ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  *snake_case       ):

						'''simple docstring'''


						UpperCamelCase__   =    TFGPTJModel(config=snake_case       )

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

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

						UpperCamelCase__, UpperCamelCase__   =    outputs.to_tuple()

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

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

						UpperCamelCase__   =    model(
						    snake_case ,  token_type_ids=snake_case ,  attention_mask=snake_case       )["last_hidden_state"]
						UpperCamelCase__   =    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
						UpperCamelCase__   =    int(ids_tensor((1,) ,  shape_list(snake_case       )[-1]       )       )
						UpperCamelCase__   =    output_from_no_past[:, -3:, random_slice_idx]
						UpperCamelCase__   =    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 			snake_case__			(							self ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  *snake_case       ):

						'''simple docstring'''


						UpperCamelCase__   =    TFGPTJForCausalLM(config=snake_case       )
						UpperCamelCase__   =    {
						    "input_ids": input_ids,
						    "attention_mask": input_mask,
						    "token_type_ids": token_type_ids,
						}
						UpperCamelCase__   =    model(snake_case       )
						self.parent.assertEqual(result.logits.shape ,  (self.batch_size, self.seq_length, self.vocab_size)       )







			def 			snake_case__			(							self       ):

						'''simple docstring'''


						UpperCamelCase__   =    self.prepare_config_and_inputs()

						(
						    (
						    UpperCamelCase__ 
						), (
						    UpperCamelCase__ 
						), (
						    UpperCamelCase__ 
						), (
						    UpperCamelCase__ 
						), (
						    UpperCamelCase__ 
						), (
						    UpperCamelCase__ 
						), (
						    UpperCamelCase__ 
						), (
						    UpperCamelCase__ 
						), (
						    UpperCamelCase__ 
						),  
						)   =    config_and_inputs

						UpperCamelCase__   =    {
						    "input_ids": input_ids,
						    "token_type_ids": token_type_ids,
						    "attention_mask": input_mask,
						}
						return config, inputs_dict







@require_tf
class     lowerCamelCase__		(							UpperCAmelCase   ,		UpperCAmelCase   ,		UpperCAmelCase   ,		unittest.TestCase ):






			"""simple docstring"""






			_UpperCamelCase						:   Dict					=						(
			    (TFGPTJForCausalLM, TFGPTJForSequenceClassification, TFGPTJForQuestionAnswering, TFGPTJModel)
			    if is_tf_available()
			    else ()
			)

			_UpperCamelCase						:   Any					=						(TFGPTJForCausalLM,) if is_tf_available() else ()
			_UpperCamelCase						:   Tuple					=						(
			    {
			        'feature-extraction': TFGPTJModel,
			        'question-answering': TFGPTJForQuestionAnswering,
			        'text-classification': TFGPTJForSequenceClassification,
			        'text-generation': TFGPTJForCausalLM,
			        'zero-shot': TFGPTJForSequenceClassification,
			    }
			    if is_tf_available()
			    else {}
			)
			_UpperCamelCase						:   Dict					=						False
			_UpperCamelCase						:   List[str]					=						False
			_UpperCamelCase						:   str					=						False
			_UpperCamelCase						:   Dict					=						False




			def 			snake_case__			(							self ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  snake_case       ):

						'''simple docstring'''


						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 			snake_case__			(							self       ):

						'''simple docstring'''


						UpperCamelCase__   =    TFGPTJModelTester(self       )
						UpperCamelCase__   =    ConfigTester(self ,  config_class=snake_case ,  n_embd=37       )




			def 			snake_case__			(							self       ):

						'''simple docstring'''


						self.config_tester.run_common_tests()




			def 			snake_case__			(							self       ):

						'''simple docstring'''


						UpperCamelCase__   =    self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_gptj_model(*snake_case       )




			def 			snake_case__			(							self       ):

						'''simple docstring'''


						UpperCamelCase__   =    self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_gptj_model_past(*snake_case       )




			def 			snake_case__			(							self       ):

						'''simple docstring'''


						UpperCamelCase__   =    self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_gptj_model_attention_mask_past(*snake_case       )




			def 			snake_case__			(							self       ):

						'''simple docstring'''


						UpperCamelCase__   =    self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_gptj_model_past_large_inputs(*snake_case       )




			def 			snake_case__			(							self       ):

						'''simple docstring'''


						UpperCamelCase__   =    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 			snake_case__			(							self       ):

						'''simple docstring'''


						UpperCamelCase__   =    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 			snake_case__			(							self       ):

						'''simple docstring'''


						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     lowerCamelCase__		(							unittest.TestCase ):






			"""simple docstring"""






			def 			snake_case__			(							self       ):

						'''simple docstring'''


						UpperCamelCase__   =    TFGPTJForCausalLM.from_pretrained("EleutherAI/gpt-j-6B" ,  from_pt=snake_case       )
						UpperCamelCase__   =    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
						UpperCamelCase__   =    [464, 3290, 318, 257, 582, 338, 1266, 1545, 13, 632, 318, 257, 9112, 15185, 11, 290, 340, 318, 257, 1545]
						# fmt: on
						UpperCamelCase__   =    model.generate(snake_case ,  do_sample=snake_case       )
						self.assertListEqual(output_ids[0].numpy().tolist() ,  snake_case       )




			def 			snake_case__			(							self       ):

						'''simple docstring'''


						UpperCamelCase__   =    AutoTokenizer.from_pretrained("EleutherAI/gpt-j-6B" ,  revision="float16"       )
						UpperCamelCase__   =    TFGPTJForCausalLM.from_pretrained("EleutherAI/gpt-j-6B" ,  revision="float16" ,  from_pt=snake_case       )

						UpperCamelCase__   =    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"       ):
									UpperCamelCase__   =    model.generate(**snake_case ,  do_sample=snake_case ,  seed=[42, 0]       )
						UpperCamelCase__   =    tokenizer.decode(output_ids[0] ,  skip_special_tokens=snake_case       )

						UpperCamelCase__   =    "Today is a nice day and I’m going to go for a walk. I’"
						self.assertEqual(snake_case ,  snake_case       )




			def 			snake_case__			(							self       ):

						'''simple docstring'''


						UpperCamelCase__   =    TFGPTJForCausalLM.from_pretrained("EleutherAI/gpt-j-6B" ,  revision="float16" ,  from_pt=snake_case       )
						UpperCamelCase__   =    AutoTokenizer.from_pretrained("EleutherAI/gpt-j-6B" ,  revision="float16"       )

						UpperCamelCase__   =    "left"

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

						# use different length sentences to test batching
						UpperCamelCase__   =    [
						    "Hello, my dog is a little",
						    "Today, I",
						]
						UpperCamelCase__   =    [
						    "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 			snake_case__			(							self       ):

						'''simple docstring'''


						UpperCamelCase__, UpperCamelCase__, UpperCamelCase__, UpperCamelCase__   =    self._get_beam_search_test_objects()

						UpperCamelCase__   =    tokenizer(snake_case ,  return_tensors="tf" ,  padding=snake_case       )
						UpperCamelCase__   =    model.generate(**snake_case ,  do_sample=snake_case ,  num_beams=2       )
						UpperCamelCase__   =    tokenizer.batch_decode(snake_case ,  skip_special_tokens=snake_case       )
						self.assertListEqual(snake_case ,  snake_case       )




			def 			snake_case__			(							self       ):

						'''simple docstring'''


						UpperCamelCase__, UpperCamelCase__, UpperCamelCase__, UpperCamelCase__   =    self._get_beam_search_test_objects()

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







			def 			snake_case__			(							self       ):

						'''simple docstring'''


						UpperCamelCase__, UpperCamelCase__, UpperCamelCase__, UpperCamelCase__   =    self._get_beam_search_test_objects()

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






from __future__ import annotations
def     UpperCamelCase_(			_A				:list					)->						int | float:
			UpperCamelCase__   =    sorted(_A					)
			UpperCamelCase__   =    len(_A					)
			UpperCamelCase__   =    length >> 1
			return (
			    (sorted_list[mid_index] + sorted_list[mid_index - 1]) / 2
			    if length % 2 == 0
			    else sorted_list[mid_index]
			)
def     UpperCamelCase_(			)->						List[Any]:
			import doctest

			doctest.testmod()


if __name__ == "__main__":
						main()


