
import logging
import os
import threading
import time


try:
		import warnings
except ImportError:
		_UpperCAmelCase :			str              =	None

try:
		import msvcrt
except ImportError:
		_UpperCAmelCase :			List[Any]              =	None

try:
		import fcntl
except ImportError:
		_UpperCAmelCase :			int              =	None


# Backward compatibility
# ------------------------------------------------
try:
		TimeoutError
except NameError:
		_UpperCAmelCase :			Dict              =	OSError


# Data
# ------------------------------------------------
_UpperCAmelCase :			Optional[Any]              =	[
    "Timeout",
    "BaseFileLock",
    "WindowsFileLock",
    "UnixFileLock",
    "SoftFileLock",
    "FileLock",
]

_UpperCAmelCase :			Optional[int]              =	"3.0.12"


_UpperCAmelCase :			int              =	None


def 				A	( )       ->  Tuple:
		'''simple docstring'''

		global _logger
		UpperCamelCase          =					_logger or logging.getLogger(__name__			)
		return _logger


class     lowercase (		_SCREAMING_SNAKE_CASE       ):



		def __init__(			self    ,				A_	)  -> Tuple:
				"""simple docstring"""
				UpperCamelCase          =					lock_file
				return None



		def __str__(			self	)  -> List[str]:
				"""simple docstring"""
				UpperCamelCase          =					F'''The file lock \'{self.lock_file}\' could not be acquired.'''
				return temp






class     lowercase :



		def __init__(			self    ,				A_	)  -> Optional[int]:
				"""simple docstring"""
				UpperCamelCase          =					lock
				return None



		def __enter__(			self	)  -> int:
				"""simple docstring"""
				return self.lock



		def __exit__(			self    ,				A_    ,				A_    ,				A_	)  -> Tuple:
				"""simple docstring"""
				self.lock.release()
				return None






class     lowercase :



		def __init__(			self    ,				A_    ,				A_=-1    ,				A_=None	)  -> Union[str, Any]:
				"""simple docstring"""
				UpperCamelCase          =					max_filename_length if max_filename_length is not None else 255
				# Hash the filename if it's too long
				UpperCamelCase          =					self.hash_filename_if_too_long(A_    ,				A_	)
				# The path to the lock file.
				UpperCamelCase          =					lock_file

				# The file descriptor for the *_lock_file* as it is returned by the
				# os.open() function.
				# This file lock is only NOT None, if the object currently holds the
				# lock.
				UpperCamelCase          =					None

				# The default timeout value.
				UpperCamelCase          =					timeout

				# We use this lock primarily for the lock counter.
				UpperCamelCase          =					threading.Lock()

				# The lock counter is used for implementing the nested locking
				# mechanism. Whenever the lock is acquired, the counter is increased and
				# the lock is only released, when this value is 0 again.
				UpperCamelCase          =					0
				return None



		@property
		def __UpperCamelCase			(			self	)  -> int:
				"""simple docstring"""
				return self._lock_file



		@property
		def __UpperCamelCase			(			self	)  -> Dict:
				"""simple docstring"""
				return self._timeout



		@timeout.setter
		def __UpperCamelCase			(			self    ,				A_	)  -> Optional[int]:
				"""simple docstring"""
				UpperCamelCase          =					float(A_	)
				return None



		def __UpperCamelCase			(			self	)  -> int:
				"""simple docstring"""
				raise NotImplementedError()



		def __UpperCamelCase			(			self	)  -> Union[str, Any]:
				"""simple docstring"""
				raise NotImplementedError()



		@property
		def __UpperCamelCase			(			self	)  -> Any:
				"""simple docstring"""
				return self._lock_file_fd is not None



		def __UpperCamelCase			(			self    ,				A_=None    ,				A_=0.05	)  -> Union[str, Any]:
				"""simple docstring"""
				# Use the default timeout, if no timeout is provided.
				if timeout is None:
						UpperCamelCase          =					self.timeout

				# Increment the number right at the beginning.
				# We can still undo it, if something fails.
				with self._thread_lock:
						self._lock_counter += 1

				UpperCamelCase          =					id(self	)
				UpperCamelCase          =					self._lock_file
				UpperCamelCase          =					time.time()
				try:
						while True:
								with self._thread_lock:
										if not self.is_locked:
												logger().debug(F'''Attempting to acquire lock {lock_id} on {lock_filename}'''	)
												self._acquire()

								if self.is_locked:
										logger().debug(F'''Lock {lock_id} acquired on {lock_filename}'''	)
										break
								elif timeout >= 0 and time.time() - start_time > timeout:
										logger().debug(F'''Timeout on acquiring lock {lock_id} on {lock_filename}'''	)
										raise Timeout(self._lock_file	)
								else:
										logger().debug(
										    F'''Lock {lock_id} not acquired on {lock_filename}, waiting {poll_intervall} seconds ...'''	)
										time.sleep(A_	)
				except:  # noqa
						# Something did go wrong, so decrement the counter.
						with self._thread_lock:
								UpperCamelCase          =					max(0    ,				self._lock_counter - 1	)

						raise
				return _Acquire_ReturnProxy(lock=self	)



		def __UpperCamelCase			(			self    ,				A_=False	)  -> Optional[Any]:
				"""simple docstring"""
				with self._thread_lock:
						if self.is_locked:
								self._lock_counter -= 1

								if self._lock_counter == 0 or force:
										UpperCamelCase          =					id(self	)
										UpperCamelCase          =					self._lock_file

										logger().debug(F'''Attempting to release lock {lock_id} on {lock_filename}'''	)
										self._release()
										UpperCamelCase          =					0
										logger().debug(F'''Lock {lock_id} released on {lock_filename}'''	)

				return None



		def __enter__(			self	)  -> Union[str, Any]:
				"""simple docstring"""
				self.acquire()
				return self



		def __exit__(			self    ,				A_    ,				A_    ,				A_	)  -> Optional[Any]:
				"""simple docstring"""
				self.release()
				return None



		def __del__(			self	)  -> int:
				"""simple docstring"""
				self.release(force=A_	)
				return None



		def __UpperCamelCase			(			self    ,				A_    ,				A_	)  -> str:
				"""simple docstring"""
				UpperCamelCase          =					os.path.basename(A_	)
				if len(A_	) > max_length and max_length > 0:
						UpperCamelCase          =					os.path.dirname(A_	)
						UpperCamelCase          =					str(hash(A_	)	)
						UpperCamelCase          =					filename[: max_length - len(A_	) - 8] + '...' + hashed_filename + '.lock'
						return os.path.join(A_    ,				A_	)
				else:
						return path






