






"""simple docstring"""



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


							def __init__(      self   :    Dict      ,     snake_case   :    Tuple				):
													'''simple docstring'''





													A__    :	str			=	parent
													A__    :	List[Any]			=	13
													A__    :	Optional[int]			=	7
													A__    :	Any			=	True
													A__    :	Union[str, Any]			=	True
													A__    :	Union[str, Any]			=	True
													A__    :	Optional[Any]			=	True
													A__    :	int			=	True
													A__    :	Any			=	99
													A__    :	List[str]			=	32
													A__    :	Tuple			=	4
													A__    :	List[str]			=	2
													A__    :	List[Any]			=	4
													A__    :	Any			=	37
													A__    :	str			=	'gelu'
													A__    :	Optional[Any]			=	0.1
													A__    :	Tuple			=	0.1
													A__    :	List[str]			=	512
													A__    :	Any			=	16
													A__    :	Union[str, Any]			=	2
													A__    :	str			=	0.02
													A__    :	Optional[Any]			=	3
													A__    :	Dict			=	4
													A__    :	Optional[Any]			=	None
													A__    :	Any			=	self.vocab_size - 1
													A__    :	int			=	self.vocab_size - 1
													A__    :	Dict			=	self.vocab_size - 1


							def     _UpperCamelCase							(      self   :    List[Any]				):
													'''simple docstring'''





													A__    :	Optional[int]			=	ids_tensor([self.batch_size, self.seq_length]      ,     self.vocab_size				)

													A__    :	Dict			=	None
													if self.use_input_mask:
																			A__    :	int			=	random_attention_mask([self.batch_size, self.seq_length]				)

													A__    :	List[Any]			=	None
													if self.use_token_type_ids:
																			A__    :	Union[str, Any]			=	ids_tensor([self.batch_size, self.seq_length]      ,     self.type_vocab_size				)

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

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

													A__    :	List[Any]			=	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      ,     )

													A__    :	Union[str, Any]			=	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     _UpperCamelCase							(      self   :    Dict      ,     snake_case   :    Tuple      ,     snake_case   :    Union[str, Any]      ,     snake_case   :    Optional[int]      ,     snake_case   :    Union[str, Any]      ,     snake_case   :    Dict      ,     *snake_case   :    int				):
													'''simple docstring'''





													A__    :	Any			=	TFGPTJModel(config=snake_case				)
													A__    :	List[str]			=	{
													    'input_ids': input_ids,
													    'attention_mask': input_mask,
													    'token_type_ids': token_type_ids,
													}
													A__    :	List[Any]			=	model(snake_case				)

													A__    :	Tuple			=	[input_ids, None, input_mask]  # None is the input for 'past'
													A__    :	int			=	model(snake_case				)

													A__    :	Union[str, Any]			=	model(snake_case				)

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


							def     _UpperCamelCase							(      self   :    Optional[Any]      ,     snake_case   :    Tuple      ,     snake_case   :    str      ,     snake_case   :    int      ,     snake_case   :    Optional[int]      ,     snake_case   :    Dict      ,     *snake_case   :    Optional[int]				):
													'''simple docstring'''





													A__    :	List[Any]			=	TFGPTJModel(config=snake_case				)

													# first forward pass
													A__    :	Tuple			=	model(snake_case      ,     token_type_ids=snake_case      ,     use_cache=snake_case				)
													A__    :	str			=	model(snake_case      ,     token_type_ids=snake_case				)
													A__    :	Optional[int]			=	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				)

													A__    :	Tuple			=	outputs.to_tuple()

													# create hypothetical next token and extent to next_input_ids
													A__    :	List[str]			=	ids_tensor((self.batch_size, 1)      ,     config.vocab_size				)
													A__    :	int			=	ids_tensor([self.batch_size, 1]      ,     self.type_vocab_size				)

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

													A__    :	int			=	model(snake_case      ,     token_type_ids=snake_case				)['last_hidden_state']
													A__    :	Union[str, Any]			=	model(snake_case      ,     token_type_ids=snake_case      ,     past_key_values=snake_case				)[
													    'last_hidden_state'
													]

													# select random slice
													A__    :	List[str]			=	int(ids_tensor((1,)      ,     shape_list(snake_case				)[-1]				)				)
													A__    :	int			=	output_from_no_past[:, -1, random_slice_idx]
													A__    :	Optional[Any]			=	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     _UpperCamelCase							(      self   :    Any      ,     snake_case   :    List[str]      ,     snake_case   :    List[Any]      ,     snake_case   :    Tuple      ,     snake_case   :    Dict      ,     snake_case   :    Optional[Any]      ,     *snake_case   :    List[Any]				):
													'''simple docstring'''





													A__    :	Dict			=	TFGPTJModel(config=snake_case				)

													# create attention mask
													A__    :	Any			=	self.seq_length // 2
													A__    :	Dict			=	tf.ones((self.batch_size, half_seq_length)      ,     dtype=tf.intaa				)
													A__    :	Union[str, Any]			=	tf.zeros((self.batch_size, self.seq_length - half_seq_length)      ,     dtype=tf.intaa				)
													A__    :	Optional[Any]			=	tf.concat([attn_mask_begin, attn_mask_end]      ,     axis=1				)

													# first forward pass
													A__    :	int			=	model(snake_case      ,     attention_mask=snake_case				).to_tuple()

													# create hypothetical next token and extent to next_input_ids
													A__    :	Optional[int]			=	ids_tensor((self.batch_size, 1)      ,     config.vocab_size				)

													# change a random masked slice from input_ids
													A__    :	str			=	ids_tensor((1,)      ,     snake_case				).numpy() + 1
													A__    :	List[Any]			=	ids_tensor((self.batch_size, self.seq_length)      ,     config.vocab_size				)
													A__    :	Optional[int]			=	tf.range(self.seq_length				) == (self.seq_length - random_seq_idx_to_change)
													A__    :	int			=	tf.transpose(
													    tf.broadcast_to(tf.expand_dims(snake_case      ,     -1				)      ,     (self.seq_length, self.batch_size)				)				)
													A__    :	Optional[int]			=	tf.where(snake_case      ,     snake_case      ,     snake_case				)

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

													# get two different outputs
													A__    :	Optional[int]			=	model(snake_case      ,     attention_mask=snake_case				)['last_hidden_state']
													A__    :	List[Any]			=	model(snake_case      ,     past_key_values=snake_case      ,     attention_mask=snake_case				)[
													    'last_hidden_state'
													]

													# select random slice
													A__    :	int			=	int(ids_tensor((1,)      ,     shape_list(snake_case				)[-1]				)				)
													A__    :	List[str]			=	output_from_no_past[:, -1, random_slice_idx]
													A__    :	str			=	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     _UpperCamelCase							(      self   :    int      ,     snake_case   :    Tuple      ,     snake_case   :    List[Any]      ,     snake_case   :    str      ,     snake_case   :    Dict      ,     snake_case   :    List[Any]      ,     *snake_case   :    Dict				):
													'''simple docstring'''





													A__    :	Dict			=	TFGPTJModel(config=snake_case				)

													A__    :	str			=	input_ids[:1, :]
													A__    :	Dict			=	input_mask[:1, :]
													A__    :	Optional[Any]			=	token_type_ids[:1, :]
													A__    :	Dict			=	1

													# first forward pass
													A__    :	Optional[int]			=	model(snake_case      ,     attention_mask=snake_case      ,     token_type_ids=snake_case      ,     use_cache=snake_case				)

													A__    :	Dict			=	outputs.to_tuple()

													# create hypothetical next token and extent to next_input_ids
													A__    :	Dict			=	ids_tensor((self.batch_size, 3)      ,     config.vocab_size				)
													A__    :	str			=	ids_tensor((self.batch_size, 3)      ,     2				)
													A__    :	int			=	ids_tensor((self.batch_size, 3)      ,     self.type_vocab_size				)

													# append to next input_ids and token_type_ids
													A__    :	Optional[Any]			=	tf.concat([input_ids, next_tokens]      ,     axis=-1				)
													A__    :	Optional[Any]			=	tf.concat([input_mask, next_attn_mask]      ,     axis=-1				)
													A__    :	int			=	tf.concat([token_type_ids, next_token_types]      ,     axis=-1				)

													A__    :	Any			=	model(
													    snake_case      ,     token_type_ids=snake_case      ,     attention_mask=snake_case				)['last_hidden_state']
													A__    :	int			=	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
													A__    :	Dict			=	int(ids_tensor((1,)      ,     shape_list(snake_case				)[-1]				)				)
													A__    :	Optional[int]			=	output_from_no_past[:, -3:, random_slice_idx]
													A__    :	Tuple			=	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     _UpperCamelCase							(      self   :    Union[str, Any]      ,     snake_case   :    List[Any]      ,     snake_case   :    Union[str, Any]      ,     snake_case   :    List[Any]      ,     snake_case   :    Any      ,     snake_case   :    Dict      ,     *snake_case   :    List[str]				):
													'''simple docstring'''





													A__    :	List[Any]			=	TFGPTJForCausalLM(config=snake_case				)
													A__    :	List[Any]			=	{
													    'input_ids': input_ids,
													    'attention_mask': input_mask,
													    'token_type_ids': token_type_ids,
													}
													A__    :	int			=	model(snake_case				)
													self.parent.assertEqual(result.logits.shape      ,     (self.batch_size, self.seq_length, self.vocab_size)				)


							def     _UpperCamelCase							(      self   :    Dict				):
													'''simple docstring'''





													A__    :	Optional[Any]			=	self.prepare_config_and_inputs()

													(
													    A__					
													)    :	Tuple			=	config_and_inputs

													A__    :	Dict			=	{
													    'input_ids': input_ids,
													    'token_type_ids': token_type_ids,
													    'attention_mask': input_mask,
													}
													return config, inputs_dict






