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	:	List[str]  ,  lowercase__	:	Optional[Any]  ,  lowercase__	:	Union[str, Any]=13  ,  lowercase__	:	Any=7  ,  lowercase__	:	Optional[int]=True  ,  lowercase__	:	Any=True  ,  lowercase__	:	List[Any]=False  ,  lowercase__	:	List[Any]=True  ,  lowercase__	:	Any=99  ,  lowercase__	:	int=32  ,  lowercase__	:	List[Any]=5  ,  lowercase__	:	str=4  ,  lowercase__	:	Tuple=37  ,  lowercase__	:	Dict="gelu"  ,  lowercase__	:	int=0.1  ,  lowercase__	:	Optional[Any]=0.1  ,  lowercase__	:	Tuple=5_12  ,  lowercase__	:	Optional[Any]=16  ,  lowercase__	:	Optional[int]=2  ,  lowercase__	:	List[str]=0.0_2  ,  lowercase__	:	List[Any]=3  ,  lowercase__	:	Dict=4  ,  lowercase__	:	Optional[int]=None  ,  ):
										_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





			def   SCREAMING_SNAKE_CASE__     (       self	:	List[str]						):
										_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_token_type_ids:
																	_lowerCAmelCase							=							ids_tensor([self.batch_size, self.seq_length]  ,  self.type_vocab_size						)

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

										_lowerCAmelCase							=							self.get_config()

										return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels





			def   SCREAMING_SNAKE_CASE__     (       self	:	Tuple						):
										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=lowercase__  ,  initializer_range=self.initializer_range  ,  )





			def   SCREAMING_SNAKE_CASE__     (       self	:	Optional[int]  ,  lowercase__	:	Tuple  ,  lowercase__	:	int  ,  lowercase__	:	Tuple  ,  lowercase__	:	List[str]  ,  lowercase__	:	Optional[Any]  ,  lowercase__	:	str  ,  lowercase__	:	str						):
										_lowerCAmelCase							=							LlamaModel(config=lowercase__						)
										model.to(lowercase__						)
										model.eval()
										_lowerCAmelCase							=							model(lowercase__  ,  attention_mask=lowercase__						)
										_lowerCAmelCase							=							model(lowercase__						)
										self.parent.assertEqual(result.last_hidden_state.shape  ,  (self.batch_size, self.seq_length, self.hidden_size)						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	Optional[Any]  ,  lowercase__	:	Optional[Any]  ,  lowercase__	:	int  ,  lowercase__	:	int  ,  lowercase__	:	List[Any]  ,  lowercase__	:	List[Any]  ,  lowercase__	:	str  ,  lowercase__	:	str  ,  lowercase__	:	Optional[int]  ,  lowercase__	:	int  ,  ):
										_lowerCAmelCase							=							True
										_lowerCAmelCase							=							LlamaModel(lowercase__						)
										model.to(lowercase__						)
										model.eval()
										_lowerCAmelCase							=							model(
										    lowercase__  ,  attention_mask=lowercase__  ,  encoder_hidden_states=lowercase__  ,  encoder_attention_mask=lowercase__  ,  )
										_lowerCAmelCase							=							model(
										    lowercase__  ,  attention_mask=lowercase__  ,  encoder_hidden_states=lowercase__  ,  )
										_lowerCAmelCase							=							model(lowercase__  ,  attention_mask=lowercase__						)
										self.parent.assertEqual(result.last_hidden_state.shape  ,  (self.batch_size, self.seq_length, self.hidden_size)						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	List[str]  ,  lowercase__	:	Tuple  ,  lowercase__	:	str  ,  lowercase__	:	Union[str, Any]  ,  lowercase__	:	Optional[int]  ,  lowercase__	:	Optional[Any]  ,  lowercase__	:	Optional[int]  ,  lowercase__	:	str  ,  lowercase__	:	Union[str, Any]  ,  lowercase__	:	int  ,  ):
										_lowerCAmelCase							=							LlamaForCausalLM(config=lowercase__						)
										model.to(lowercase__						)
										model.eval()
										_lowerCAmelCase							=							model(lowercase__  ,  attention_mask=lowercase__  ,  labels=lowercase__						)
										self.parent.assertEqual(result.logits.shape  ,  (self.batch_size, self.seq_length, self.vocab_size)						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	Any  ,  lowercase__	:	Union[str, Any]  ,  lowercase__	:	Dict  ,  lowercase__	:	str  ,  lowercase__	:	str  ,  lowercase__	:	List[Any]  ,  lowercase__	:	Union[str, Any]  ,  lowercase__	:	str  ,  lowercase__	:	List[str]  ,  lowercase__	:	Dict  ,  ):
										_lowerCAmelCase							=							True
										_lowerCAmelCase							=							True
										_lowerCAmelCase							=							LlamaForCausalLM(config=lowercase__						)
										model.to(lowercase__						)
										model.eval()

										# first forward pass
										_lowerCAmelCase							=							model(
										    lowercase__  ,  attention_mask=lowercase__  ,  encoder_hidden_states=lowercase__  ,  encoder_attention_mask=lowercase__  ,  use_cache=lowercase__  ,  )
										_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(
										    lowercase__  ,  attention_mask=lowercase__  ,  encoder_hidden_states=lowercase__  ,  encoder_attention_mask=lowercase__  ,  output_hidden_states=lowercase__  ,  )['hidden_states'][0]
										_lowerCAmelCase							=							model(
										    lowercase__  ,  attention_mask=lowercase__  ,  encoder_hidden_states=lowercase__  ,  encoder_attention_mask=lowercase__  ,  past_key_values=lowercase__  ,  output_hidden_states=lowercase__  ,  )['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(lowercase__  ,  lowercase__  ,  atol=1e-3						)						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	Dict						):
										_lowerCAmelCase							=							self.prepare_config_and_inputs()
										(
										    (
										    _lowerCAmelCase
										)			,		(
										    _lowerCAmelCase
										)			,		(
										    _lowerCAmelCase
										)			,		(
										    _lowerCAmelCase
										)			,		(
										    _lowerCAmelCase
										)			,		(
										    _lowerCAmelCase
										)			,		(
										    _lowerCAmelCase
										)			,		
										)							=							config_and_inputs
										_lowerCAmelCase							=							{'input_ids': input_ids, 'attention_mask': input_mask}
										return config, inputs_dict







@require_torch
class        lowerCamelCase__				(   UpperCAmelCase       ,UpperCAmelCase       ,UpperCAmelCase       ,unittest.TestCase				):
			UpperCamelCase__    							=(LlamaModel, LlamaForCausalLM, LlamaForSequenceClassification) if is_torch_available() else ()
			UpperCamelCase__    							=(LlamaForCausalLM,) if is_torch_available() else ()
			UpperCamelCase__    							=(
			    {
			        "feature-extraction": LlamaModel,
			        "text-classification": LlamaForSequenceClassification,
			        "text-generation": LlamaForCausalLM,
			        "zero-shot": LlamaForSequenceClassification,
			    }
			    if is_torch_available()
			    else {}
			)
			UpperCamelCase__    							=False
			UpperCamelCase__    							=False





			def   SCREAMING_SNAKE_CASE__     (       self	:	str						):
										_lowerCAmelCase							=							LlamaModelTester(self						)
										_lowerCAmelCase							=							ConfigTester(self  ,  config_class=lowercase__  ,  hidden_size=37						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	Dict						):
										self.config_tester.run_common_tests()





			def   SCREAMING_SNAKE_CASE__     (       self	:	Optional[int]						):
										_lowerCAmelCase							=							self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*lowercase__						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	List[str]						):
										_lowerCAmelCase							=							self.model_tester.prepare_config_and_inputs()
										for type in ["absolute", "relative_key", "relative_key_query"]:
																	_lowerCAmelCase							=							type
																	self.model_tester.create_and_check_model(*lowercase__						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	Optional[int]						):
										_lowerCAmelCase			,		_lowerCAmelCase							=							self.model_tester.prepare_config_and_inputs_for_common()
										_lowerCAmelCase							=							3
										_lowerCAmelCase							=							input_dict['input_ids']
										_lowerCAmelCase							=							input_ids.ne(1						).to(lowercase__						)
										_lowerCAmelCase							=							ids_tensor([self.model_tester.batch_size]  ,  self.model_tester.type_sequence_label_size						)
										_lowerCAmelCase							=							LlamaForSequenceClassification(lowercase__						)
										model.to(lowercase__						)
										model.eval()
										_lowerCAmelCase							=							model(lowercase__  ,  attention_mask=lowercase__  ,  labels=lowercase__						)
										self.assertEqual(result.logits.shape  ,  (self.model_tester.batch_size, self.model_tester.num_labels)						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	List[str]						):
										_lowerCAmelCase			,		_lowerCAmelCase							=							self.model_tester.prepare_config_and_inputs_for_common()
										_lowerCAmelCase							=							3
										_lowerCAmelCase							=							'single_label_classification'
										_lowerCAmelCase							=							input_dict['input_ids']
										_lowerCAmelCase							=							input_ids.ne(1						).to(lowercase__						)
										_lowerCAmelCase							=							ids_tensor([self.model_tester.batch_size]  ,  self.model_tester.type_sequence_label_size						)
										_lowerCAmelCase							=							LlamaForSequenceClassification(lowercase__						)
										model.to(lowercase__						)
										model.eval()
										_lowerCAmelCase							=							model(lowercase__  ,  attention_mask=lowercase__  ,  labels=lowercase__						)
										self.assertEqual(result.logits.shape  ,  (self.model_tester.batch_size, self.model_tester.num_labels)						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	List[Any]						):
										_lowerCAmelCase			,		_lowerCAmelCase							=							self.model_tester.prepare_config_and_inputs_for_common()
										_lowerCAmelCase							=							3
										_lowerCAmelCase							=							'multi_label_classification'
										_lowerCAmelCase							=							input_dict['input_ids']
										_lowerCAmelCase							=							input_ids.ne(1						).to(lowercase__						)
										_lowerCAmelCase							=							ids_tensor(
										    [self.model_tester.batch_size, config.num_labels]  ,  self.model_tester.type_sequence_label_size						).to(torch.float						)
										_lowerCAmelCase							=							LlamaForSequenceClassification(lowercase__						)
										model.to(lowercase__						)
										model.eval()
										_lowerCAmelCase							=							model(lowercase__  ,  attention_mask=lowercase__  ,  labels=lowercase__						)
										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   SCREAMING_SNAKE_CASE__     (       self	:	str						):
										pass





			@parameterized.expand([('linear',), ('dynamic',)]						)
			def   SCREAMING_SNAKE_CASE__     (       self	:	Optional[int]  ,  lowercase__	:	Union[str, Any]						):
										_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							=							LlamaModel(lowercase__						)
										original_model.to(lowercase__						)
										original_model.eval()
										_lowerCAmelCase							=							original_model(lowercase__						).last_hidden_state
										_lowerCAmelCase							=							original_model(lowercase__						).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': 1_0.0}
										_lowerCAmelCase							=							LlamaModel(lowercase__						)
										scaled_model.to(lowercase__						)
										scaled_model.eval()
										_lowerCAmelCase							=							scaled_model(lowercase__						).last_hidden_state
										_lowerCAmelCase							=							scaled_model(lowercase__						).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(lowercase__  ,  lowercase__  ,  atol=1e-5						)						)
										else:
																	self.assertFalse(torch.allclose(lowercase__  ,  lowercase__  ,  atol=1e-5						)						)

										# The output should be different for long inputs
										self.assertFalse(torch.allclose(lowercase__  ,  lowercase__  ,  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   SCREAMING_SNAKE_CASE__     (       self	:	Tuple						):
										_lowerCAmelCase							=							[1, 3_06, 46_58, 2_78, 65_93, 3_10, 28_34, 3_38]
										_lowerCAmelCase							=							LlamaForCausalLM.from_pretrained('meta-llama/Llama-2-7b-hf'  ,  device_map='auto'						)
										_lowerCAmelCase							=							model(torch.tensor([input_ids]						)						)
										# Expected mean on dim = -1
										_lowerCAmelCase							=							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						)  ,  lowercase__  ,  atol=1e-2  ,  rtol=1e-2						)
										# slicing logits[0, 0, 0:30]
										# fmt: off
										_lowerCAmelCase							=							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]  ,  lowercase__  ,  atol=1e-5  ,  rtol=1e-5						)





			@unittest.skip('Logits are not exactly the same, once we fix the instabalities somehow, will update!'						)
			@slow
			def   SCREAMING_SNAKE_CASE__     (       self	:	int						):
										_lowerCAmelCase							=							[1, 3_06, 46_58, 2_78, 65_93, 3_10, 28_34, 3_38]
										_lowerCAmelCase							=							LlamaForCausalLM.from_pretrained('meta-llama/Llama-2-13b-hf'  ,  device_map='auto'						)
										_lowerCAmelCase							=							model(torch.tensor(lowercase__						)						)
										# Expected mean on dim = -1
										_lowerCAmelCase							=							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						)  ,  lowercase__  ,  atol=1e-2  ,  rtol=1e-2						)
										# slicing logits[0, 0, 0:30]
										# fmt: off
										_lowerCAmelCase							=							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]  ,  lowercase__  ,  atol=1e-5  ,  rtol=1e-5						)





			@unittest.skip('Logits are not exactly the same, once we fix the instabalities somehow, will update!'						)
			@slow
			def   SCREAMING_SNAKE_CASE__     (       self	:	Tuple						):
										_lowerCAmelCase							=							[1, 3_06, 46_58, 2_78, 65_93, 3_10, 28_34, 3_38]
										_lowerCAmelCase							=							LlamaForCausalLM.from_pretrained('meta-llama/Llama-2-13b-chat-hf'  ,  device_map='auto'						)
										_lowerCAmelCase							=							model(torch.tensor(lowercase__						)						)
										# Expected mean on dim = -1
										_lowerCAmelCase							=							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						)  ,  lowercase__  ,  atol=1e-2  ,  rtol=1e-2						)
										# slicing logits[0, 0, 0:30]
										# fmt: off
										_lowerCAmelCase							=							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						)  ,  lowercase__  ,  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   SCREAMING_SNAKE_CASE__     (       self	:	List[Any]						):
										_lowerCAmelCase							=							[1, 3_06, 46_58, 2_78, 65_93, 3_10, 28_34, 3_38]
										_lowerCAmelCase							=							LlamaForCausalLM.from_pretrained('meta-llama/Llama-2-70b-hf'  ,  device_map='auto'						)
										_lowerCAmelCase							=							model(torch.tensor(lowercase__						)						)

										_lowerCAmelCase							=							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						)  ,  lowercase__  ,  atol=1e-2  ,  rtol=1e-2						)
										# fmt: off
										_lowerCAmelCase							=							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]  ,  lowercase__  ,  atol=1e-5  ,  rtol=1e-5						)





			@unittest.skip('Model is curently gated'						)
			@slow
			def   SCREAMING_SNAKE_CASE__     (       self	:	Tuple						):
										_lowerCAmelCase							=							'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'
										_lowerCAmelCase							=							'Simply put, the theory of relativity states that '
										_lowerCAmelCase							=							LlamaTokenizer.from_pretrained('meta-llama/Llama-2-13b-chat-hf'						)
										_lowerCAmelCase							=							tokenizer.encode(lowercase__  ,  return_tensors='pt'						)
										_lowerCAmelCase							=							LlamaForCausalLM.from_pretrained(
										    'meta-llama/Llama-2-13b-chat-hf'  ,  device_map='sequential'  ,  use_safetensors=lowercase__						)

										# greedy generation outputs
										_lowerCAmelCase							=							model.generate(lowercase__  ,  max_new_tokens=64  ,  top_p=lowercase__  ,  temperature=1  ,  do_sample=lowercase__						)
										_lowerCAmelCase							=							tokenizer.decode(generated_ids[0]  ,  skip_special_tokens=lowercase__						)
										self.assertEqual(lowercase__  ,  lowercase__						)







import functools






def _lowerCamelCase  (		snake_case     , snake_case  ):

							# Validation
							if not isinstance(snake_case     , snake_case  ) or not all(isinstance(snake_case     , snake_case  ) for day in days  ):
														raise ValueError('The parameter days should be a list of integers'  )

							if len(snake_case  ) != 3 or not all(isinstance(snake_case     , snake_case  ) for cost in costs  ):
														raise ValueError('The parameter costs should be a list of three integers'  )

							if len(snake_case  ) == 0:
														return 0

							if min(snake_case  ) <= 0:
														raise ValueError('All days elements should be greater than 0'  )

							if max(snake_case  ) >= 366:
														raise ValueError('All days elements should be less than 366'  )

							_lowerCAmelCase							=							set(snake_case  )

							@functools.cache
							def dynamic_programming(snake_case  ) -> int:
														if index > 365:
																					return 0

														if index not in days_set:
																					return dynamic_programming(index + 1  )

														return min(
														    costs[0] + dynamic_programming(index + 1  )     , costs[1] + dynamic_programming(index + 7  )     , costs[2] + dynamic_programming(index + 30  )     , )

							return dynamic_programming(1  )


if __name__ == "__main__":
				import doctest

				doctest.testmod()






