


'''simple docstring'''


import unittest

from parameterized import parameterized

from transformers import AutoTokenizer, GPTNeoXConfig, is_torch_available, set_seed
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
				import torch

				from transformers import (
				    GPTNeoXForCausalLM,
				    GPTNeoXForQuestionAnswering,
				    GPTNeoXForSequenceClassification,
				    GPTNeoXForTokenClassification,
				    GPTNeoXModel,
				)





class        lowercase__    :





							'''simple docstring'''


							def __init__(       self       ,   __snake_case       ,   __snake_case=13       ,   __snake_case=7       ,   __snake_case=True       ,   __snake_case=True       ,   __snake_case=True       ,   __snake_case=True       ,   __snake_case=99       ,   __snake_case=64       ,   __snake_case=5       ,   __snake_case=4       ,   __snake_case=37       ,   __snake_case="gelu"       ,   __snake_case=0.1       ,   __snake_case=0.1       ,   __snake_case=512       ,   __snake_case=16       ,   __snake_case=2       ,   __snake_case=0.02       ,   __snake_case=3       ,   __snake_case=4       ,   __snake_case=None       ,   ):
											_SCREAMING_SNAKE_CASE					:			Optional[Any]							= parent
											_SCREAMING_SNAKE_CASE					:			List[str]							= batch_size
											_SCREAMING_SNAKE_CASE					:			List[Any]							= seq_length
											_SCREAMING_SNAKE_CASE					:			Any							= is_training
											_SCREAMING_SNAKE_CASE					:			Optional[int]							= use_input_mask
											_SCREAMING_SNAKE_CASE					:			List[str]							= use_token_type_ids
											_SCREAMING_SNAKE_CASE					:			List[Any]							= use_labels
											_SCREAMING_SNAKE_CASE					:			List[str]							= vocab_size
											_SCREAMING_SNAKE_CASE					:			List[str]							= hidden_size
											_SCREAMING_SNAKE_CASE					:			List[str]							= num_hidden_layers
											_SCREAMING_SNAKE_CASE					:			List[str]							= num_attention_heads
											_SCREAMING_SNAKE_CASE					:			Optional[Any]							= intermediate_size
											_SCREAMING_SNAKE_CASE					:			Any							= hidden_act
											_SCREAMING_SNAKE_CASE					:			List[Any]							= hidden_dropout_prob
											_SCREAMING_SNAKE_CASE					:			Optional[Any]							= attention_probs_dropout_prob
											_SCREAMING_SNAKE_CASE					:			Optional[int]							= max_position_embeddings
											_SCREAMING_SNAKE_CASE					:			Any							= type_vocab_size
											_SCREAMING_SNAKE_CASE					:			Optional[Any]							= type_sequence_label_size
											_SCREAMING_SNAKE_CASE					:			Optional[int]							= initializer_range
											_SCREAMING_SNAKE_CASE					:			str							= num_labels
											_SCREAMING_SNAKE_CASE					:			Optional[int]							= num_choices
											_SCREAMING_SNAKE_CASE					:			Any							= scope
											_SCREAMING_SNAKE_CASE					:			Optional[int]							= vocab_size - 1






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE					:			Any							= ids_tensor([self.batch_size, self.seq_length]       ,   self.vocab_size    )

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

											_SCREAMING_SNAKE_CASE					:			List[str]							= None
											if self.use_labels:
															_SCREAMING_SNAKE_CASE					:			Any							= ids_tensor([self.batch_size, self.seq_length]       ,   self.num_labels    )

											_SCREAMING_SNAKE_CASE					:			Any							= self.get_config()

											return config, input_ids, input_mask, token_labels






							def UpperCAmelCase_      (       self    ):
											return GPTNeoXConfig(
											    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       ,   is_decoder=__snake_case       ,   initializer_range=self.initializer_range       ,   pad_token_id=self.pad_token_id       ,   )






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE					:			Optional[Any]							= self.prepare_config_and_inputs()

											_SCREAMING_SNAKE_CASE					:			List[str]							= True

											return config, input_ids, input_mask, token_labels






							def UpperCAmelCase_      (       self       ,   __snake_case       ,   __snake_case       ,   __snake_case    ):
											_SCREAMING_SNAKE_CASE					:			Any							= GPTNeoXModel(config=__snake_case    )
											model.to(__snake_case    )
											model.eval()
											_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= model(__snake_case       ,   attention_mask=__snake_case    )
											_SCREAMING_SNAKE_CASE					:			Tuple							= model(__snake_case    )
											self.parent.assertEqual(result.last_hidden_state.shape       ,   (self.batch_size, self.seq_length, self.hidden_size)    )






							def UpperCAmelCase_      (       self       ,   __snake_case       ,   __snake_case       ,   __snake_case    ):
											_SCREAMING_SNAKE_CASE					:			str							= True
											_SCREAMING_SNAKE_CASE					:			List[Any]							= GPTNeoXModel(__snake_case    )
											model.to(__snake_case    )
											model.eval()
											_SCREAMING_SNAKE_CASE					:			Any							= model(__snake_case       ,   attention_mask=__snake_case    )
											self.parent.assertEqual(result.last_hidden_state.shape       ,   (self.batch_size, self.seq_length, self.hidden_size)    )






							def UpperCAmelCase_      (       self       ,   __snake_case       ,   __snake_case       ,   __snake_case       ,   __snake_case    ):
											_SCREAMING_SNAKE_CASE					:			Optional[Any]							= GPTNeoXForCausalLM(config=__snake_case    )
											model.to(__snake_case    )
											model.eval()
											_SCREAMING_SNAKE_CASE					:			Optional[int]							= model(__snake_case       ,   attention_mask=__snake_case       ,   labels=__snake_case    )
											self.parent.assertEqual(result.logits.shape       ,   (self.batch_size, self.seq_length, self.vocab_size)    )






							def UpperCAmelCase_      (       self       ,   __snake_case       ,   __snake_case       ,   __snake_case       ,   __snake_case    ):
											_SCREAMING_SNAKE_CASE					:			Any							= self.num_labels
											_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= GPTNeoXForQuestionAnswering(__snake_case    )
											model.to(__snake_case    )
											model.eval()
											_SCREAMING_SNAKE_CASE					:			int							= model(__snake_case       ,   attention_mask=__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       ,   __snake_case       ,   __snake_case       ,   __snake_case       ,   __snake_case    ):
											_SCREAMING_SNAKE_CASE					:			Any							= self.num_labels
											_SCREAMING_SNAKE_CASE					:			Any							= GPTNeoXForSequenceClassification(__snake_case    )
											model.to(__snake_case    )
											model.eval()
											_SCREAMING_SNAKE_CASE					:			int							= ids_tensor([self.batch_size]       ,   self.type_sequence_label_size    )
											_SCREAMING_SNAKE_CASE					:			str							= model(__snake_case       ,   attention_mask=__snake_case       ,   labels=__snake_case    )
											self.parent.assertEqual(result.logits.shape       ,   (self.batch_size, self.num_labels)    )






							def UpperCAmelCase_      (       self       ,   __snake_case       ,   __snake_case       ,   __snake_case       ,   __snake_case    ):
											_SCREAMING_SNAKE_CASE					:			str							= self.num_labels
											_SCREAMING_SNAKE_CASE					:			Optional[int]							= GPTNeoXForTokenClassification(__snake_case    )
											model.to(__snake_case    )
											model.eval()
											_SCREAMING_SNAKE_CASE					:			Dict							= model(__snake_case       ,   attention_mask=__snake_case       ,   labels=__snake_case    )
											self.parent.assertEqual(result.logits.shape       ,   (self.batch_size, self.seq_length, self.num_labels)    )






							def UpperCAmelCase_      (       self       ,   __snake_case       ,   __snake_case       ,   __snake_case    ):
											_SCREAMING_SNAKE_CASE					:			str							= True
											_SCREAMING_SNAKE_CASE					:			Any							= GPTNeoXForCausalLM(config=__snake_case    )
											model.to(__snake_case    )
											model.eval()

											# first forward pass
											_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= model(__snake_case       ,   attention_mask=__snake_case       ,   use_cache=__snake_case    )
											_SCREAMING_SNAKE_CASE					:			Dict							= outputs.past_key_values

											# create hypothetical multiple next token and extent to next_input_ids
											_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= ids_tensor((self.batch_size, 3)       ,   config.vocab_size    )
											_SCREAMING_SNAKE_CASE					:			List[Any]							= ids_tensor((self.batch_size, 3)       ,   vocab_size=2    )

											# append to next input_ids and
											_SCREAMING_SNAKE_CASE					:			Any							= torch.cat([input_ids, next_tokens]       ,   dim=-1    )
											_SCREAMING_SNAKE_CASE					:			Tuple							= torch.cat([input_mask, next_mask]       ,   dim=-1    )

											_SCREAMING_SNAKE_CASE					:			int							= model(__snake_case       ,   attention_mask=__snake_case       ,   output_hidden_states=__snake_case    )
											_SCREAMING_SNAKE_CASE					:			Tuple							= output_from_no_past["""hidden_states"""][0]
											_SCREAMING_SNAKE_CASE					:			Optional[int]							= model(
											    __snake_case       ,   attention_mask=__snake_case       ,   past_key_values=__snake_case       ,   output_hidden_states=__snake_case       ,   )["""hidden_states"""][0]

											# select random slice
											_SCREAMING_SNAKE_CASE					:			str							= ids_tensor((1,)       ,   output_from_past.shape[-1]    ).item()
											_SCREAMING_SNAKE_CASE					:			str							= output_from_no_past[:, -3:, random_slice_idx].detach()
											_SCREAMING_SNAKE_CASE					:			Tuple							= output_from_past[:, :, random_slice_idx].detach()

											self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]    )

											# test that outputs are equal for slice
											self.parent.assertTrue(torch.allclose(__snake_case       ,   __snake_case       ,   atol=1e-3    )    )






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE					:			Optional[int]							= self.prepare_config_and_inputs()
											_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE					:			Optional[Any]							= config_and_inputs
											_SCREAMING_SNAKE_CASE					:			List[Any]							= {"""input_ids""": input_ids, """attention_mask""": input_mask}
											return config, inputs_dict