class     lowercase (		_SCREAMING_SNAKE_CASE       ):



		def __init__(			self    ,				A_    ,				A_=-1    ,				A_=None	)  -> List[Any]:
				"""simple docstring"""
				from .file_utils import relative_to_absolute_path

				super().__init__(A_    ,				timeout=A_    ,				max_filename_length=A_	)
				UpperCamelCase          =					'\\\\?\\' + relative_to_absolute_path(self.lock_file	)



		def __UpperCamelCase			(			self	)  -> Tuple:
				"""simple docstring"""
				UpperCamelCase          =					os.O_RDWR | os.O_CREAT | os.O_TRUNC

				try:
						UpperCamelCase          =					os.open(self._lock_file    ,				A_	)
				except OSError:
						pass
				else:
						try:
								msvcrt.locking(A_    ,				msvcrt.LK_NBLCK    ,				1	)
						except OSError:
								os.close(A_	)
						else:
								UpperCamelCase          =					fd
				return None



		def __UpperCamelCase			(			self	)  -> int:
				"""simple docstring"""
				UpperCamelCase          =					self._lock_file_fd
				UpperCamelCase          =					None
				msvcrt.locking(A_    ,				msvcrt.LK_UNLCK    ,				1	)
				os.close(A_	)

				try:
						os.remove(self._lock_file	)
				# Probably another instance of the application
				# that acquired the file lock.
				except OSError:
						pass
				return None






class     lowercase (		_SCREAMING_SNAKE_CASE       ):



		def __init__(			self    ,				A_    ,				A_=-1    ,				A_=None	)  -> Any:
				"""simple docstring"""
				UpperCamelCase          =					os.statvfs(os.path.dirname(A_	)	).f_namemax
				super().__init__(A_    ,				timeout=A_    ,				max_filename_length=A_	)



		def __UpperCamelCase			(			self	)  -> Union[str, Any]:
				"""simple docstring"""
				UpperCamelCase          =					os.O_RDWR | os.O_CREAT | os.O_TRUNC
				UpperCamelCase          =					os.open(self._lock_file    ,				A_	)

				try:
						fcntl.flock(A_    ,				fcntl.LOCK_EX | fcntl.LOCK_NB	)
				except OSError:
						os.close(A_	)
				else:
						UpperCamelCase          =					fd
				return None



		def __UpperCamelCase			(			self	)  -> Union[str, Any]:
				"""simple docstring"""
				UpperCamelCase          =					self._lock_file_fd
				UpperCamelCase          =					None
				fcntl.flock(A_    ,				fcntl.LOCK_UN	)
				os.close(A_	)
				return None






