


import unittest

from parameterized import parameterized

from transformers import LlamaConfig, 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 LlamaForCausalLM, LlamaForSequenceClassification, LlamaModel, LlamaTokenizer






class _lowerCamelCase:
       def __init__(      self,   lowerCamelCase,   lowerCamelCase=13,   lowerCamelCase=7,   lowerCamelCase=True,   lowerCamelCase=True,   lowerCamelCase=False,   lowerCamelCase=True,   lowerCamelCase=99,   lowerCamelCase=32,   lowerCamelCase=5,   lowerCamelCase=4,   lowerCamelCase=37,   lowerCamelCase="gelu",   lowerCamelCase=0.1,   lowerCamelCase=0.1,   lowerCamelCase=5_12,   lowerCamelCase=16,   lowerCamelCase=2,   lowerCamelCase=0.0_2,   lowerCamelCase=3,   lowerCamelCase=4,   lowerCamelCase=None,   ) ->     Union[str, Any]:




           """simple docstring"""

           _lowercase :							Tuple   	=	parent
           _lowercase :							Tuple   	=	batch_size
           _lowercase :							int   	=	seq_length
           _lowercase :							str   	=	is_training
           _lowercase :							Any   	=	use_input_mask
           _lowercase :							Any   	=	use_token_type_ids
           _lowercase :							str   	=	use_labels
           _lowercase :							str   	=	vocab_size
           _lowercase :							Dict   	=	hidden_size
           _lowercase :							Any   	=	num_hidden_layers
           _lowercase :							Optional[int]   	=	num_attention_heads
           _lowercase :							Optional[int]   	=	intermediate_size
           _lowercase :							Dict   	=	hidden_act
           _lowercase :							Optional[Any]   	=	hidden_dropout_prob
           _lowercase :							Tuple   	=	attention_probs_dropout_prob
           _lowercase :							str   	=	max_position_embeddings
           _lowercase :							List[str]   	=	type_vocab_size
           _lowercase :							List[str]   	=	type_sequence_label_size
           _lowercase :							Any   	=	initializer_range
           _lowercase :							Optional[int]   	=	num_labels
           _lowercase :							str   	=	num_choices
           _lowercase :							Dict   	=	scope
       def     UpperCamelCase  (      self) ->     List[str]:




           """simple docstring"""

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

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

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

           _lowercase :							List[Any]   	=	None
           _lowercase :							Optional[Any]   	=	None
           _lowercase :							Any   	=	None
           if self.use_labels:
               _lowercase :							List[Any]   	=	ids_tensor([self.batch_size],   self.type_sequence_label_size)
               _lowercase :							Tuple   	=	ids_tensor([self.batch_size, self.seq_length],   self.num_labels)
               _lowercase :							int   	=	ids_tensor([self.batch_size],   self.num_choices)

           _lowercase :							Any   	=	self.get_config()

           return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
       def     UpperCamelCase  (      self) ->     Tuple:




           """simple docstring"""

           return LlamaConfig(
               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=UpperCAmelCase__,   initializer_range=self.initializer_range,   )
       def     UpperCamelCase  (      self,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase) ->     Tuple:




           """simple docstring"""

           _lowercase :							Union[str, Any]   	=	LlamaModel(config=UpperCAmelCase__)
           model.to(UpperCAmelCase__)
           model.eval()
           _lowercase :							Optional[int]   	=	model(UpperCAmelCase__,   attention_mask=UpperCAmelCase__)
           _lowercase :							Optional[int]   	=	model(UpperCAmelCase__)
           self.parent.assertEqual(result.last_hidden_state.shape,   (self.batch_size, self.seq_length, self.hidden_size))
       def     UpperCamelCase  (      self,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   ) ->     Union[str, Any]:




           """simple docstring"""

           _lowercase :							Optional[int]   	=	True
           _lowercase :							List[Any]   	=	LlamaModel(UpperCAmelCase__)
           model.to(UpperCAmelCase__)
           model.eval()
           _lowercase :							Optional[Any]   	=	model(
               UpperCAmelCase__,   attention_mask=UpperCAmelCase__,   encoder_hidden_states=UpperCAmelCase__,   encoder_attention_mask=UpperCAmelCase__,   )
           _lowercase :							Optional[int]   	=	model(
               UpperCAmelCase__,   attention_mask=UpperCAmelCase__,   encoder_hidden_states=UpperCAmelCase__,   )
           _lowercase :							List[str]   	=	model(UpperCAmelCase__,   attention_mask=UpperCAmelCase__)
           self.parent.assertEqual(result.last_hidden_state.shape,   (self.batch_size, self.seq_length, self.hidden_size))
       def     UpperCamelCase  (      self,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   ) ->     Optional[Any]:




           """simple docstring"""

           _lowercase :							List[str]   	=	LlamaForCausalLM(config=UpperCAmelCase__)
           model.to(UpperCAmelCase__)
           model.eval()
           _lowercase :							Any   	=	model(UpperCAmelCase__,   attention_mask=UpperCAmelCase__,   labels=UpperCAmelCase__)
           self.parent.assertEqual(result.logits.shape,   (self.batch_size, self.seq_length, self.vocab_size))
       def     UpperCamelCase  (      self,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   ) ->     List[str]:




           """simple docstring"""

           _lowercase :							str   	=	True
           _lowercase :							Optional[int]   	=	True
           _lowercase :							Optional[int]   	=	LlamaForCausalLM(config=UpperCAmelCase__)
           model.to(UpperCAmelCase__)
           model.eval()

           # first forward pass
           _lowercase :							str   	=	model(
               UpperCAmelCase__,   attention_mask=UpperCAmelCase__,   encoder_hidden_states=UpperCAmelCase__,   encoder_attention_mask=UpperCAmelCase__,   use_cache=UpperCAmelCase__,   )
           _lowercase :							int   	=	outputs.past_key_values

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

           # append to next input_ids and
           _lowercase :							Union[str, Any]   	=	torch.cat([input_ids, next_tokens],   dim=-1)
           _lowercase :							List[Any]   	=	torch.cat([input_mask, next_mask],   dim=-1)

           _lowercase :							List[Any]   	=	model(
               UpperCAmelCase__,   attention_mask=UpperCAmelCase__,   encoder_hidden_states=UpperCAmelCase__,   encoder_attention_mask=UpperCAmelCase__,   output_hidden_states=UpperCAmelCase__,   )['''hidden_states'''][0]
           _lowercase :							int   	=	model(
               UpperCAmelCase__,   attention_mask=UpperCAmelCase__,   encoder_hidden_states=UpperCAmelCase__,   encoder_attention_mask=UpperCAmelCase__,   past_key_values=UpperCAmelCase__,   output_hidden_states=UpperCAmelCase__,   )['''hidden_states'''][0]

           # select random slice
           _lowercase :							List[str]   	=	ids_tensor((1,),   output_from_past.shape[-1]).item()
           _lowercase :							Tuple   	=	output_from_no_past[:, -3:, random_slice_idx].detach()
           _lowercase :							int   	=	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(UpperCAmelCase__,   UpperCAmelCase__,   atol=1E-3))




       def     UpperCamelCase  (      self) ->     Tuple:




           """simple docstring"""

           _lowercase :							Any   	=	self.prepare_config_and_inputs()
           (
               _lowercase	
           ) :							Tuple   	=	config_and_inputs
           _lowercase :							Dict   	=	{'''input_ids''': input_ids, '''attention_mask''': input_mask}
           return config, inputs_dict