@require_torch
class        lowercase__    (		_snake_case	,	_snake_case	,	_snake_case	,	unittest.TestCase   ):





							'''simple docstring'''


							A_				: Union[str, Any]       =    (
							    (
							        GPTNeoXModel,
							        GPTNeoXForCausalLM,
							        GPTNeoXForQuestionAnswering,
							        GPTNeoXForSequenceClassification,
							        GPTNeoXForTokenClassification,
							    )
							    if is_torch_available()
							    else ()
							)
							A_				: Dict       =    (GPTNeoXForCausalLM,) if is_torch_available() else ()
							A_				: Dict       =    (
							    {
							        """feature-extraction""": GPTNeoXModel,
							        """question-answering""": GPTNeoXForQuestionAnswering,
							        """text-classification""": GPTNeoXForSequenceClassification,
							        """text-generation""": GPTNeoXForCausalLM,
							        """token-classification""": GPTNeoXForTokenClassification,
							        """zero-shot""": GPTNeoXForSequenceClassification,
							    }
							    if is_torch_available()
							    else {}
							)
							A_				: str       =    False
							A_				: Optional[int]       =    False
							A_				: Optional[int]       =    False
							A_				: Union[str, Any]       =    False






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE					:			str							= GPTNeoXModelTester(self    )
											_SCREAMING_SNAKE_CASE					:			int							= ConfigTester(self       ,   config_class=__snake_case       ,   hidden_size=64       ,   num_attention_heads=8    )






							def UpperCAmelCase_      (       self    ):
											self.config_tester.run_common_tests()






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE					:			List[str]							= self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(__snake_case       ,   __snake_case       ,   __snake_case    )






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE					:			List[str]							= self.model_tester.prepare_config_and_inputs_for_decoder()
											self.model_tester.create_and_check_model_as_decoder(__snake_case       ,   __snake_case       ,   __snake_case    )






							def UpperCAmelCase_      (       self    ):
											# This regression test was failing with PyTorch < 1.3
											_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE					:			Optional[int]							= self.model_tester.prepare_config_and_inputs_for_decoder()

											_SCREAMING_SNAKE_CASE					:			Tuple							= None

											self.model_tester.create_and_check_model_as_decoder(__snake_case       ,   __snake_case       ,   __snake_case    )






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE					:			int							= self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_decoder_model_past_large_inputs(__snake_case       ,   __snake_case       ,   __snake_case    )






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE					:			Optional[int]							= self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_causal_lm(*__snake_case    )






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE					:			Dict							= self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_question_answering(*__snake_case    )






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE					:			str							= self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_sequence_classification(*__snake_case    )






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE					:			Tuple							= self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_token_classification(*__snake_case    )






							@unittest.skip(reason="""Feed forward chunking is not implemented"""    )
							def UpperCAmelCase_      (       self    ):
											pass






							@parameterized.expand([("""linear""",), ("""dynamic""",)]    )
							def UpperCAmelCase_      (       self       ,   __snake_case    ):
											_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE					:			str							= self.model_tester.prepare_config_and_inputs_for_common()
											_SCREAMING_SNAKE_CASE					:			Optional[Any]							= ids_tensor([1, 10]       ,   config.vocab_size    )
											_SCREAMING_SNAKE_CASE					:			int							= ids_tensor([1, int(config.max_position_embeddings * 1.5    )]       ,   config.vocab_size    )

											set_seed(42    )  # Fixed seed at init time so the two models get the same random weights
											_SCREAMING_SNAKE_CASE					:			List[str]							= GPTNeoXModel(__snake_case    )
											original_model.to(__snake_case    )
											original_model.eval()
											_SCREAMING_SNAKE_CASE					:			List[str]							= original_model(__snake_case    ).last_hidden_state
											_SCREAMING_SNAKE_CASE					:			Optional[int]							= original_model(__snake_case    ).last_hidden_state

											set_seed(42    )  # Fixed seed at init time so the two models get the same random weights
											_SCREAMING_SNAKE_CASE					:			Optional[int]							= {"""type""": scaling_type, """factor""": 10.0}
											_SCREAMING_SNAKE_CASE					:			Optional[Any]							= GPTNeoXModel(__snake_case    )
											scaled_model.to(__snake_case    )
											scaled_model.eval()
											_SCREAMING_SNAKE_CASE					:			Tuple							= scaled_model(__snake_case    ).last_hidden_state
											_SCREAMING_SNAKE_CASE					:			Optional[int]							= scaled_model(__snake_case    ).last_hidden_state

											# Dynamic scaling does not change the RoPE embeddings until it receives an input longer than the original
											# maximum sequence length, so the outputs for the short input should match.
											if scaling_type == "dynamic":
															self.assertTrue(torch.allclose(__snake_case       ,   __snake_case       ,   atol=1e-5    )    )
											else:
															self.assertFalse(torch.allclose(__snake_case       ,   __snake_case       ,   atol=1e-5    )    )

											# The output should be different for long inputs
											self.assertFalse(torch.allclose(__snake_case       ,   __snake_case       ,   atol=1e-5    )    )





