


"""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 				SCREAMING_SNAKE_CASE__    :
       """simple docstring"""


       def __init__(						self		,					snake_case__		,					snake_case__=13		,					snake_case__=7		,					snake_case__=True		,					snake_case__=True		,					snake_case__=False		,					snake_case__=True		,					snake_case__=99		,					snake_case__=32		,					snake_case__=5		,					snake_case__=4		,					snake_case__=37		,					snake_case__="gelu"		,					snake_case__=0.1		,					snake_case__=0.1		,					snake_case__=512		,					snake_case__=16		,					snake_case__=2		,					snake_case__=0.02		,					snake_case__=3		,					snake_case__=4		,					snake_case__=None		,					):






         """simple docstring"""





         lowerCAmelCase					:					List[str]								=							parent
         lowerCAmelCase					:					List[Any]								=							batch_size
         lowerCAmelCase					:					Tuple								=							seq_length
         lowerCAmelCase					:					Dict								=							is_training
         lowerCAmelCase					:					str								=							use_input_mask
         lowerCAmelCase					:					int								=							use_token_type_ids
         lowerCAmelCase					:					List[Any]								=							use_labels
         lowerCAmelCase					:					Tuple								=							vocab_size
         lowerCAmelCase					:					Optional[Any]								=							hidden_size
         lowerCAmelCase					:					List[str]								=							num_hidden_layers
         lowerCAmelCase					:					Union[str, Any]								=							num_attention_heads
         lowerCAmelCase					:					Optional[Any]								=							intermediate_size
         lowerCAmelCase					:					str								=							hidden_act
         lowerCAmelCase					:					Optional[Any]								=							hidden_dropout_prob
         lowerCAmelCase					:					Union[str, Any]								=							attention_probs_dropout_prob
         lowerCAmelCase					:					Union[str, Any]								=							max_position_embeddings
         lowerCAmelCase					:					Any								=							type_vocab_size
         lowerCAmelCase					:					Tuple								=							type_sequence_label_size
         lowerCAmelCase					:					Optional[Any]								=							initializer_range
         lowerCAmelCase					:					Dict								=							num_labels
         lowerCAmelCase					:					Optional[int]								=							num_choices
         lowerCAmelCase					:					Optional[int]								=							scope

       def 	lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase					:					Tuple								=							ids_tensor([self.batch_size, self.seq_length]		,					self.vocab_size						)

         lowerCAmelCase					:					Union[str, Any]								=							None
         if self.use_input_mask:
           lowerCAmelCase					:					str								=							random_attention_mask([self.batch_size, self.seq_length]						)

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

         lowerCAmelCase					:					Dict								=							None
         lowerCAmelCase					:					Optional[Any]								=							None
         lowerCAmelCase					:					str								=							None
         if self.use_labels:
           lowerCAmelCase					:					Optional[Any]								=							ids_tensor([self.batch_size]		,					self.type_sequence_label_size						)
           lowerCAmelCase					:					int								=							ids_tensor([self.batch_size, self.seq_length]		,					self.num_labels						)
           lowerCAmelCase					:					Union[str, Any]								=							ids_tensor([self.batch_size]		,					self.num_choices						)

         lowerCAmelCase					:					int								=							self.get_config()

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

       def 	lowercase__							(						self						):






         """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=lowerCamelCase_		,					initializer_range=self.initializer_range		,					)

       def 	lowercase__							(						self		,					snake_case__		,					snake_case__		,					snake_case__		,					snake_case__		,					snake_case__		,					snake_case__		,					snake_case__						):






         """simple docstring"""





         lowerCAmelCase					:					Dict								=							LlamaModel(config=lowerCamelCase_						)
         model.to(lowerCamelCase_						)
         model.eval()
         lowerCAmelCase					:					Optional[int]								=							model(lowerCamelCase_		,					attention_mask=lowerCamelCase_						)
         lowerCAmelCase					:					Dict								=							model(lowerCamelCase_						)
         self.parent.assertEqual(result.last_hidden_state.shape		,					(self.batch_size, self.seq_length, self.hidden_size)						)

       def 	lowercase__							(						self		,					snake_case__		,					snake_case__		,					snake_case__		,					snake_case__		,					snake_case__		,					snake_case__		,					snake_case__		,					snake_case__		,					snake_case__		,					):






         """simple docstring"""





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

       def 	lowercase__							(						self		,					snake_case__		,					snake_case__		,					snake_case__		,					snake_case__		,					snake_case__		,					snake_case__		,					snake_case__		,					snake_case__		,					snake_case__		,					):






         """simple docstring"""





         lowerCAmelCase					:					Tuple								=							LlamaForCausalLM(config=lowerCamelCase_						)
         model.to(lowerCamelCase_						)
         model.eval()
         lowerCAmelCase					:					Any								=							model(lowerCamelCase_		,					attention_mask=lowerCamelCase_		,					labels=lowerCamelCase_						)
         self.parent.assertEqual(result.logits.shape		,					(self.batch_size, self.seq_length, self.vocab_size)						)

       def 	lowercase__							(						self		,					snake_case__		,					snake_case__		,					snake_case__		,					snake_case__		,					snake_case__		,					snake_case__		,					snake_case__		,					snake_case__		,					snake_case__		,					):






         """simple docstring"""





         lowerCAmelCase					:					Tuple								=							True
         lowerCAmelCase					:					List[str]								=							True
         lowerCAmelCase					:					List[str]								=							LlamaForCausalLM(config=lowerCamelCase_						)
         model.to(lowerCamelCase_						)
         model.eval()

         # first forward pass
         lowerCAmelCase					:					int								=							model(
             lowerCamelCase_		,					attention_mask=lowerCamelCase_		,					encoder_hidden_states=lowerCamelCase_		,					encoder_attention_mask=lowerCamelCase_		,					use_cache=lowerCamelCase_		,					)
         lowerCAmelCase					:					Tuple								=							outputs.past_key_values

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

         # append to next input_ids and
         lowerCAmelCase					:					Tuple								=							torch.cat([input_ids, next_tokens]		,					dim=-1						)
         lowerCAmelCase					:					Optional[Any]								=							torch.cat([input_mask, next_mask]		,					dim=-1						)

         lowerCAmelCase					:					Optional[int]								=							model(
             lowerCamelCase_		,					attention_mask=lowerCamelCase_		,					encoder_hidden_states=lowerCamelCase_		,					encoder_attention_mask=lowerCamelCase_		,					output_hidden_states=lowerCamelCase_		,					)["hidden_states"][0]
         lowerCAmelCase					:					Dict								=							model(
             lowerCamelCase_		,					attention_mask=lowerCamelCase_		,					encoder_hidden_states=lowerCamelCase_		,					encoder_attention_mask=lowerCamelCase_		,					past_key_values=lowerCamelCase_		,					output_hidden_states=lowerCamelCase_		,					)["hidden_states"][0]

         # select random slice
         lowerCAmelCase					:					Optional[Any]								=							ids_tensor((1,)		,					output_from_past.shape[-1]						).item()
         lowerCAmelCase					:					int								=							output_from_no_past[:, -3:, random_slice_idx].detach()
         lowerCAmelCase					:					Union[str, Any]								=							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(lowerCamelCase_		,					lowerCamelCase_		,					atol=1e-3						)						)







       def 	lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase					:					List[Any]								=							self.prepare_config_and_inputs()
         (
             (
             lowerCAmelCase    
         )						,  (
             lowerCAmelCase    
         )						,  (
             lowerCAmelCase    
         )						,  (
             lowerCAmelCase    
         )						,  (
             lowerCAmelCase    
         )						,  (
             lowerCAmelCase    
         )						,  (
             lowerCAmelCase    
         )						,      
         )					:					List[str]								=							config_and_inputs
         lowerCAmelCase					:					List[Any]								=							{"input_ids": input_ids, "attention_mask": input_mask}
         return config, inputs_dict


