

"""simple docstring"""




from __future__ import annotations

from typing import TypedDict







class   __lowercase      (     _lowercase       ):
  snake_case_												=							42
  snake_case_												=							42







def 	lowerCAmelCase    (       __UpperCamelCase   ):
 '''simple docstring'''





 if not isinstance(__UpperCamelCase				,     __UpperCamelCase   ):
  raise TypeError("""The parameter s type must be str."""   )

 return [s[i:] + s[:i] for i in range(len(__UpperCamelCase   )   )]
def 	lowerCAmelCase    (       __UpperCamelCase   ):
 '''simple docstring'''





 if not isinstance(__UpperCamelCase				,     __UpperCamelCase   ):
  raise TypeError("""The parameter s type must be str."""   )
 if not s:
  raise ValueError("""The parameter s must not be empty."""   )

 UpperCAmelCase__       :	Tuple        =       all_rotations(__UpperCamelCase   )
 rotations.sort()  # sort the list of rotations in alphabetically order
 # make a string composed of the last char of each rotation
 UpperCAmelCase__       :	str        =       {
     """bwt_string""": """""".join([word[-1] for word in rotations]   ),
     """idx_original_string""": rotations.index(__UpperCamelCase   ),
 }
 return response
def 	lowerCAmelCase    (       __UpperCamelCase				,     __UpperCamelCase   ):
 '''simple docstring'''





 if not isinstance(__UpperCamelCase				,     __UpperCamelCase   ):
  raise TypeError("""The parameter bwt_string type must be str."""   )
 if not bwt_string:
  raise ValueError("""The parameter bwt_string must not be empty."""   )
 try:
  UpperCAmelCase__       :	Union[str, Any]        =       int(__UpperCamelCase   )
 except ValueError:
  raise TypeError(
      """The parameter idx_original_string type must be int or passive"""
      """ of cast to int."""   )
 if idx_original_string < 0:
  raise ValueError("""The parameter idx_original_string must not be lower than 0."""   )
 if idx_original_string >= len(__UpperCamelCase   ):
  raise ValueError(
      """The parameter idx_original_string must be lower than""" """ len(bwt_string)."""   )

 UpperCAmelCase__       :	Optional[int]        =       [""""""] * len(__UpperCamelCase   )
 for _ in range(len(__UpperCamelCase   )   ):
  for i in range(len(__UpperCamelCase   )   ):
   UpperCAmelCase__       :	List[Any]        =       bwt_string[i] + ordered_rotations[i]
  ordered_rotations.sort()
 return ordered_rotations[idx_original_string]


if __name__ == "__main__":
      __UpperCAmelCase			=					'Provide a string that I will generate its BWT transform: '
      __UpperCAmelCase			=					input(entry_msg).strip()
      __UpperCAmelCase			=					bwt_transform(s)
      print(
          F"Burrows Wheeler transform for string \'{s}\' results "
          F"in \'{result['bwt_string']}\'"
      )
      __UpperCAmelCase			=					reverse_bwt(result['bwt_string'], result['idx_original_string'])
      print(
          F"Reversing Burrows Wheeler transform for entry \'{result['bwt_string']}\' "
          F"we get original string \'{original_string}\'"
      )