@require_torch
class        lowercase__    (		unittest.TestCase   ):





							'''simple docstring'''


							@slow
							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE					:			Tuple							= AutoTokenizer.from_pretrained("""EleutherAI/pythia-410m-deduped"""    )
											for checkpointing in [True, False]:
															_SCREAMING_SNAKE_CASE					:			Any							= GPTNeoXForCausalLM.from_pretrained("""EleutherAI/pythia-410m-deduped"""    )

															if checkpointing:
																			model.gradient_checkpointing_enable()
															else:
																			model.gradient_checkpointing_disable()
															model.to(__snake_case    )

															_SCREAMING_SNAKE_CASE					:			Tuple							= tokenizer("""My favorite food is"""       ,   return_tensors="""pt"""    ).to(__snake_case    )
															# The hub repo. is updated on 2023-04-04, resulting in poor outputs.
															# See: https://github.com/huggingface/transformers/pull/24193
															_SCREAMING_SNAKE_CASE					:			Optional[Any]							= """My favorite food is a good old-fashioned, old-fashioned, old-fashioned.\n\nI'm not sure"""

															_SCREAMING_SNAKE_CASE					:			int							= model.generate(**__snake_case       ,   do_sample=__snake_case       ,   max_new_tokens=20    )
															_SCREAMING_SNAKE_CASE					:			Dict							= tokenizer.batch_decode(__snake_case    )[0]

															self.assertEqual(__snake_case       ,   __snake_case    )








'''simple docstring'''


from __future__ import annotations







def      snake_case_  (    SCREAMING_SNAKE_CASE__				, SCREAMING_SNAKE_CASE__	):







				"""simple docstring"""





				if len(SCREAMING_SNAKE_CASE__	) <= 1 or n <= 1:
								return

				insert_next(SCREAMING_SNAKE_CASE__				, n - 1	)
				rec_insertion_sort(SCREAMING_SNAKE_CASE__				, n - 1	)







def      snake_case_  (    SCREAMING_SNAKE_CASE__				, SCREAMING_SNAKE_CASE__	):







				"""simple docstring"""





				if index >= len(SCREAMING_SNAKE_CASE__	) or collection[index - 1] <= collection[index]:
								return

				# Swaps adjacent elements since they are not in ascending order
				_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE					:			List[Any]							= (
				    collection[index],
				    collection[index - 1],
				)

				insert_next(SCREAMING_SNAKE_CASE__				, index + 1	)


if __name__ == "__main__":
				UpperCAmelCase_						:  List[str]				  =						input('Enter integers separated by spaces: ')
				UpperCAmelCase_						:  list[int]				  =						[int(num) for num in numbers.split()]
				rec_insertion_sort(number_list, len(number_list))
				print(number_list)




