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

     '''simple docstring'''

     def __init__(					self				,				A_				,				A_=13				,				A_=7				,				A_=True				,				A_=True				,				A_=True				,				A_=True				,				A_=99				,				A_=64				,				A_=5				,				A_=4				,				A_=37				,				A_="gelu"				,				A_=0.1				,				A_=0.1				,				A_=5_12				,				A_=16				,				A_=2				,				A_=0.02				,				A_=3				,				A_=4				,				A_=None				,				) ->				Tuple:






           """simple docstring"""
           _lowerCamelCase			    =				parent
           _lowerCamelCase			    =				batch_size
           _lowerCamelCase			    =				seq_length
           _lowerCamelCase			    =				is_training
           _lowerCamelCase			    =				use_input_mask
           _lowerCamelCase			    =				use_token_type_ids
           _lowerCamelCase			    =				use_labels
           _lowerCamelCase			    =				vocab_size
           _lowerCamelCase			    =				hidden_size
           _lowerCamelCase			    =				num_hidden_layers
           _lowerCamelCase			    =				num_attention_heads
           _lowerCamelCase			    =				intermediate_size
           _lowerCamelCase			    =				hidden_act
           _lowerCamelCase			    =				hidden_dropout_prob
           _lowerCamelCase			    =				attention_probs_dropout_prob
           _lowerCamelCase			    =				max_position_embeddings
           _lowerCamelCase			    =				type_vocab_size
           _lowerCamelCase			    =				type_sequence_label_size
           _lowerCamelCase			    =				initializer_range
           _lowerCamelCase			    =				num_labels
           _lowerCamelCase			    =				num_choices
           _lowerCamelCase			    =				scope
           _lowerCamelCase			    =				vocab_size - 1



     def 		UpperCamelCase_						(					self						) ->				List[Any]:






           """simple docstring"""
           _lowerCamelCase			    =				ids_tensor([self.batch_size, self.seq_length]				,				self.vocab_size						)

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

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

           _lowerCamelCase			    =				self.get_config()

           return config, input_ids, input_mask, token_labels



     def 		UpperCamelCase_						(					self						) ->				Tuple:






           """simple docstring"""
           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=A_				,				initializer_range=self.initializer_range				,				pad_token_id=self.pad_token_id				,				)



     def 		UpperCamelCase_						(					self						) ->				List[Any]:






           """simple docstring"""
           _lowerCamelCase    ,					_lowerCamelCase    ,					_lowerCamelCase    ,					_lowerCamelCase			    =				self.prepare_config_and_inputs()

           _lowerCamelCase			    =				True

           return config, input_ids, input_mask, token_labels



     def 		UpperCamelCase_						(					self				,				A_				,				A_				,				A_						) ->				Optional[int]:






           """simple docstring"""
           _lowerCamelCase			    =				GPTNeoXModel(config=A_						)
           model.to(A_						)
           model.eval()
           _lowerCamelCase			    =				model(A_				,				attention_mask=A_						)
           _lowerCamelCase			    =				model(A_						)
           self.parent.assertEqual(result.last_hidden_state.shape				,				(self.batch_size, self.seq_length, self.hidden_size)						)



     def 		UpperCamelCase_						(					self				,				A_				,				A_				,				A_						) ->				Union[str, Any]:






           """simple docstring"""
           _lowerCamelCase			    =				True
           _lowerCamelCase			    =				GPTNeoXModel(A_						)
           model.to(A_						)
           model.eval()
           _lowerCamelCase			    =				model(A_				,				attention_mask=A_						)
           self.parent.assertEqual(result.last_hidden_state.shape				,				(self.batch_size, self.seq_length, self.hidden_size)						)



     def 		UpperCamelCase_						(					self				,				A_				,				A_				,				A_				,				A_						) ->				List[str]:






           """simple docstring"""
           _lowerCamelCase			    =				GPTNeoXForCausalLM(config=A_						)
           model.to(A_						)
           model.eval()
           _lowerCamelCase			    =				model(A_				,				attention_mask=A_				,				labels=A_						)
           self.parent.assertEqual(result.logits.shape				,				(self.batch_size, self.seq_length, self.vocab_size)						)



     def 		UpperCamelCase_						(					self				,				A_				,				A_				,				A_				,				A_						) ->				str:






           """simple docstring"""
           _lowerCamelCase			    =				self.num_labels
           _lowerCamelCase			    =				GPTNeoXForQuestionAnswering(A_						)
           model.to(A_						)
           model.eval()
           _lowerCamelCase			    =				model(A_				,				attention_mask=A_						)
           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				,				A_				,				A_				,				A_				,				A_						) ->				Dict:






           """simple docstring"""
           _lowerCamelCase			    =				self.num_labels
           _lowerCamelCase			    =				GPTNeoXForSequenceClassification(A_						)
           model.to(A_						)
           model.eval()
           _lowerCamelCase			    =				ids_tensor([self.batch_size]				,				self.type_sequence_label_size						)
           _lowerCamelCase			    =				model(A_				,				attention_mask=A_				,				labels=A_						)
           self.parent.assertEqual(result.logits.shape				,				(self.batch_size, self.num_labels)						)



     def 		UpperCamelCase_						(					self				,				A_				,				A_				,				A_				,				A_						) ->				Optional[Any]:






           """simple docstring"""
           _lowerCamelCase			    =				self.num_labels
           _lowerCamelCase			    =				GPTNeoXForTokenClassification(A_						)
           model.to(A_						)
           model.eval()
           _lowerCamelCase			    =				model(A_				,				attention_mask=A_				,				labels=A_						)
           self.parent.assertEqual(result.logits.shape				,				(self.batch_size, self.seq_length, self.num_labels)						)



     def 		UpperCamelCase_						(					self				,				A_				,				A_				,				A_						) ->				str:






           """simple docstring"""
           _lowerCamelCase			    =				True
           _lowerCamelCase			    =				GPTNeoXForCausalLM(config=A_						)
           model.to(A_						)
           model.eval()

           # first forward pass
           _lowerCamelCase			    =				model(A_				,				attention_mask=A_				,				use_cache=A_						)
           _lowerCamelCase			    =				outputs.past_key_values

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

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

           _lowerCamelCase			    =				model(A_				,				attention_mask=A_				,				output_hidden_states=A_						)
           _lowerCamelCase			    =				output_from_no_past['''hidden_states'''][0]
           _lowerCamelCase			    =				model(
               A_				,				attention_mask=A_				,				past_key_values=A_				,				output_hidden_states=A_				,				)['''hidden_states'''][0]

           # select random slice
           _lowerCamelCase			    =				ids_tensor((1,)				,				output_from_past.shape[-1]						).item()
           _lowerCamelCase			    =				output_from_no_past[:, -3:, random_slice_idx].detach()
           _lowerCamelCase			    =				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(A_				,				A_				,				atol=1E-3						)						)





     def 		UpperCamelCase_						(					self						) ->				Optional[Any]:






           """simple docstring"""
           _lowerCamelCase			    =				self.prepare_config_and_inputs()
           _lowerCamelCase    ,					_lowerCamelCase    ,					_lowerCamelCase    ,					_lowerCamelCase			    =				config_and_inputs
           _lowerCamelCase			    =				{'''input_ids''': input_ids, '''attention_mask''': input_mask}
           return config, inputs_dict