@require_torch
class _lowerCamelCase(		_a,				_a,				_a,				unittest.TestCase     ):
       lowercase_				:			Optional[Any]									=    (LlamaModel, LlamaForCausalLM, LlamaForSequenceClassification) if is_torch_available() else ()
       lowercase_				:			Any									=    (LlamaForCausalLM,) if is_torch_available() else ()
       lowercase_				:			Union[str, Any]									=    (
           {
               'feature-extraction': LlamaModel,
               'text-classification': LlamaForSequenceClassification,
               'text-generation': LlamaForCausalLM,
               'zero-shot': LlamaForSequenceClassification,
           }
           if is_torch_available()
           else {}
       )
       lowercase_				:			List[str]									=    False
       lowercase_				:			Tuple									=    False
       def     UpperCamelCase  (      self) ->     Optional[int]:




           """simple docstring"""

           _lowercase :							Dict   	=	LlamaModelTester(self)
           _lowercase :							Optional[int]   	=	ConfigTester(self,   config_class=UpperCAmelCase__,   hidden_size=37)
       def     UpperCamelCase  (      self) ->     int:




           """simple docstring"""

           self.config_tester.run_common_tests()
       def     UpperCamelCase  (      self) ->     List[str]:




           """simple docstring"""

           _lowercase :							Any   	=	self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*UpperCAmelCase__)
       def     UpperCamelCase  (      self) ->     Dict:




           """simple docstring"""

           _lowercase :							Optional[int]   	=	self.model_tester.prepare_config_and_inputs()
           for type in ["absolute", "relative_key", "relative_key_query"]:
               _lowercase :							Union[str, Any]   	=	type
               self.model_tester.create_and_check_model(*UpperCAmelCase__)
       def     UpperCamelCase  (      self) ->     List[str]:




           """simple docstring"""

           _lowercase :							Optional[Any]   	=	self.model_tester.prepare_config_and_inputs_for_common()
           _lowercase :							List[str]   	=	3
           _lowercase :							Dict   	=	input_dict['''input_ids''']
           _lowercase :							int   	=	input_ids.ne(1).to(UpperCAmelCase__)
           _lowercase :							List[Any]   	=	ids_tensor([self.model_tester.batch_size],   self.model_tester.type_sequence_label_size)
           _lowercase :							Dict   	=	LlamaForSequenceClassification(UpperCAmelCase__)
           model.to(UpperCAmelCase__)
           model.eval()
           _lowercase :							Union[str, Any]   	=	model(UpperCAmelCase__,   attention_mask=UpperCAmelCase__,   labels=UpperCAmelCase__)
           self.assertEqual(result.logits.shape,   (self.model_tester.batch_size, self.model_tester.num_labels))
       def     UpperCamelCase  (      self) ->     Optional[Any]:




           """simple docstring"""

           _lowercase :							List[Any]   	=	self.model_tester.prepare_config_and_inputs_for_common()
           _lowercase :							List[Any]   	=	3
           _lowercase :							Any   	=	'''single_label_classification'''
           _lowercase :							Optional[int]   	=	input_dict['''input_ids''']
           _lowercase :							Dict   	=	input_ids.ne(1).to(UpperCAmelCase__)
           _lowercase :							int   	=	ids_tensor([self.model_tester.batch_size],   self.model_tester.type_sequence_label_size)
           _lowercase :							int   	=	LlamaForSequenceClassification(UpperCAmelCase__)
           model.to(UpperCAmelCase__)
           model.eval()
           _lowercase :							str   	=	model(UpperCAmelCase__,   attention_mask=UpperCAmelCase__,   labels=UpperCAmelCase__)
           self.assertEqual(result.logits.shape,   (self.model_tester.batch_size, self.model_tester.num_labels))
       def     UpperCamelCase  (      self) ->     List[Any]:




           """simple docstring"""

           _lowercase :							Dict   	=	self.model_tester.prepare_config_and_inputs_for_common()
           _lowercase :							Tuple   	=	3
           _lowercase :							Dict   	=	'''multi_label_classification'''
           _lowercase :							Optional[int]   	=	input_dict['''input_ids''']
           _lowercase :							Optional[Any]   	=	input_ids.ne(1).to(UpperCAmelCase__)
           _lowercase :							Tuple   	=	ids_tensor(
               [self.model_tester.batch_size, config.num_labels],   self.model_tester.type_sequence_label_size).to(torch.float)
           _lowercase :							Dict   	=	LlamaForSequenceClassification(UpperCAmelCase__)
           model.to(UpperCAmelCase__)
           model.eval()
           _lowercase :							Union[str, Any]   	=	model(UpperCAmelCase__,   attention_mask=UpperCAmelCase__,   labels=UpperCAmelCase__)
           self.assertEqual(result.logits.shape,   (self.model_tester.batch_size, self.model_tester.num_labels))
       @unittest.skip('LLaMA buffers include complex numbers, which breaks this test')
       def     UpperCamelCase  (      self) ->     str:




           """simple docstring"""

           pass




       @parameterized.expand([('linear',), ('dynamic',)])
       def     UpperCamelCase  (      self,   lowerCamelCase) ->     Optional[int]:




           """simple docstring"""

           _lowercase :							Optional[int]   	=	self.model_tester.prepare_config_and_inputs_for_common()
           _lowercase :							List[str]   	=	ids_tensor([1, 10],   config.vocab_size)
           _lowercase :							Tuple   	=	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
           _lowercase :							Dict   	=	LlamaModel(UpperCAmelCase__)
           original_model.to(UpperCAmelCase__)
           original_model.eval()
           _lowercase :							Dict   	=	original_model(UpperCAmelCase__).last_hidden_state
           _lowercase :							Union[str, Any]   	=	original_model(UpperCAmelCase__).last_hidden_state

           set_seed(42)  # Fixed seed at init time so the two models get the same random weights
           _lowercase :							List[Any]   	=	{'''type''': scaling_type, '''factor''': 1_0.0}
           _lowercase :							int   	=	LlamaModel(UpperCAmelCase__)
           scaled_model.to(UpperCAmelCase__)
           scaled_model.eval()
           _lowercase :							Optional[Any]   	=	scaled_model(UpperCAmelCase__).last_hidden_state
           _lowercase :							List[Any]   	=	scaled_model(UpperCAmelCase__).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(UpperCAmelCase__,   UpperCAmelCase__,   atol=1E-5))
           else:
               self.assertFalse(torch.allclose(UpperCAmelCase__,   UpperCAmelCase__,   atol=1E-5))

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