"""simple docstring"""




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     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE=1_3     ,				__SCREAMING_SNAKE_CASE=7     ,				__SCREAMING_SNAKE_CASE=True     ,				__SCREAMING_SNAKE_CASE=True     ,				__SCREAMING_SNAKE_CASE=False     ,				__SCREAMING_SNAKE_CASE=True     ,				__SCREAMING_SNAKE_CASE=9_9     ,				__SCREAMING_SNAKE_CASE=3_2     ,				__SCREAMING_SNAKE_CASE=5     ,				__SCREAMING_SNAKE_CASE=4     ,				__SCREAMING_SNAKE_CASE=3_7     ,				__SCREAMING_SNAKE_CASE="gelu"     ,				__SCREAMING_SNAKE_CASE=0.1     ,				__SCREAMING_SNAKE_CASE=0.1     ,				__SCREAMING_SNAKE_CASE=5_1_2     ,				__SCREAMING_SNAKE_CASE=1_6     ,				__SCREAMING_SNAKE_CASE=2     ,				__SCREAMING_SNAKE_CASE=0.02     ,				__SCREAMING_SNAKE_CASE=3     ,				__SCREAMING_SNAKE_CASE=4     ,				__SCREAMING_SNAKE_CASE=None     ,				)		->     int:







         """simple docstring"""



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



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







         """simple docstring"""



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

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

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

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

         a__		=			self.get_config()

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



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



     def 			lowercase__  (							self     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE   )		->     Dict:







         """simple docstring"""



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



     def 			lowercase__  (							self     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				)		->     Any:







         """simple docstring"""



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



     def 			lowercase__  (							self     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				)		->     List[str]:







         """simple docstring"""



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



     def 			lowercase__  (							self     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				)		->     Optional[int]:







         """simple docstring"""



         a__		=			True
         a__		=			True
         a__		=			LlamaForCausalLM(config=__SCREAMING_SNAKE_CASE   )
         model.to(__SCREAMING_SNAKE_CASE   )
         model.eval()

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

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

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

         a__		=			model(
             __SCREAMING_SNAKE_CASE     ,				attention_mask=__SCREAMING_SNAKE_CASE     ,				encoder_hidden_states=__SCREAMING_SNAKE_CASE     ,				encoder_attention_mask=__SCREAMING_SNAKE_CASE     ,				output_hidden_states=__SCREAMING_SNAKE_CASE     ,				)['hidden_states'][0]
         a__		=			model(
             __SCREAMING_SNAKE_CASE     ,				attention_mask=__SCREAMING_SNAKE_CASE     ,				encoder_hidden_states=__SCREAMING_SNAKE_CASE     ,				encoder_attention_mask=__SCREAMING_SNAKE_CASE     ,				past_key_values=__SCREAMING_SNAKE_CASE     ,				output_hidden_states=__SCREAMING_SNAKE_CASE     ,				)['hidden_states'][0]

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




     def 			lowercase__  (							self   )		->     Dict:







         """simple docstring"""



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







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



     def 			lowercase__  (							self   )		->     Any:







         """simple docstring"""



         a__		=			LlamaModelTester(self   )
         a__		=			ConfigTester(self     ,				config_class=__SCREAMING_SNAKE_CASE     ,				hidden_size=3_7   )



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







         """simple docstring"""



         self.config_tester.run_common_tests()



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







         """simple docstring"""



         a__		=			self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE   )



     def 			lowercase__  (							self   )		->     Any:







         """simple docstring"""



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



     def 			lowercase__  (							self   )		->     int:







         """simple docstring"""



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



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







         """simple docstring"""



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



     def 			lowercase__  (							self   )		->     int:







         """simple docstring"""



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







         """simple docstring"""



         pass




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







         """simple docstring"""



         a__	,     a__		=			self.model_tester.prepare_config_and_inputs_for_common()
         a__		=			ids_tensor([1, 1_0]     ,				config.vocab_size   )
         a__		=			ids_tensor([1, int(config.max_position_embeddings * 1.5   )]     ,				config.vocab_size   )

         set_seed(4_2   )  # Fixed seed at init time so the two models get the same random weights
         a__		=			LlamaModel(__SCREAMING_SNAKE_CASE   )
         original_model.to(__SCREAMING_SNAKE_CASE   )
         original_model.eval()
         a__		=			original_model(__SCREAMING_SNAKE_CASE   ).last_hidden_state
         a__		=			original_model(__SCREAMING_SNAKE_CASE   ).last_hidden_state

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

         # The output should be different for long inputs
         self.assertFalse(torch.allclose(__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				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 			lowercase__  (							self   )		->     Any:







         """simple docstring"""



         a__		=			[1, 3_0_6, 4_6_5_8, 2_7_8, 6_5_9_3, 3_1_0, 2_8_3_4, 3_3_8]
         a__		=			LlamaForCausalLM.from_pretrained('meta-llama/Llama-2-7b-hf'     ,				device_map='auto'   )
         a__		=			model(torch.tensor([input_ids]   )   )
         # Expected mean on dim = -1
         a__		=			torch.tensor([[-6.65_50, -4.12_27, -4.98_59, -3.24_06, 0.82_62, -3.00_33, 1.29_64, -3.36_99]]   )
         torch.testing.assert_close(out.mean(-1   )     ,				__SCREAMING_SNAKE_CASE     ,				atol=1e-2     ,				rtol=1e-2   )
         # slicing logits[0, 0, 0:30]
         # fmt: off
         a__		=			torch.tensor([-12.82_81, -7.44_53, -0.46_39, -8.06_25, -7.25_00, -8.00_00, -6.48_83, -7.76_95, -7.84_38, -7.03_12, -6.21_88, -7.13_28, -1.84_96, 1.99_61, -8.62_50, -6.72_27, -12.82_81, -6.94_92, -7.07_42, -7.78_52, -7.58_20, -7.90_62, -6.93_75, -7.98_05, -8.34_38, -8.15_62, -8.04_69, -7.62_50, -7.74_22, -7.33_98,]   )
         # fmt: on
         torch.testing.assert_close(out[0, 0, :3_0]     ,				__SCREAMING_SNAKE_CASE     ,				atol=1e-5     ,				rtol=1e-5   )



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







         """simple docstring"""



         a__		=			[1, 3_0_6, 4_6_5_8, 2_7_8, 6_5_9_3, 3_1_0, 2_8_3_4, 3_3_8]
         a__		=			LlamaForCausalLM.from_pretrained('meta-llama/Llama-2-13b-hf'     ,				device_map='auto'   )
         a__		=			model(torch.tensor(__SCREAMING_SNAKE_CASE   )   )
         # Expected mean on dim = -1
         a__		=			torch.tensor([[-2.06_22, -1.27_94, -1.16_38, -0.97_88, -1.46_03, -1.02_38, -1.78_93, -1.44_11]]   )
         torch.testing.assert_close(out.mean(-1   )     ,				__SCREAMING_SNAKE_CASE     ,				atol=1e-2     ,				rtol=1e-2   )
         # slicing logits[0, 0, 0:30]
         # fmt: off
         a__		=			torch.tensor([-8.14_06, -8.05_47, 2.74_61, -1.23_44, -0.14_48, -1.82_62, -1.00_20, -1.81_54, -1.68_95, -1.85_16, -2.35_74, -0.92_77, 3.75_98, 6.57_42, -1.29_98, -0.11_77, -8.14_06, -2.96_88, -2.91_99, -3.16_99, -3.52_54, -2.35_55, -2.79_88, -3.41_41, -2.82_62, -4.51_95, -3.33_79, -3.31_64, -2.78_32, -3.02_73]   )
         # fmt: on
         torch.testing.assert_close(out[0, 0, :3_0]     ,				__SCREAMING_SNAKE_CASE     ,				atol=1e-5     ,				rtol=1e-5   )



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







         """simple docstring"""



         a__		=			[1, 3_0_6, 4_6_5_8, 2_7_8, 6_5_9_3, 3_1_0, 2_8_3_4, 3_3_8]
         a__		=			LlamaForCausalLM.from_pretrained('meta-llama/Llama-2-13b-chat-hf'     ,				device_map='auto'   )
         a__		=			model(torch.tensor(__SCREAMING_SNAKE_CASE   )   )
         # Expected mean on dim = -1
         a__		=			torch.tensor([[-0.85_62, -1.85_20, -0.75_51, -0.41_62, -1.51_61, -1.20_38, -2.48_23, -2.32_54]]   )
         torch.testing.assert_close(out.mean(-1   )     ,				__SCREAMING_SNAKE_CASE     ,				atol=1e-2     ,				rtol=1e-2   )
         # slicing logits[0, 0, 0:30]
         # fmt: off
         a__		=			torch.tensor([-2.22_27, 4.88_28, 0.90_23, -0.45_78, -0.78_71, -0.10_33, -0.62_21, -0.57_86, -0.78_03, -1.06_74, -1.29_20, -0.15_70, 0.80_08, 2.07_23, -0.94_97, 0.27_71, -2.22_27, -0.76_12, -1.43_46, -1.20_61, -1.64_26, -0.30_00, -0.71_39, -1.19_34, -1.86_91, -1.69_73, -1.59_47, -1.27_05, -0.35_23, -0.55_13]   )
         # fmt: on
         torch.testing.assert_close(out.mean(-1   )     ,				__SCREAMING_SNAKE_CASE     ,				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 			lowercase__  (							self   )		->     Tuple:







         """simple docstring"""



         a__		=			[1, 3_0_6, 4_6_5_8, 2_7_8, 6_5_9_3, 3_1_0, 2_8_3_4, 3_3_8]
         a__		=			LlamaForCausalLM.from_pretrained('meta-llama/Llama-2-70b-hf'     ,				device_map='auto'   )
         a__		=			model(torch.tensor(__SCREAMING_SNAKE_CASE   )   )

         a__		=			torch.tensor(
             [[-4.23_27, -3.33_60, -4.66_65, -4.76_31, -1.81_80, -3.41_70, -1.42_11, -3.18_10]]     ,				dtype=torch.floataa   )
         torch.testing.assert_close(out.mean(-1   )     ,				__SCREAMING_SNAKE_CASE     ,				atol=1e-2     ,				rtol=1e-2   )
         # fmt: off
         a__		=			torch.tensor([-9.49_22, -3.95_51, 1.79_98, -5.67_58, -5.10_55, -5.89_84, -4.83_20, -6.80_86, -6.53_91, -5.61_72, -5.58_20, -5.53_52, 1.78_81, 3.62_89, -6.51_17, -3.47_85, -9.50_00, -6.03_52, -6.81_25, -6.01_95, -6.68_36, -5.47_27, -6.28_12, -6.03_91, -7.33_98, -7.42_97, -7.48_44, -6.58_20, -5.87_89, -5.53_12]   )
         # fmt: on
         torch.testing.assert_close(out[0, 0, :3_0]     ,				__SCREAMING_SNAKE_CASE     ,				atol=1e-5     ,				rtol=1e-5   )




     @unittest.skip('Model is curently gated'   )
     @slow
     def 			lowercase__  (							self   )		->     List[str]:







         """simple docstring"""



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

         # greedy generation outputs
         a__		=			model.generate(__SCREAMING_SNAKE_CASE     ,				max_new_tokens=6_4     ,				top_p=__SCREAMING_SNAKE_CASE     ,				temperature=1     ,				do_sample=__SCREAMING_SNAKE_CASE   )
         a__		=			tokenizer.decode(generated_ids[0]     ,				skip_special_tokens=__SCREAMING_SNAKE_CASE   )
         self.assertEqual(__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE   )