@require_torch
class 				SCREAMING_SNAKE_CASE__    (		lowercase       ,   lowercase       ,   lowercase       ,   unittest.TestCase    ):
       """simple docstring"""


       a  :    Tuple       =(LlamaModel, LlamaForCausalLM, LlamaForSequenceClassification) if is_torch_available() else ()
       a  :    str       =(LlamaForCausalLM,) if is_torch_available() else ()
       a  :    Dict       =(
           {
               "feature-extraction": LlamaModel,
               "text-classification": LlamaForSequenceClassification,
               "text-generation": LlamaForCausalLM,
               "zero-shot": LlamaForSequenceClassification,
           }
           if is_torch_available()
           else {}
       )
       a  :    int       =False
       a  :    Dict       =False

       def 	lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase					:					Tuple								=							LlamaModelTester(self						)
         lowerCAmelCase					:					Optional[int]								=							ConfigTester(self		,					config_class=lowerCamelCase_		,					hidden_size=37						)

       def 	lowercase__							(						self						):






         """simple docstring"""





         self.config_tester.run_common_tests()

       def 	lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase					:					List[str]								=							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*lowerCamelCase_						)

       def 	lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase					:					List[str]								=							self.model_tester.prepare_config_and_inputs()
         for type in ["absolute", "relative_key", "relative_key_query"]:
           lowerCAmelCase					:					str								=							type
           self.model_tester.create_and_check_model(*lowerCamelCase_						)

       def 	lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase						,  lowerCAmelCase					:					Optional[int]								=							self.model_tester.prepare_config_and_inputs_for_common()
         lowerCAmelCase					:					List[str]								=							3
         lowerCAmelCase					:					List[Any]								=							input_dict["input_ids"]
         lowerCAmelCase					:					Optional[Any]								=							input_ids.ne(1						).to(lowerCamelCase_						)
         lowerCAmelCase					:					Tuple								=							ids_tensor([self.model_tester.batch_size]		,					self.model_tester.type_sequence_label_size						)
         lowerCAmelCase					:					int								=							LlamaForSequenceClassification(lowerCamelCase_						)
         model.to(lowerCamelCase_						)
         model.eval()
         lowerCAmelCase					:					List[str]								=							model(lowerCamelCase_		,					attention_mask=lowerCamelCase_		,					labels=lowerCamelCase_						)
         self.assertEqual(result.logits.shape		,					(self.model_tester.batch_size, self.model_tester.num_labels)						)

       def 	lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase						,  lowerCAmelCase					:					str								=							self.model_tester.prepare_config_and_inputs_for_common()
         lowerCAmelCase					:					int								=							3
         lowerCAmelCase					:					str								=							"single_label_classification"
         lowerCAmelCase					:					List[str]								=							input_dict["input_ids"]
         lowerCAmelCase					:					List[Any]								=							input_ids.ne(1						).to(lowerCamelCase_						)
         lowerCAmelCase					:					List[Any]								=							ids_tensor([self.model_tester.batch_size]		,					self.model_tester.type_sequence_label_size						)
         lowerCAmelCase					:					Union[str, Any]								=							LlamaForSequenceClassification(lowerCamelCase_						)
         model.to(lowerCamelCase_						)
         model.eval()
         lowerCAmelCase					:					Optional[Any]								=							model(lowerCamelCase_		,					attention_mask=lowerCamelCase_		,					labels=lowerCamelCase_						)
         self.assertEqual(result.logits.shape		,					(self.model_tester.batch_size, self.model_tester.num_labels)						)

       def 	lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase						,  lowerCAmelCase					:					Union[str, Any]								=							self.model_tester.prepare_config_and_inputs_for_common()
         lowerCAmelCase					:					List[str]								=							3
         lowerCAmelCase					:					List[str]								=							"multi_label_classification"
         lowerCAmelCase					:					Any								=							input_dict["input_ids"]
         lowerCAmelCase					:					Union[str, Any]								=							input_ids.ne(1						).to(lowerCamelCase_						)
         lowerCAmelCase					:					int								=							ids_tensor(
             [self.model_tester.batch_size, config.num_labels]		,					self.model_tester.type_sequence_label_size						).to(torch.float						)
         lowerCAmelCase					:					Dict								=							LlamaForSequenceClassification(lowerCamelCase_						)
         model.to(lowerCamelCase_						)
         model.eval()
         lowerCAmelCase					:					str								=							model(lowerCamelCase_		,					attention_mask=lowerCamelCase_		,					labels=lowerCamelCase_						)
         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						):






         """simple docstring"""





         pass







       @parameterized.expand([("linear",), ("dynamic",)]						)
       def 	lowercase__							(						self		,					snake_case__						):






         """simple docstring"""





         lowerCAmelCase						,  lowerCAmelCase					:					str								=							self.model_tester.prepare_config_and_inputs_for_common()
         lowerCAmelCase					:					List[Any]								=							ids_tensor([1, 10]		,					config.vocab_size						)
         lowerCAmelCase					:					List[Any]								=							ids_tensor([1, int(config.max_position_embeddings * 1.5						)]		,					config.vocab_size						)

         set_seed(42						)  # Fixed seed at init time so the two models get the same random weights
         lowerCAmelCase					:					List[Any]								=							LlamaModel(lowerCamelCase_						)
         original_model.to(lowerCamelCase_						)
         original_model.eval()
         lowerCAmelCase					:					Union[str, Any]								=							original_model(lowerCamelCase_						).last_hidden_state
         lowerCAmelCase					:					Tuple								=							original_model(lowerCamelCase_						).last_hidden_state

         set_seed(42						)  # Fixed seed at init time so the two models get the same random weights
         lowerCAmelCase					:					Any								=							{"type": scaling_type, "factor": 10.0}
         lowerCAmelCase					:					List[str]								=							LlamaModel(lowerCamelCase_						)
         scaled_model.to(lowerCamelCase_						)
         scaled_model.eval()
         lowerCAmelCase					:					Tuple								=							scaled_model(lowerCamelCase_						).last_hidden_state
         lowerCAmelCase					:					Any								=							scaled_model(lowerCamelCase_						).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(lowerCamelCase_		,					lowerCamelCase_		,					atol=1e-5						)						)
         else:
           self.assertFalse(torch.allclose(lowerCamelCase_		,					lowerCamelCase_		,					atol=1e-5						)						)

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