@require_torch
class _lowerCamelCase(		unittest.TestCase     ):
       @unittest.skip('Logits are not exactly the same, once we fix the instabalities somehow, will update!')
       @slow
       def     UpperCamelCase  (      self) ->     Optional[int]:




           """simple docstring"""

           _lowercase :							Optional[int]   	=	[1, 3_06, 46_58, 2_78, 65_93, 3_10, 28_34, 3_38]
           _lowercase :							int   	=	LlamaForCausalLM.from_pretrained('meta-llama/Llama-2-7b-hf',   device_map='auto')
           _lowercase :							List[str]   	=	model(torch.tensor([input_ids]))
           # Expected mean on dim = -1
           _lowercase :							Optional[Any]   	=	torch.tensor([[-6.6_5_5_0, -4.1_2_2_7, -4.9_8_5_9, -3.2_4_0_6, 0.8_2_6_2, -3.0_0_3_3, 1.2_9_6_4, -3.3_6_9_9]])
           torch.testing.assert_close(out.mean(-1),   UpperCAmelCase__,   atol=1E-2,   rtol=1E-2)
           # slicing logits[0, 0, 0:30]
           # fmt: off
           _lowercase :							List[Any]   	=	torch.tensor([-1_2.8_2_8_1, -7.4_4_5_3, -0.4_6_3_9, -8.0_6_2_5, -7.2_5_0_0, -8.0_0_0_0, -6.4_8_8_3, -7.7_6_9_5, -7.8_4_3_8, -7.0_3_1_2, -6.2_1_8_8, -7.1_3_2_8, -1.8_4_9_6, 1.9_9_6_1, -8.6_2_5_0, -6.7_2_2_7, -1_2.8_2_8_1, -6.9_4_9_2, -7.0_7_4_2, -7.7_8_5_2, -7.5_8_2_0, -7.9_0_6_2, -6.9_3_7_5, -7.9_8_0_5, -8.3_4_3_8, -8.1_5_6_2, -8.0_4_6_9, -7.6_2_5_0, -7.7_4_2_2, -7.3_3_9_8,])
           # fmt: on
           torch.testing.assert_close(out[0, 0, :30],   UpperCAmelCase__,   atol=1E-5,   rtol=1E-5)
       @unittest.skip('Logits are not exactly the same, once we fix the instabalities somehow, will update!')
       @slow
       def     UpperCamelCase  (      self) ->     Optional[int]:




           """simple docstring"""

           _lowercase :							Optional[Any]   	=	[1, 3_06, 46_58, 2_78, 65_93, 3_10, 28_34, 3_38]
           _lowercase :							List[str]   	=	LlamaForCausalLM.from_pretrained('meta-llama/Llama-2-13b-hf',   device_map='auto')
           _lowercase :							Any   	=	model(torch.tensor(UpperCAmelCase__))
           # Expected mean on dim = -1
           _lowercase :							Dict   	=	torch.tensor([[-2.0_6_2_2, -1.2_7_9_4, -1.1_6_3_8, -0.9_7_8_8, -1.4_6_0_3, -1.0_2_3_8, -1.7_8_9_3, -1.4_4_1_1]])
           torch.testing.assert_close(out.mean(-1),   UpperCAmelCase__,   atol=1E-2,   rtol=1E-2)
           # slicing logits[0, 0, 0:30]
           # fmt: off
           _lowercase :							List[Any]   	=	torch.tensor([-8.1_4_0_6, -8.0_5_4_7, 2.7_4_6_1, -1.2_3_4_4, -0.1_4_4_8, -1.8_2_6_2, -1.0_0_2_0, -1.8_1_5_4, -1.6_8_9_5, -1.8_5_1_6, -2.3_5_7_4, -0.9_2_7_7, 3.7_5_9_8, 6.5_7_4_2, -1.2_9_9_8, -0.1_1_7_7, -8.1_4_0_6, -2.9_6_8_8, -2.9_1_9_9, -3.1_6_9_9, -3.5_2_5_4, -2.3_5_5_5, -2.7_9_8_8, -3.4_1_4_1, -2.8_2_6_2, -4.5_1_9_5, -3.3_3_7_9, -3.3_1_6_4, -2.7_8_3_2, -3.0_2_7_3])
           # fmt: on
           torch.testing.assert_close(out[0, 0, :30],   UpperCAmelCase__,   atol=1E-5,   rtol=1E-5)
       @unittest.skip('Logits are not exactly the same, once we fix the instabalities somehow, will update!')
       @slow
       def     UpperCamelCase  (      self) ->     Optional[Any]:




           """simple docstring"""

           _lowercase :							Optional[Any]   	=	[1, 3_06, 46_58, 2_78, 65_93, 3_10, 28_34, 3_38]
           _lowercase :							List[str]   	=	LlamaForCausalLM.from_pretrained('meta-llama/Llama-2-13b-chat-hf',   device_map='auto')
           _lowercase :							str   	=	model(torch.tensor(UpperCAmelCase__))
           # Expected mean on dim = -1
           _lowercase :							Optional[int]   	=	torch.tensor([[-0.8_5_6_2, -1.8_5_2_0, -0.7_5_5_1, -0.4_1_6_2, -1.5_1_6_1, -1.2_0_3_8, -2.4_8_2_3, -2.3_2_5_4]])
           torch.testing.assert_close(out.mean(-1),   UpperCAmelCase__,   atol=1E-2,   rtol=1E-2)
           # slicing logits[0, 0, 0:30]
           # fmt: off
           _lowercase :							Optional[Any]   	=	torch.tensor([-2.2_2_2_7, 4.8_8_2_8, 0.9_0_2_3, -0.4_5_7_8, -0.7_8_7_1, -0.1_0_3_3, -0.6_2_2_1, -0.5_7_8_6, -0.7_8_0_3, -1.0_6_7_4, -1.2_9_2_0, -0.1_5_7_0, 0.8_0_0_8, 2.0_7_2_3, -0.9_4_9_7, 0.2_7_7_1, -2.2_2_2_7, -0.7_6_1_2, -1.4_3_4_6, -1.2_0_6_1, -1.6_4_2_6, -0.3_0_0_0, -0.7_1_3_9, -1.1_9_3_4, -1.8_6_9_1, -1.6_9_7_3, -1.5_9_4_7, -1.2_7_0_5, -0.3_5_2_3, -0.5_5_1_3])
           # fmt: on
           torch.testing.assert_close(out.mean(-1),   UpperCAmelCase__,   atol=1E-2,   rtol=1E-2)
       @unittest.skip(
           'Logits are not exactly the same, once we fix the instabalities somehow, will update! Also it is gonna be a `too_slow` test')
       @slow
       def     UpperCamelCase  (      self) ->     int:




           """simple docstring"""

           _lowercase :							List[Any]   	=	[1, 3_06, 46_58, 2_78, 65_93, 3_10, 28_34, 3_38]
           _lowercase :							List[Any]   	=	LlamaForCausalLM.from_pretrained('meta-llama/Llama-2-70b-hf',   device_map='auto')
           _lowercase :							Tuple   	=	model(torch.tensor(UpperCAmelCase__))

           _lowercase :							Union[str, Any]   	=	torch.tensor(
               [[-4.2_3_2_7, -3.3_3_6_0, -4.6_6_6_5, -4.7_6_3_1, -1.8_1_8_0, -3.4_1_7_0, -1.4_2_1_1, -3.1_8_1_0]],   dtype=torch.floataa)
           torch.testing.assert_close(out.mean(-1),   UpperCAmelCase__,   atol=1E-2,   rtol=1E-2)
           # fmt: off
           _lowercase :							Optional[int]   	=	torch.tensor([-9.4_9_2_2, -3.9_5_5_1, 1.7_9_9_8, -5.6_7_5_8, -5.1_0_5_5, -5.8_9_8_4, -4.8_3_2_0, -6.8_0_8_6, -6.5_3_9_1, -5.6_1_7_2, -5.5_8_2_0, -5.5_3_5_2, 1.7_8_8_1, 3.6_2_8_9, -6.5_1_1_7, -3.4_7_8_5, -9.5_0_0_0, -6.0_3_5_2, -6.8_1_2_5, -6.0_1_9_5, -6.6_8_3_6, -5.4_7_2_7, -6.2_8_1_2, -6.0_3_9_1, -7.3_3_9_8, -7.4_2_9_7, -7.4_8_4_4, -6.5_8_2_0, -5.8_7_8_9, -5.5_3_1_2])
           # fmt: on
           torch.testing.assert_close(out[0, 0, :30],   UpperCAmelCase__,   atol=1E-5,   rtol=1E-5)




       @unittest.skip('Model is curently gated')
       @slow
       def     UpperCamelCase  (      self) ->     str:




           """simple docstring"""

           _lowercase :							Optional[int]   	=	'''Simply put, the theory of relativity states that 1) the laws of physics are the same everywhere in the universe and 2) the passage of time and the length of objects can vary depending on the observer\'s frame of reference.\n\nThe first part of the theory, that the laws of physics are the same everywhere, is known as the "princi'''
           _lowercase :							List[Any]   	=	'''Simply put, the theory of relativity states that '''
           _lowercase :							int   	=	LlamaTokenizer.from_pretrained('meta-llama/Llama-2-13b-chat-hf')
           _lowercase :							List[str]   	=	tokenizer.encode(UpperCAmelCase__,   return_tensors='pt')
           _lowercase :							List[Any]   	=	LlamaForCausalLM.from_pretrained(
               'meta-llama/Llama-2-13b-chat-hf',   device_map='sequential',   use_safetensors=UpperCAmelCase__)

           # greedy generation outputs
           _lowercase :							str   	=	model.generate(UpperCAmelCase__,   max_new_tokens=64,   top_p=UpperCAmelCase__,   temperature=1,   do_sample=UpperCAmelCase__)
           _lowercase :							List[str]   	=	tokenizer.decode(generated_ids[0],   skip_special_tokens=UpperCAmelCase__)
           self.assertEqual(UpperCAmelCase__,   UpperCAmelCase__)






# this script reports modified .py files under the desired list of top-level sub-dirs passed as a list of arguments, e.g.:
#   python ./utils/get_modified_files.py utils src tests examples
#
# it uses git to find the forking point and which files were modified - i.e. files not under git won't be considered
# since the output of this script is fed into Makefile commands it doesn't print a newline after the results

import re
import subprocess
import sys


SCREAMING_SNAKE_CASE :   List[Any]							      =				subprocess.check_output("git merge-base main HEAD".split()).decode("utf-8")
SCREAMING_SNAKE_CASE :   Optional[int]							      =				(
    subprocess.check_output(F"git diff --diff-filter=d --name-only {fork_point_sha}".split()).decode("utf-8").split()
)

SCREAMING_SNAKE_CASE :   Any							      =				"|".join(sys.argv[1:])
SCREAMING_SNAKE_CASE :   Union[str, Any]							      =				re.compile(rF"^({joined_dirs}).*?\.py$")

SCREAMING_SNAKE_CASE :   List[Any]							      =				[x for x in modified_files if regex.match(x)]
print(" ".join(relevant_modified_files), end="")