@require_torch
class  UpperCamelCase				( __lowercase   ,  __lowercase   ,  __lowercase   ,  unittest.TestCase ):

     '''simple docstring'''

     A_										=  (
         (
             GPTNeoXModel,
             GPTNeoXForCausalLM,
             GPTNeoXForQuestionAnswering,
             GPTNeoXForSequenceClassification,
             GPTNeoXForTokenClassification,
         )
         if is_torch_available()
         else ()
     )
     A_										=  (GPTNeoXForCausalLM,) if is_torch_available() else ()
     A_										=  (
         {
             'feature-extraction': GPTNeoXModel,
             'question-answering': GPTNeoXForQuestionAnswering,
             'text-classification': GPTNeoXForSequenceClassification,
             'text-generation': GPTNeoXForCausalLM,
             'token-classification': GPTNeoXForTokenClassification,
             'zero-shot': GPTNeoXForSequenceClassification,
         }
         if is_torch_available()
         else {}
     )
     A_										=  False
     A_										=  False
     A_										=  False
     A_										=  False



     def 		UpperCamelCase_						(					self						) ->				Union[str, Any]:






           """simple docstring"""
           _lowerCamelCase			    =				GPTNeoXModelTester(self						)
           _lowerCamelCase			    =				ConfigTester(self				,				config_class=A_				,				hidden_size=64				,				num_attention_heads=8						)



     def 		UpperCamelCase_						(					self						) ->				List[str]:






           """simple docstring"""
           self.config_tester.run_common_tests()



     def 		UpperCamelCase_						(					self						) ->				str:






           """simple docstring"""
           _lowerCamelCase    ,					_lowerCamelCase    ,					_lowerCamelCase    ,					_lowerCamelCase			    =				self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(A_				,				A_				,				A_						)



     def 		UpperCamelCase_						(					self						) ->				int:






           """simple docstring"""
           _lowerCamelCase    ,					_lowerCamelCase    ,					_lowerCamelCase    ,					_lowerCamelCase			    =				self.model_tester.prepare_config_and_inputs_for_decoder()
           self.model_tester.create_and_check_model_as_decoder(A_				,				A_				,				A_						)



     def 		UpperCamelCase_						(					self						) ->				Optional[int]:






           """simple docstring"""
           # This regression test was failing with PyTorch < 1.3
           _lowerCamelCase    ,					_lowerCamelCase    ,					_lowerCamelCase    ,					_lowerCamelCase			    =				self.model_tester.prepare_config_and_inputs_for_decoder()

           _lowerCamelCase			    =				None

           self.model_tester.create_and_check_model_as_decoder(A_				,				A_				,				A_						)



     def 		UpperCamelCase_						(					self						) ->				int:






           """simple docstring"""
           _lowerCamelCase    ,					_lowerCamelCase    ,					_lowerCamelCase    ,					_lowerCamelCase			    =				self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_decoder_model_past_large_inputs(A_				,				A_				,				A_						)



     def 		UpperCamelCase_						(					self						) ->				List[Any]:






           """simple docstring"""
           _lowerCamelCase			    =				self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_causal_lm(*A_						)



     def 		UpperCamelCase_						(					self						) ->				Dict:






           """simple docstring"""
           _lowerCamelCase			    =				self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_question_answering(*A_						)



     def 		UpperCamelCase_						(					self						) ->				Union[str, Any]:






           """simple docstring"""
           _lowerCamelCase			    =				self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_sequence_classification(*A_						)



     def 		UpperCamelCase_						(					self						) ->				Tuple:






           """simple docstring"""
           _lowerCamelCase			    =				self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_token_classification(*A_						)



     @unittest.skip(reason='''Feed forward chunking is not implemented'''						)
     def 		UpperCamelCase_						(					self						) ->				Optional[int]:






           """simple docstring"""
           pass





     @parameterized.expand([('''linear''',), ('''dynamic''',)]						)
     def 		UpperCamelCase_						(					self				,				A_						) ->				Optional[Any]:






           """simple docstring"""
           _lowerCamelCase    ,					_lowerCamelCase			    =				self.model_tester.prepare_config_and_inputs_for_common()
           _lowerCamelCase			    =				ids_tensor([1, 10]				,				config.vocab_size						)
           _lowerCamelCase			    =				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
           _lowerCamelCase			    =				GPTNeoXModel(A_						)
           original_model.to(A_						)
           original_model.eval()
           _lowerCamelCase			    =				original_model(A_						).last_hidden_state
           _lowerCamelCase			    =				original_model(A_						).last_hidden_state

           set_seed(42						)  # Fixed seed at init time so the two models get the same random weights
           _lowerCamelCase			    =				{'''type''': scaling_type, '''factor''': 10.0}
           _lowerCamelCase			    =				GPTNeoXModel(A_						)
           scaled_model.to(A_						)
           scaled_model.eval()
           _lowerCamelCase			    =				scaled_model(A_						).last_hidden_state
           _lowerCamelCase			    =				scaled_model(A_						).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(A_				,				A_				,				atol=1E-5						)						)
           else:
                 self.assertFalse(torch.allclose(A_				,				A_				,				atol=1E-5						)						)

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