@require_torch
class 				SCREAMING_SNAKE_CASE__    (		unittest.TestCase    ):
       """simple docstring"""


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






         """simple docstring"""





         lowerCAmelCase					:					Union[str, Any]								=							[1, 306, 4_658, 278, 6_593, 310, 2_834, 338]
         lowerCAmelCase					:					Optional[Any]								=							LlamaForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf"		,					device_map="auto"						)
         lowerCAmelCase					:					Optional[int]								=							model(torch.tensor([input_ids]						)						)
         # Expected mean on dim = -1
         lowerCAmelCase					:					Tuple								=							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						)		,					lowerCamelCase_		,					atol=1e-2		,					rtol=1e-2						)
         # slicing logits[0, 0, 0:30]
         # fmt: off
         lowerCAmelCase					:					Dict								=							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]		,					lowerCamelCase_		,					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						):






         """simple docstring"""





         lowerCAmelCase					:					Tuple								=							[1, 306, 4_658, 278, 6_593, 310, 2_834, 338]
         lowerCAmelCase					:					List[Any]								=							LlamaForCausalLM.from_pretrained("meta-llama/Llama-2-13b-hf"		,					device_map="auto"						)
         lowerCAmelCase					:					Tuple								=							model(torch.tensor(lowerCamelCase_						)						)
         # Expected mean on dim = -1
         lowerCAmelCase					:					Tuple								=							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						)		,					lowerCamelCase_		,					atol=1e-2		,					rtol=1e-2						)
         # slicing logits[0, 0, 0:30]
         # fmt: off
         lowerCAmelCase					:					Dict								=							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]		,					lowerCamelCase_		,					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						):






         """simple docstring"""





         lowerCAmelCase					:					List[str]								=							[1, 306, 4_658, 278, 6_593, 310, 2_834, 338]
         lowerCAmelCase					:					int								=							LlamaForCausalLM.from_pretrained("meta-llama/Llama-2-13b-chat-hf"		,					device_map="auto"						)
         lowerCAmelCase					:					str								=							model(torch.tensor(lowerCamelCase_						)						)
         # Expected mean on dim = -1
         lowerCAmelCase					:					Any								=							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						)		,					lowerCamelCase_		,					atol=1e-2		,					rtol=1e-2						)
         # slicing logits[0, 0, 0:30]
         # fmt: off
         lowerCAmelCase					:					List[Any]								=							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						)		,					lowerCamelCase_		,					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						):






         """simple docstring"""





         lowerCAmelCase					:					int								=							[1, 306, 4_658, 278, 6_593, 310, 2_834, 338]
         lowerCAmelCase					:					Any								=							LlamaForCausalLM.from_pretrained("meta-llama/Llama-2-70b-hf"		,					device_map="auto"						)
         lowerCAmelCase					:					Optional[Any]								=							model(torch.tensor(lowerCamelCase_						)						)

         lowerCAmelCase					:					Tuple								=							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						)		,					lowerCamelCase_		,					atol=1e-2		,					rtol=1e-2						)
         # fmt: off
         lowerCAmelCase					:					Optional[int]								=							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]		,					lowerCamelCase_		,					atol=1e-5		,					rtol=1e-5						)







       @unittest.skip("Model is curently gated"						)
       @slow
       def 	lowercase__							(						self						):






         """simple docstring"""





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

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