@require_tf
class 				__SCREAMING_SNAKE_CASE    (					UpperCamelCase							,		UpperCamelCase							,		UpperCamelCase							,		unittest.TestCase		):
							snake_case_  =				(
							    (TFGPTJForCausalLM, TFGPTJForSequenceClassification, TFGPTJForQuestionAnswering, TFGPTJModel)
							    if is_tf_available()
							    else ()
							)

							snake_case_  =				(TFGPTJForCausalLM,) if is_tf_available() else ()
							snake_case_  =				(
							    {
							        'feature-extraction': TFGPTJModel,
							        'question-answering': TFGPTJForQuestionAnswering,
							        'text-classification': TFGPTJForSequenceClassification,
							        'text-generation': TFGPTJForCausalLM,
							        'zero-shot': TFGPTJForSequenceClassification,
							    }
							    if is_tf_available()
							    else {}
							)
							snake_case_  =				False
							snake_case_  =				False
							snake_case_  =				False
							snake_case_  =				False


							def     _UpperCamelCase							(      self   :    Any      ,     snake_case   :    str      ,     snake_case   :    Dict      ,     snake_case   :    Optional[Any]      ,     snake_case   :    Union[str, Any]      ,     snake_case   :    Union[str, Any]				):
													'''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     _UpperCamelCase							(      self   :    Any				):
													'''simple docstring'''





													A__    :	List[Any]			=	TFGPTJModelTester(self				)
													A__    :	Tuple			=	ConfigTester(self      ,     config_class=snake_case      ,     n_embd=37				)


							def     _UpperCamelCase							(      self   :    Any				):
													'''simple docstring'''





													self.config_tester.run_common_tests()


							def     _UpperCamelCase							(      self   :    int				):
													'''simple docstring'''





													A__    :	Union[str, Any]			=	self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_gptj_model(*snake_case				)


							def     _UpperCamelCase							(      self   :    List[Any]				):
													'''simple docstring'''





													A__    :	Dict			=	self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_gptj_model_past(*snake_case				)


							def     _UpperCamelCase							(      self   :    int				):
													'''simple docstring'''





													A__    :	int			=	self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_gptj_model_attention_mask_past(*snake_case				)


							def     _UpperCamelCase							(      self   :    List[str]				):
													'''simple docstring'''





													A__    :	Optional[int]			=	self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_gptj_model_past_large_inputs(*snake_case				)


							def     _UpperCamelCase							(      self   :    str				):
													'''simple docstring'''





													A__    :	int			=	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     _UpperCamelCase							(      self   :    Any				):
													'''simple docstring'''





													A__    :	Optional[int]			=	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     _UpperCamelCase							(      self   :    Union[str, Any]				):
													'''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 				__SCREAMING_SNAKE_CASE    (					unittest.TestCase		):


							def     _UpperCamelCase							(      self   :    List[str]				):
													'''simple docstring'''





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


							def     _UpperCamelCase							(      self   :    Any				):
													'''simple docstring'''





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

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

													A__    :	str			=	'Today is a nice day and I’m going to go for a walk. I’'
													self.assertEqual(snake_case      ,     snake_case				)


							def     _UpperCamelCase							(      self   :    Tuple				):
													'''simple docstring'''





													A__    :	List[Any]			=	TFGPTJForCausalLM.from_pretrained("""EleutherAI/gpt-j-6B"""      ,     revision="""float16"""      ,     from_pt=snake_case				)
													A__    :	Union[str, Any]			=	AutoTokenizer.from_pretrained("""EleutherAI/gpt-j-6B"""      ,     revision="""float16"""				)

													A__    :	List[Any]			=	'left'

													# Define PAD Token = EOS Token = 50256
													A__    :	List[str]			=	tokenizer.eos_token
													A__    :	List[Any]			=	model.config.eos_token_id

													# use different length sentences to test batching
													A__    :	Union[str, Any]			=	[
													    'Hello, my dog is a little',
													    'Today, I',
													]
													A__    :	Any			=	[
													    '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     _UpperCamelCase							(      self   :    Optional[Any]				):
													'''simple docstring'''





													A__    :	Optional[int]			=	self._get_beam_search_test_objects()

													A__    :	List[str]			=	tokenizer(snake_case      ,     return_tensors="""tf"""      ,     padding=snake_case				)
													A__    :	Any			=	model.generate(**snake_case      ,     do_sample=snake_case      ,     num_beams=2				)
													A__    :	Any			=	tokenizer.batch_decode(snake_case      ,     skip_special_tokens=snake_case				)
													self.assertListEqual(snake_case      ,     snake_case				)


							def     _UpperCamelCase							(      self   :    str				):
													'''simple docstring'''





													A__    :	str			=	self._get_beam_search_test_objects()

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


							def     _UpperCamelCase							(      self   :    str				):
													'''simple docstring'''





													A__    :	Any			=	self._get_beam_search_test_objects()

													A__    :	List[Any]			=	tokenizer(snake_case      ,     return_tensors="""tf"""      ,     padding=snake_case				)
													A__    :	Union[str, Any]			=	tf.function(model.generate      ,     jit_compile=snake_case				)
													A__    :	Tuple			=	xla_generate(**snake_case      ,     do_sample=snake_case      ,     num_beams=2				)
													A__    :	Tuple			=	tokenizer.batch_decode(snake_case      ,     skip_special_tokens=snake_case				)
													self.assertListEqual(snake_case      ,     snake_case				)













'''simple docstring'''


from __future__ import annotations




def       A							(      _UpperCAmelCase   :				list[int]						,_UpperCAmelCase   :				int					)  ->				int:


  '''simple docstring'''




  __lowerCAmelCase     ,					__lowerCAmelCase		:    Dict			     =  0, len(_UpperCAmelCase					) - 1
  while start_ind <= end_ind:
    if array[start_ind] == search_item:
      return start_ind
    elif array[end_ind] == search_item:
      return end_ind
    else:
      start_ind += 1
      end_ind -= 1
    # returns -1 if search_item is not found in array
  return -1


if __name__ == "__main__":
    print(double_linear_search(list(range(1_00)), 40))





