


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

							def __init__(							self:	List[str]    ,						UpperCamelCase_:	Optional[int]    ,						UpperCamelCase_:	Optional[Any]=13    ,						UpperCamelCase_:	List[Any]=7    ,						UpperCamelCase_:	int=True    ,						UpperCamelCase_:	Optional[Any]=True    ,						UpperCamelCase_:	Optional[Any]=False    ,						UpperCamelCase_:	int=True    ,						UpperCamelCase_:	Optional[int]=99    ,						UpperCamelCase_:	Optional[Any]=32    ,						UpperCamelCase_:	List[str]=5    ,						UpperCamelCase_:	Tuple=4    ,						UpperCamelCase_:	Dict=37    ,						UpperCamelCase_:	Optional[Any]="gelu"    ,						UpperCamelCase_:	int=0.1    ,						UpperCamelCase_:	int=0.1    ,						UpperCamelCase_:	Dict=512    ,						UpperCamelCase_:	List[str]=16    ,						UpperCamelCase_:	Tuple=2    ,						UpperCamelCase_:	List[Any]=0.02    ,						UpperCamelCase_:	str=3    ,						UpperCamelCase_:	str=4    ,						UpperCamelCase_:	List[str]=None    ,						)			->   int:





									"""simple docstring"""







									lowercase__            =      parent
									lowercase__            =      batch_size
									lowercase__            =      seq_length
									lowercase__            =      is_training
									lowercase__            =      use_input_mask
									lowercase__            =      use_token_type_ids
									lowercase__            =      use_labels
									lowercase__            =      vocab_size
									lowercase__            =      hidden_size
									lowercase__            =      num_hidden_layers
									lowercase__            =      num_attention_heads
									lowercase__            =      intermediate_size
									lowercase__            =      hidden_act
									lowercase__            =      hidden_dropout_prob
									lowercase__            =      attention_probs_dropout_prob
									lowercase__            =      max_position_embeddings
									lowercase__            =      type_vocab_size
									lowercase__            =      type_sequence_label_size
									lowercase__            =      initializer_range
									lowercase__            =      num_labels
									lowercase__            =      num_choices
									lowercase__            =      scope

							def       lowerCamelCase_ (							self:	Union[str, Any]							)			->   Optional[int]:





									"""simple docstring"""







									lowercase__            =      ids_tensor([self.batch_size, self.seq_length]    ,						self.vocab_size							)

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

									lowercase__            =      None
									if self.use_token_type_ids:
											lowercase__            =      ids_tensor([self.batch_size, self.seq_length]    ,						self.type_vocab_size							)

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

									lowercase__            =      self.get_config()

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

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





									"""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       lowerCamelCase_ (							self:	Tuple    ,						UpperCamelCase_:	int    ,						UpperCamelCase_:	List[str]    ,						UpperCamelCase_:	Optional[Any]    ,						UpperCamelCase_:	Any    ,						UpperCamelCase_:	Optional[Any]    ,						UpperCamelCase_:	Any    ,						UpperCamelCase_:	str							)			->   Optional[int]:





									"""simple docstring"""







									lowercase__            =      LlamaModel(config=UpperCamelCase_							)
									model.to(UpperCamelCase_							)
									model.eval()
									lowercase__            =      model(UpperCamelCase_    ,						attention_mask=UpperCamelCase_							)
									lowercase__            =      model(UpperCamelCase_							)
									self.parent.assertEqual(result.last_hidden_state.shape    ,						(self.batch_size, self.seq_length, self.hidden_size)							)

							def       lowerCamelCase_ (							self:	Optional[int]    ,						UpperCamelCase_:	Optional[Any]    ,						UpperCamelCase_:	Tuple    ,						UpperCamelCase_:	int    ,						UpperCamelCase_:	Optional[int]    ,						UpperCamelCase_:	int    ,						UpperCamelCase_:	List[str]    ,						UpperCamelCase_:	List[str]    ,						UpperCamelCase_:	Any    ,						UpperCamelCase_:	Union[str, Any]    ,						)			->   Union[str, Any]:





									"""simple docstring"""







									lowercase__            =      True
									lowercase__            =      LlamaModel(UpperCamelCase_							)
									model.to(UpperCamelCase_							)
									model.eval()
									lowercase__            =      model(
									    UpperCamelCase_    ,						attention_mask=UpperCamelCase_    ,						encoder_hidden_states=UpperCamelCase_    ,						encoder_attention_mask=UpperCamelCase_    ,						)
									lowercase__            =      model(
									    UpperCamelCase_    ,						attention_mask=UpperCamelCase_    ,						encoder_hidden_states=UpperCamelCase_    ,						)
									lowercase__            =      model(UpperCamelCase_    ,						attention_mask=UpperCamelCase_							)
									self.parent.assertEqual(result.last_hidden_state.shape    ,						(self.batch_size, self.seq_length, self.hidden_size)							)

							def       lowerCamelCase_ (							self:	Optional[int]    ,						UpperCamelCase_:	Any    ,						UpperCamelCase_:	Dict    ,						UpperCamelCase_:	Union[str, Any]    ,						UpperCamelCase_:	str    ,						UpperCamelCase_:	List[str]    ,						UpperCamelCase_:	Tuple    ,						UpperCamelCase_:	Dict    ,						UpperCamelCase_:	Union[str, Any]    ,						UpperCamelCase_:	Tuple    ,						)			->   Dict:





									"""simple docstring"""







									lowercase__            =      LlamaForCausalLM(config=UpperCamelCase_							)
									model.to(UpperCamelCase_							)
									model.eval()
									lowercase__            =      model(UpperCamelCase_    ,						attention_mask=UpperCamelCase_    ,						labels=UpperCamelCase_							)
									self.parent.assertEqual(result.logits.shape    ,						(self.batch_size, self.seq_length, self.vocab_size)							)

							def       lowerCamelCase_ (							self:	List[str]    ,						UpperCamelCase_:	Optional[int]    ,						UpperCamelCase_:	Dict    ,						UpperCamelCase_:	Union[str, Any]    ,						UpperCamelCase_:	List[str]    ,						UpperCamelCase_:	int    ,						UpperCamelCase_:	List[str]    ,						UpperCamelCase_:	Any    ,						UpperCamelCase_:	Dict    ,						UpperCamelCase_:	Optional[int]    ,						)			->   Any:





									"""simple docstring"""







									lowercase__            =      True
									lowercase__            =      True
									lowercase__            =      LlamaForCausalLM(config=UpperCamelCase_							)
									model.to(UpperCamelCase_							)
									model.eval()

									# first forward pass
									lowercase__            =      model(
									    UpperCamelCase_    ,						attention_mask=UpperCamelCase_    ,						encoder_hidden_states=UpperCamelCase_    ,						encoder_attention_mask=UpperCamelCase_    ,						use_cache=UpperCamelCase_    ,						)
									lowercase__            =      outputs.past_key_values

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

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

									lowercase__            =      model(
									    UpperCamelCase_    ,						attention_mask=UpperCamelCase_    ,						encoder_hidden_states=UpperCamelCase_    ,						encoder_attention_mask=UpperCamelCase_    ,						output_hidden_states=UpperCamelCase_    ,						)['''hidden_states'''][0]
									lowercase__            =      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__            =      ids_tensor((1,)    ,						output_from_past.shape[-1]							).item()
									lowercase__            =      output_from_no_past[:, -3:, random_slice_idx].detach()
									lowercase__            =      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       lowerCamelCase_ (							self:	Any							)			->   str:





									"""simple docstring"""







									lowercase__            =      self.prepare_config_and_inputs()
									(
									    (
									    lowercase__
									)     ,		(
									    lowercase__
									)     ,		(
									    lowercase__
									)     ,		(
									    lowercase__
									)     ,		(
									    lowercase__
									)     ,		(
									    lowercase__
									)     ,		(
									    lowercase__
									)     ,		
									)            =      config_and_inputs
									lowercase__            =      {'''input_ids''': input_ids, '''attention_mask''': input_mask}
									return config, inputs_dict


@require_torch
class        _a							(			UpperCamelCase__     ,	UpperCamelCase__     ,	UpperCamelCase__     ,	unittest.TestCase			):
							_lowercase	:			str        = (LlamaModel, LlamaForCausalLM, LlamaForSequenceClassification) if is_torch_available() else ()
							_lowercase	:			Any        = (LlamaForCausalLM,) if is_torch_available() else ()
							_lowercase	:			List[str]        = (
							    {
							        '''feature-extraction''': LlamaModel,
							        '''text-classification''': LlamaForSequenceClassification,
							        '''text-generation''': LlamaForCausalLM,
							        '''zero-shot''': LlamaForSequenceClassification,
							    }
							    if is_torch_available()
							    else {}
							)
							_lowercase	:			Optional[Any]        = False
							_lowercase	:			str        = False

							def       lowerCamelCase_ (							self:	Any							)			->   Any:





									"""simple docstring"""







									lowercase__            =      LlamaModelTester(self							)
									lowercase__            =      ConfigTester(self    ,						config_class=UpperCamelCase_    ,						hidden_size=37							)

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





									"""simple docstring"""







									self.config_tester.run_common_tests()

							def       lowerCamelCase_ (							self:	List[Any]							)			->   Tuple:





									"""simple docstring"""







									lowercase__            =      self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*UpperCamelCase_							)

							def       lowerCamelCase_ (							self:	Dict							)			->   Any:





									"""simple docstring"""







									lowercase__            =      self.model_tester.prepare_config_and_inputs()
									for type in ["absolute", "relative_key", "relative_key_query"]:
											lowercase__            =      type
											self.model_tester.create_and_check_model(*UpperCamelCase_							)

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





									"""simple docstring"""







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

							def       lowerCamelCase_ (							self:	Any							)			->   Any:





									"""simple docstring"""







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

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





									"""simple docstring"""







									lowercase__     ,		lowercase__            =      self.model_tester.prepare_config_and_inputs_for_common()
									lowercase__            =      3
									lowercase__            =      '''multi_label_classification'''
									lowercase__            =      input_dict['''input_ids''']
									lowercase__            =      input_ids.ne(1							).to(UpperCamelCase_							)
									lowercase__            =      ids_tensor(
									    [self.model_tester.batch_size, config.num_labels]    ,						self.model_tester.type_sequence_label_size							).to(torch.float							)
									lowercase__            =      LlamaForSequenceClassification(UpperCamelCase_							)
									model.to(UpperCamelCase_							)
									model.eval()
									lowercase__            =      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       lowerCamelCase_ (							self:	Optional[int]							)			->   Dict:





									"""simple docstring"""







									pass


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





									"""simple docstring"""







									lowercase__     ,		lowercase__            =      self.model_tester.prepare_config_and_inputs_for_common()
									lowercase__            =      ids_tensor([1, 10]    ,						config.vocab_size							)
									lowercase__            =      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__            =      LlamaModel(UpperCamelCase_							)
									original_model.to(UpperCamelCase_							)
									original_model.eval()
									lowercase__            =      original_model(UpperCamelCase_							).last_hidden_state
									lowercase__            =      original_model(UpperCamelCase_							).last_hidden_state

									set_seed(42							)  # Fixed seed at init time so the two models get the same random weights
									lowercase__            =      {'''type''': scaling_type, '''factor''': 10.0}
									lowercase__            =      LlamaModel(UpperCamelCase_							)
									scaled_model.to(UpperCamelCase_							)
									scaled_model.eval()
									lowercase__            =      scaled_model(UpperCamelCase_							).last_hidden_state
									lowercase__            =      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        _a							(			unittest.TestCase			):

							@unittest.skip('''Logits are not exactly the same, once we fix the instabalities somehow, will update!'''							)
							@slow
							def       lowerCamelCase_ (							self:	Optional[Any]							)			->   Optional[Any]:





									"""simple docstring"""







									lowercase__            =      [1, 306, 4_658, 278, 6_593, 310, 2_834, 338]
									lowercase__            =      LlamaForCausalLM.from_pretrained('''meta-llama/Llama-2-7b-hf'''    ,						device_map='''auto'''							)
									lowercase__            =      model(torch.tensor([input_ids]							)							)
									# Expected mean on dim = -1
									lowercase__            =      torch.tensor([[-6.6550, -4.1227, -4.9859, -3.2406, 0.8262, -3.0033, 1.2964, -3.3699]]							)
									torch.testing.assert_close(out.mean(-1							)    ,						UpperCamelCase_    ,						atol=1E-2    ,						rtol=1E-2							)
									# slicing logits[0, 0, 0:30]
									# fmt: off
									lowercase__            =      torch.tensor([-12.8281, -7.4453, -0.4639, -8.0625, -7.2500, -8.0000, -6.4883, -7.7695, -7.8438, -7.0312, -6.2188, -7.1328, -1.8496, 1.9961, -8.6250, -6.7227, -12.8281, -6.9492, -7.0742, -7.7852, -7.5820, -7.9062, -6.9375, -7.9805, -8.3438, -8.1562, -8.0469, -7.6250, -7.7422, -7.3398,]							)
									# 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       lowerCamelCase_ (							self:	int							)			->   List[str]:





									"""simple docstring"""







									lowercase__            =      [1, 306, 4_658, 278, 6_593, 310, 2_834, 338]
									lowercase__            =      LlamaForCausalLM.from_pretrained('''meta-llama/Llama-2-13b-hf'''    ,						device_map='''auto'''							)
									lowercase__            =      model(torch.tensor(UpperCamelCase_							)							)
									# Expected mean on dim = -1
									lowercase__            =      torch.tensor([[-2.0622, -1.2794, -1.1638, -0.9788, -1.4603, -1.0238, -1.7893, -1.4411]]							)
									torch.testing.assert_close(out.mean(-1							)    ,						UpperCamelCase_    ,						atol=1E-2    ,						rtol=1E-2							)
									# slicing logits[0, 0, 0:30]
									# fmt: off
									lowercase__            =      torch.tensor([-8.1406, -8.0547, 2.7461, -1.2344, -0.1448, -1.8262, -1.0020, -1.8154, -1.6895, -1.8516, -2.3574, -0.9277, 3.7598, 6.5742, -1.2998, -0.1177, -8.1406, -2.9688, -2.9199, -3.1699, -3.5254, -2.3555, -2.7988, -3.4141, -2.8262, -4.5195, -3.3379, -3.3164, -2.7832, -3.0273]							)
									# 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       lowerCamelCase_ (							self:	List[Any]							)			->   Tuple:





									"""simple docstring"""







									lowercase__            =      [1, 306, 4_658, 278, 6_593, 310, 2_834, 338]
									lowercase__            =      LlamaForCausalLM.from_pretrained('''meta-llama/Llama-2-13b-chat-hf'''    ,						device_map='''auto'''							)
									lowercase__            =      model(torch.tensor(UpperCamelCase_							)							)
									# Expected mean on dim = -1
									lowercase__            =      torch.tensor([[-0.8562, -1.8520, -0.7551, -0.4162, -1.5161, -1.2038, -2.4823, -2.3254]]							)
									torch.testing.assert_close(out.mean(-1							)    ,						UpperCamelCase_    ,						atol=1E-2    ,						rtol=1E-2							)
									# slicing logits[0, 0, 0:30]
									# fmt: off
									lowercase__            =      torch.tensor([-2.2227, 4.8828, 0.9023, -0.4578, -0.7871, -0.1033, -0.6221, -0.5786, -0.7803, -1.0674, -1.2920, -0.1570, 0.8008, 2.0723, -0.9497, 0.2771, -2.2227, -0.7612, -1.4346, -1.2061, -1.6426, -0.3000, -0.7139, -1.1934, -1.8691, -1.6973, -1.5947, -1.2705, -0.3523, -0.5513]							)
									# 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       lowerCamelCase_ (							self:	Tuple							)			->   Dict:





									"""simple docstring"""







									lowercase__            =      [1, 306, 4_658, 278, 6_593, 310, 2_834, 338]
									lowercase__            =      LlamaForCausalLM.from_pretrained('''meta-llama/Llama-2-70b-hf'''    ,						device_map='''auto'''							)
									lowercase__            =      model(torch.tensor(UpperCamelCase_							)							)

									lowercase__            =      torch.tensor(
									    [[-4.2327, -3.3360, -4.6665, -4.7631, -1.8180, -3.4170, -1.4211, -3.1810]]    ,						dtype=torch.floataa							)
									torch.testing.assert_close(out.mean(-1							)    ,						UpperCamelCase_    ,						atol=1E-2    ,						rtol=1E-2							)
									# fmt: off
									lowercase__            =      torch.tensor([-9.4922, -3.9551, 1.7998, -5.6758, -5.1055, -5.8984, -4.8320, -6.8086, -6.5391, -5.6172, -5.5820, -5.5352, 1.7881, 3.6289, -6.5117, -3.4785, -9.5000, -6.0352, -6.8125, -6.0195, -6.6836, -5.4727, -6.2812, -6.0391, -7.3398, -7.4297, -7.4844, -6.5820, -5.8789, -5.5312]							)
									# 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       lowerCamelCase_ (							self:	Any							)			->   Any:





									"""simple docstring"""







									lowercase__            =      '''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__            =      '''Simply put, the theory of relativity states that '''
									lowercase__            =      LlamaTokenizer.from_pretrained('''meta-llama/Llama-2-13b-chat-hf'''							)
									lowercase__            =      tokenizer.encode(UpperCamelCase_    ,						return_tensors='''pt'''							)
									lowercase__            =      LlamaForCausalLM.from_pretrained(
									    '''meta-llama/Llama-2-13b-chat-hf'''    ,						device_map='''sequential'''    ,						use_safetensors=UpperCamelCase_							)

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






import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
			import torch

if is_vision_available():
			from PIL import Image

			from transformers import LevitImageProcessor


class        _a							(			unittest.TestCase			):

							def __init__(							self:	Dict    ,						UpperCamelCase_:	Any    ,						UpperCamelCase_:	Dict=7    ,						UpperCamelCase_:	Optional[int]=3    ,						UpperCamelCase_:	List[Any]=18    ,						UpperCamelCase_:	Dict=30    ,						UpperCamelCase_:	Optional[int]=400    ,						UpperCamelCase_:	Optional[int]=True    ,						UpperCamelCase_:	Union[str, Any]=None    ,						UpperCamelCase_:	List[str]=True    ,						UpperCamelCase_:	Dict=None    ,						UpperCamelCase_:	Optional[int]=True    ,						UpperCamelCase_:	Tuple=[0.5, 0.5, 0.5]    ,						UpperCamelCase_:	List[str]=[0.5, 0.5, 0.5]    ,						)			->   int:





									"""simple docstring"""







									lowercase__            =      size if size is not None else {'''shortest_edge''': 18}
									lowercase__            =      crop_size if crop_size is not None else {'''height''': 18, '''width''': 18}
									lowercase__            =      parent
									lowercase__            =      batch_size
									lowercase__            =      num_channels
									lowercase__            =      image_size
									lowercase__            =      min_resolution
									lowercase__            =      max_resolution
									lowercase__            =      do_resize
									lowercase__            =      size
									lowercase__            =      do_center_crop
									lowercase__            =      crop_size
									lowercase__            =      do_normalize
									lowercase__            =      image_mean
									lowercase__            =      image_std


							def       lowerCamelCase_ (							self:	List[str]							)			->   Optional[Any]:





									"""simple docstring"""







									return {
									    "image_mean": self.image_mean,
									    "image_std": self.image_std,
									    "do_normalize": self.do_normalize,
									    "do_resize": self.do_resize,
									    "do_center_crop": self.do_center_crop,
									    "size": self.size,
									    "crop_size": self.crop_size,
									}


@require_torch
@require_vision
class        _a							(			UpperCamelCase__     ,	unittest.TestCase			):
							_lowercase	:			List[str]        = LevitImageProcessor if is_vision_available() else None

							def       lowerCamelCase_ (							self:	Optional[Any]							)			->   List[str]:





									"""simple docstring"""







									lowercase__            =      LevitImageProcessingTester(self							)

							@property
							def       lowerCamelCase_ (							self:	List[Any]							)			->   Any:





									"""simple docstring"""







									return self.image_processor_tester.prepare_image_processor_dict()

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





									"""simple docstring"""







									lowercase__            =      self.image_processing_class(**self.image_processor_dict							)
									self.assertTrue(hasattr(UpperCamelCase_    ,						'''image_mean'''							)							)
									self.assertTrue(hasattr(UpperCamelCase_    ,						'''image_std'''							)							)
									self.assertTrue(hasattr(UpperCamelCase_    ,						'''do_normalize'''							)							)
									self.assertTrue(hasattr(UpperCamelCase_    ,						'''do_resize'''							)							)
									self.assertTrue(hasattr(UpperCamelCase_    ,						'''do_center_crop'''							)							)
									self.assertTrue(hasattr(UpperCamelCase_    ,						'''size'''							)							)

							def       lowerCamelCase_ (							self:	str							)			->   Tuple:





									"""simple docstring"""







									lowercase__            =      self.image_processing_class.from_dict(self.image_processor_dict							)
									self.assertEqual(image_processor.size    ,						{'''shortest_edge''': 18}							)
									self.assertEqual(image_processor.crop_size    ,						{'''height''': 18, '''width''': 18}							)

									lowercase__            =      self.image_processing_class.from_dict(self.image_processor_dict    ,						size=42    ,						crop_size=84							)
									self.assertEqual(image_processor.size    ,						{'''shortest_edge''': 42}							)
									self.assertEqual(image_processor.crop_size    ,						{'''height''': 84, '''width''': 84}							)

							def       lowerCamelCase_ (							self:	List[str]							)			->   Dict:





									"""simple docstring"""







									pass

							def       lowerCamelCase_ (							self:	List[str]							)			->   int:





									"""simple docstring"""







									lowercase__            =      self.image_processing_class(**self.image_processor_dict							)
									# create random PIL images
									lowercase__            =      prepare_image_inputs(self.image_processor_tester    ,						equal_resolution=UpperCamelCase_							)
									for image in image_inputs:
											self.assertIsInstance(UpperCamelCase_    ,						Image.Image							)

									# Test not batched input
									lowercase__            =      image_processing(image_inputs[0]    ,						return_tensors='''pt'''							).pixel_values
									self.assertEqual(
									    encoded_images.shape    ,						(
									        1,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.crop_size['''height'''],
									        self.image_processor_tester.crop_size['''width'''],
									    )    ,						)

									# Test batched
									lowercase__            =      image_processing(UpperCamelCase_    ,						return_tensors='''pt'''							).pixel_values
									self.assertEqual(
									    encoded_images.shape    ,						(
									        self.image_processor_tester.batch_size,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.crop_size['''height'''],
									        self.image_processor_tester.crop_size['''width'''],
									    )    ,						)

							def       lowerCamelCase_ (							self:	Union[str, Any]							)			->   Optional[int]:





									"""simple docstring"""







									lowercase__            =      self.image_processing_class(**self.image_processor_dict							)
									# create random numpy tensors
									lowercase__            =      prepare_image_inputs(self.image_processor_tester    ,						equal_resolution=UpperCamelCase_    ,						numpify=UpperCamelCase_							)
									for image in image_inputs:
											self.assertIsInstance(UpperCamelCase_    ,						np.ndarray							)

									# Test not batched input
									lowercase__            =      image_processing(image_inputs[0]    ,						return_tensors='''pt'''							).pixel_values
									self.assertEqual(
									    encoded_images.shape    ,						(
									        1,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.crop_size['''height'''],
									        self.image_processor_tester.crop_size['''width'''],
									    )    ,						)

									# Test batched
									lowercase__            =      image_processing(UpperCamelCase_    ,						return_tensors='''pt'''							).pixel_values
									self.assertEqual(
									    encoded_images.shape    ,						(
									        self.image_processor_tester.batch_size,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.crop_size['''height'''],
									        self.image_processor_tester.crop_size['''width'''],
									    )    ,						)


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





									"""simple docstring"""







									lowercase__            =      self.image_processing_class(**self.image_processor_dict							)
									# create random PyTorch tensors
									lowercase__            =      prepare_image_inputs(self.image_processor_tester    ,						equal_resolution=UpperCamelCase_    ,						torchify=UpperCamelCase_							)
									for image in image_inputs:
											self.assertIsInstance(UpperCamelCase_    ,						torch.Tensor							)

									# Test not batched input
									lowercase__            =      image_processing(image_inputs[0]    ,						return_tensors='''pt'''							).pixel_values
									self.assertEqual(
									    encoded_images.shape    ,						(
									        1,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.crop_size['''height'''],
									        self.image_processor_tester.crop_size['''width'''],
									    )    ,						)

									# Test batched
									lowercase__            =      image_processing(UpperCamelCase_    ,						return_tensors='''pt'''							).pixel_values
									self.assertEqual(
									    encoded_images.shape    ,						(
									        self.image_processor_tester.batch_size,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.crop_size['''height'''],
									        self.image_processor_tester.crop_size['''width'''],
									    )    ,						)