"""simple docstring"""







from __future__ import annotations

from math import pi

# Define the Reduced Planck Constant ℏ (H bar), speed of light C, value of
# Pi and the function
lowerCAmelCase__				    =       1.0_5_4_5_7_1_8_1_7e-3_4  # unit of ℏ : J * s

lowerCAmelCase__				    =       3e8  # unit of c : m * s^-1
def  a__      (    SCREAMING_SNAKE_CASE   :   float    ,				SCREAMING_SNAKE_CASE   :   float    ,				SCREAMING_SNAKE_CASE   :   float    ):


  '''simple docstring'''







  if (force, area, distance).count(0    ) != 1:
    raise ValueError("One and only one argument must be 0"    )
  if force < 0:
    raise ValueError("Magnitude of force can not be negative"    )
  if distance < 0:
    raise ValueError("Distance can not be negative"    )
  if area < 0:
    raise ValueError("Area can not be negative"    )
  if force == 0:
    lowerCAmelCase					:					Any								=							(REDUCED_PLANCK_CONSTANT * SPEED_OF_LIGHT * pi**2 * area) / (
        2_4_0 * (distance) ** 4
    )
    return {"force": force}
  elif area == 0:
    lowerCAmelCase					:					Any								=							(2_4_0 * force * (distance) ** 4) / (
        REDUCED_PLANCK_CONSTANT * SPEED_OF_LIGHT * pi**2
    )
    return {"area": area}
  elif distance == 0:
    lowerCAmelCase					:					Dict								=							(
        (REDUCED_PLANCK_CONSTANT * SPEED_OF_LIGHT * pi**2 * area) / (2_4_0 * force)
    ) ** (1 / 4)
    return {"distance": distance}
  raise ValueError("One and only one argument must be 0"    )


# Run doctest
if __name__ == "__main__":
     import doctest

     doctest.testmod()