@require_torch
class  UpperCamelCase				( unittest.TestCase ):

     '''simple docstring'''

     @slow
     def 		UpperCamelCase_						(					self						) ->				List[str]:






           """simple docstring"""
           _lowerCamelCase			    =				AutoTokenizer.from_pretrained('''EleutherAI/pythia-410m-deduped'''						)
           for checkpointing in [True, False]:
                 _lowerCamelCase			    =				GPTNeoXForCausalLM.from_pretrained('''EleutherAI/pythia-410m-deduped'''						)

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

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

                 _lowerCamelCase			    =				model.generate(**A_				,				do_sample=A_				,				max_new_tokens=20						)
                 _lowerCamelCase			    =				tokenizer.batch_decode(A_						)[0]

                 self.assertEqual(A_				,				A_						)
def       __magic_name__(  __UpperCAmelCase ,						__UpperCAmelCase		)						->    bool:



      '''simple docstring'''

      _lowerCamelCase			    =				len(__UpperCAmelCase		)
      _lowerCamelCase			    =				[[False] * (required_sum + 1) for _ in range(arr_len + 1		)]

      # for each arr value, a sum of zero(0) can be formed by not taking any element
      # hence True/1
      for i in range(arr_len + 1		):
            _lowerCamelCase			    =				True

      # sum is not zero and set is empty then false
      for i in range(1 ,						required_sum + 1		):
            _lowerCamelCase			    =				False

      for i in range(1 ,						arr_len + 1		):
            for j in range(1 ,						required_sum + 1		):
                  if arr[i - 1] > j:
                        _lowerCamelCase			    =				subset[i - 1][j]
                  if arr[i - 1] <= j:
                        _lowerCamelCase			    =				subset[i - 1][j] or subset[i - 1][j - arr[i - 1]]

      return subset[arr_len][required_sum]


if __name__ == "__main__":
     import doctest

     doctest.testmod()