class     lowercase (		_SCREAMING_SNAKE_CASE       ):



		def __UpperCamelCase			(			self	)  -> List[Any]:
				"""simple docstring"""
				UpperCamelCase          =					os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_TRUNC
				try:
						UpperCamelCase          =					os.open(self._lock_file    ,				A_	)
				except OSError:
						pass
				else:
						UpperCamelCase          =					fd
				return None



		def __UpperCamelCase			(			self	)  -> Union[str, Any]:
				"""simple docstring"""
				os.close(self._lock_file_fd	)
				UpperCamelCase          =					None

				try:
						os.remove(self._lock_file	)
				# The file is already deleted and that's what we want.
				except OSError:
						pass
				return None






_UpperCAmelCase :			str              =	None

if msvcrt:
		_UpperCAmelCase :			Optional[int]              =	WindowsFileLock
elif fcntl:
		_UpperCAmelCase :			List[str]              =	UnixFileLock
else:
		_UpperCAmelCase :			Tuple              =	SoftFileLock

		if warnings is not None:
				warnings.warn("only soft file lock is available")


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



		def __init__(			self    ,				A_    ,				A_=13    ,				A_=7    ,				A_=True    ,				A_=True    ,				A_=False    ,				A_=True    ,				A_=99    ,				A_=32    ,				A_=5    ,				A_=4    ,				A_=37    ,				A_="gelu"    ,				A_=0.1    ,				A_=0.1    ,				A_=512    ,				A_=16    ,				A_=2    ,				A_=0.02    ,				A_=3    ,				A_=4    ,				A_=None    ,				)  -> Tuple:
				"""simple docstring"""
				UpperCamelCase          =					parent
				UpperCamelCase          =					batch_size
				UpperCamelCase          =					seq_length
				UpperCamelCase          =					is_training
				UpperCamelCase          =					use_input_mask
				UpperCamelCase          =					use_token_type_ids
				UpperCamelCase          =					use_labels
				UpperCamelCase          =					vocab_size
				UpperCamelCase          =					hidden_size
				UpperCamelCase          =					num_hidden_layers
				UpperCamelCase          =					num_attention_heads
				UpperCamelCase          =					intermediate_size
				UpperCamelCase          =					hidden_act
				UpperCamelCase          =					hidden_dropout_prob
				UpperCamelCase          =					attention_probs_dropout_prob
				UpperCamelCase          =					max_position_embeddings
				UpperCamelCase          =					type_vocab_size
				UpperCamelCase          =					type_sequence_label_size
				UpperCamelCase          =					initializer_range
				UpperCamelCase          =					num_labels
				UpperCamelCase          =					num_choices
				UpperCamelCase          =					scope



		def __UpperCamelCase			(			self	)  -> Any:
				"""simple docstring"""
				UpperCamelCase          =					ids_tensor([self.batch_size, self.seq_length]    ,				self.vocab_size	)

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

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

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

				UpperCamelCase          =					self.get_config()

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



		def __UpperCamelCase			(			self	)  -> List[Any]:
				"""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=A_    ,				initializer_range=self.initializer_range    ,				)



		def __UpperCamelCase			(			self    ,				A_    ,				A_    ,				A_    ,				A_    ,				A_    ,				A_    ,				A_	)  -> int:
				"""simple docstring"""
				UpperCamelCase          =					LlamaModel(config=A_	)
				model.to(A_	)
				model.eval()
				UpperCamelCase          =					model(A_    ,				attention_mask=A_	)
				UpperCamelCase          =					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_    ,				A_    ,				A_    ,				A_    ,				A_    ,				A_    ,				A_    ,				)  -> List[Any]:
				"""simple docstring"""
				UpperCamelCase          =					True
				UpperCamelCase          =					LlamaModel(A_	)
				model.to(A_	)
				model.eval()
				UpperCamelCase          =					model(
				    A_    ,				attention_mask=A_    ,				encoder_hidden_states=A_    ,				encoder_attention_mask=A_    ,				)
				UpperCamelCase          =					model(
				    A_    ,				attention_mask=A_    ,				encoder_hidden_states=A_    ,				)
				UpperCamelCase          =					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_    ,				A_    ,				A_    ,				A_    ,				A_    ,				A_    ,				)  -> str:
				"""simple docstring"""
				UpperCamelCase          =					LlamaForCausalLM(config=A_	)
				model.to(A_	)
				model.eval()
				UpperCamelCase          =					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_    ,				A_    ,				A_    ,				A_    ,				A_    ,				A_    ,				)  -> Optional[int]:
				"""simple docstring"""
				UpperCamelCase          =					True
				UpperCamelCase          =					True
				UpperCamelCase          =					LlamaForCausalLM(config=A_	)
				model.to(A_	)
				model.eval()

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

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

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

				UpperCamelCase          =					model(
				    A_    ,				attention_mask=A_    ,				encoder_hidden_states=A_    ,				encoder_attention_mask=A_    ,				output_hidden_states=A_    ,				)['hidden_states'][0]
				UpperCamelCase          =					model(
				    A_    ,				attention_mask=A_    ,				encoder_hidden_states=A_    ,				encoder_attention_mask=A_    ,				past_key_values=A_    ,				output_hidden_states=A_    ,				)['hidden_states'][0]

				# select random slice
				UpperCamelCase          =					ids_tensor((1,)    ,				output_from_past.shape[-1]	).item()
				UpperCamelCase          =					output_from_no_past[:, -3:, random_slice_idx].detach()
				UpperCamelCase          =					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	)  -> Tuple:
				"""simple docstring"""
				UpperCamelCase          =					self.prepare_config_and_inputs()
				(
				    (
				    UpperCamelCase
				)     ,  (
				    UpperCamelCase
				)     ,  (
				    UpperCamelCase
				)     ,  (
				    UpperCamelCase
				)     ,  (
				    UpperCamelCase
				)     ,  (
				    UpperCamelCase
				)     ,  (
				    UpperCamelCase
				)     ,  
				)          =					config_and_inputs
				UpperCamelCase          =					{'input_ids': input_ids, 'attention_mask': input_mask}
				return config, inputs_dict






@require_torch
class     lowercase (		_SCREAMING_SNAKE_CASE  ,       _SCREAMING_SNAKE_CASE  ,       _SCREAMING_SNAKE_CASE  ,       unittest.TestCase       ):
		__lowercase	:	str     					=    (LlamaModel, LlamaForCausalLM, LlamaForSequenceClassification) if is_torch_available() else ()
		__lowercase	:	str     					=    (LlamaForCausalLM,) if is_torch_available() else ()
		__lowercase	:	Any     					=    (
		    {
		        "feature-extraction": LlamaModel,
		        "text-classification": LlamaForSequenceClassification,
		        "text-generation": LlamaForCausalLM,
		        "zero-shot": LlamaForSequenceClassification,
		    }
		    if is_torch_available()
		    else {}
		)
		__lowercase	:	int     					=    False
		__lowercase	:	Optional[int]     					=    False



		def __UpperCamelCase			(			self	)  -> int:
				"""simple docstring"""
				UpperCamelCase          =					LlamaModelTester(self	)
				UpperCamelCase          =					ConfigTester(self    ,				config_class=A_    ,				hidden_size=37	)



		def __UpperCamelCase			(			self	)  -> Union[str, Any]:
				"""simple docstring"""
				self.config_tester.run_common_tests()



		def __UpperCamelCase			(			self	)  -> Optional[int]:
				"""simple docstring"""
				UpperCamelCase          =					self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*A_	)



		def __UpperCamelCase			(			self	)  -> Optional[Any]:
				"""simple docstring"""
				UpperCamelCase          =					self.model_tester.prepare_config_and_inputs()
				for type in ["absolute", "relative_key", "relative_key_query"]:
						UpperCamelCase          =					type
						self.model_tester.create_and_check_model(*A_	)



		def __UpperCamelCase			(			self	)  -> Union[str, Any]:
				"""simple docstring"""
				UpperCamelCase     ,  UpperCamelCase          =					self.model_tester.prepare_config_and_inputs_for_common()
				UpperCamelCase          =					3
				UpperCamelCase          =					input_dict['input_ids']
				UpperCamelCase          =					input_ids.ne(1	).to(A_	)
				UpperCamelCase          =					ids_tensor([self.model_tester.batch_size]    ,				self.model_tester.type_sequence_label_size	)
				UpperCamelCase          =					LlamaForSequenceClassification(A_	)
				model.to(A_	)
				model.eval()
				UpperCamelCase          =					model(A_    ,				attention_mask=A_    ,				labels=A_	)
				self.assertEqual(result.logits.shape    ,				(self.model_tester.batch_size, self.model_tester.num_labels)	)



		def __UpperCamelCase			(			self	)  -> Dict:
				"""simple docstring"""
				UpperCamelCase     ,  UpperCamelCase          =					self.model_tester.prepare_config_and_inputs_for_common()
				UpperCamelCase          =					3
				UpperCamelCase          =					'single_label_classification'
				UpperCamelCase          =					input_dict['input_ids']
				UpperCamelCase          =					input_ids.ne(1	).to(A_	)
				UpperCamelCase          =					ids_tensor([self.model_tester.batch_size]    ,				self.model_tester.type_sequence_label_size	)
				UpperCamelCase          =					LlamaForSequenceClassification(A_	)
				model.to(A_	)
				model.eval()
				UpperCamelCase          =					model(A_    ,				attention_mask=A_    ,				labels=A_	)
				self.assertEqual(result.logits.shape    ,				(self.model_tester.batch_size, self.model_tester.num_labels)	)



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



		@parameterized.expand([('linear',), ('dynamic',)]	)
		def __UpperCamelCase			(			self    ,				A_	)  -> Optional[int]:
				"""simple docstring"""
				UpperCamelCase     ,  UpperCamelCase          =					self.model_tester.prepare_config_and_inputs_for_common()
				UpperCamelCase          =					ids_tensor([1, 10]    ,				config.vocab_size	)
				UpperCamelCase          =					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
				UpperCamelCase          =					LlamaModel(A_	)
				original_model.to(A_	)
				original_model.eval()
				UpperCamelCase          =					original_model(A_	).last_hidden_state
				UpperCamelCase          =					original_model(A_	).last_hidden_state

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



		@unittest.skip('Logits are not exactly the same, once we fix the instabalities somehow, will update!'	)
		@slow
		def __UpperCamelCase			(			self	)  -> List[Any]:
				"""simple docstring"""
				UpperCamelCase          =					[1, 306, 4_658, 278, 6_593, 310, 2_834, 338]
				UpperCamelCase          =					LlamaForCausalLM.from_pretrained('meta-llama/Llama-2-7b-hf'    ,				device_map='auto'	)
				UpperCamelCase          =					model(torch.tensor([input_ids]	)	)
				# Expected mean on dim = -1
				UpperCamelCase          =					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	)    ,				A_    ,				atol=1e-2    ,				rtol=1e-2	)
				# slicing logits[0, 0, 0:30]
				# fmt: off
				UpperCamelCase          =					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]    ,				A_    ,				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	)  -> List[Any]:
				"""simple docstring"""
				UpperCamelCase          =					[1, 306, 4_658, 278, 6_593, 310, 2_834, 338]
				UpperCamelCase          =					LlamaForCausalLM.from_pretrained('meta-llama/Llama-2-13b-hf'    ,				device_map='auto'	)
				UpperCamelCase          =					model(torch.tensor(A_	)	)
				# Expected mean on dim = -1
				UpperCamelCase          =					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	)    ,				A_    ,				atol=1e-2    ,				rtol=1e-2	)
				# slicing logits[0, 0, 0:30]
				# fmt: off
				UpperCamelCase          =					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]    ,				A_    ,				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	)  -> List[Any]:
				"""simple docstring"""
				UpperCamelCase          =					[1, 306, 4_658, 278, 6_593, 310, 2_834, 338]
				UpperCamelCase          =					LlamaForCausalLM.from_pretrained('meta-llama/Llama-2-13b-chat-hf'    ,				device_map='auto'	)
				UpperCamelCase          =					model(torch.tensor(A_	)	)
				# Expected mean on dim = -1
				UpperCamelCase          =					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	)    ,				A_    ,				atol=1e-2    ,				rtol=1e-2	)
				# slicing logits[0, 0, 0:30]
				# fmt: off
				UpperCamelCase          =					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	)    ,				A_    ,				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	)  -> List[str]:
				"""simple docstring"""
				UpperCamelCase          =					[1, 306, 4_658, 278, 6_593, 310, 2_834, 338]
				UpperCamelCase          =					LlamaForCausalLM.from_pretrained('meta-llama/Llama-2-70b-hf'    ,				device_map='auto'	)
				UpperCamelCase          =					model(torch.tensor(A_	)	)

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



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

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