


'''simple docstring'''




from __future__ import annotations

from math import gcd


def    UpperCAmelCase_  (       A		,	A = 2		,	A = 1		,	A = 3		,	):
   '''simple docstring'''





   if num < 2:
      raise ValueError('The input value cannot be less than 2'      )

   # Because of the relationship between ``f(f(x))`` and ``f(x)``, this
   # algorithm struggles to find factors that are divisible by two.
   # As a workaround, we specifically check for two and even inputs.
   #   See: https://math.stackexchange.com/a/2856214/165820
   if num > 2 and num % 2 == 0:
      return 2

   # Pollard's Rho algorithm requires a function that returns pseudorandom
   # values between 0 <= X < ``num``.  It doesn't need to be random in the
   # sense that the output value is cryptographically secure or difficult
   # to calculate, it only needs to be random in the sense that all output
   # values should be equally likely to appear.
   # For this reason, Pollard suggested using ``f(x) = (x**2 - 1) % num``
   # However, the success of Pollard's algorithm isn't guaranteed and is
   # determined in part by the initial seed and the chosen random function.
   # To make retries easier, we will instead use ``f(x) = (x**2 + C) % num``
   # where ``C`` is a value that we can modify between each attempt.
   def rand_fn(A		,	A		,	A      ) -> int:
      return (pow(A		,	2      ) + step) % modulus

   for _ in range(A      ):
      # These track the position within the cycle detection logic.
      _a					:  List[Any]						=  seed
      _a					:  Any						=  seed

      while True:
         # At each iteration, the tortoise moves one step and the hare moves two.
         _a					:  List[str]						=  rand_fn(A		,	A		,	A      )
         _a					:  int						=  rand_fn(A		,	A		,	A      )
         _a					:  Any						=  rand_fn(A		,	A		,	A      )

         # At some point both the tortoise and the hare will enter a cycle whose
         # length ``p`` is a divisor of ``num``.  Once in that cycle, at some point
         # the tortoise and hare will end up on the same value modulo ``p``.
         # We can detect when this happens because the position difference between
         # the tortoise and the hare will share a common divisor with ``num``.
         _a					:  Dict						=  gcd(hare - tortoise		,	A      )

         if divisor == 1:
            # No common divisor yet, just keep searching.
            continue
         else:
            # We found a common divisor!
            if divisor == num:
               # Unfortunately, the divisor is ``num`` itself and is useless.
               break
            else:
               # The divisor is a nontrivial factor of ``num``!
               return divisor

        # If we made it here, then this attempt failed.
        # We need to pick a new starting seed for the tortoise and hare
        # in addition to a new step value for the random function.
        # To keep this example implementation deterministic, the
        # new values will be generated based on currently available
        # values instead of using something like ``random.randint``.

        # We can use the hare's position as the new seed.
        # This is actually what Richard Brent's the "optimized" variant does.
      _a					:  Optional[Any]						=  hare

      # The new step value for the random function can just be incremented.
      # At first the results will be similar to what the old function would
      # have produced, but the value will quickly diverge after a bit.
      step += 1

   # We haven't found a divisor within the requested number of attempts.
   # We were unlucky or ``num`` itself is actually prime.
   return None


if __name__ == "__main__":
 import argparse

 UpperCAmelCase_      :		Dict          =		argparse.ArgumentParser()
 parser.add_argument(
     "num",
     type=int,
     help="The value to find a divisor of",
 )
 parser.add_argument(
     "--attempts",
     type=int,
     default=3,
     help="The number of attempts before giving up",
 )
 UpperCAmelCase_      :		Tuple          =		parser.parse_args()

 UpperCAmelCase_      :		int          =		pollard_rho(args.num, attempts=args.attempts)
 if divisor is None:
  print(f'''{args.num} is probably prime''')
 else:
  UpperCAmelCase_      :		Optional[int]          =		args.num // divisor
  print(f'''{args.num} = {divisor} * {quotient}''')






'''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 					a			:
 '''simple docstring'''




 def __init__(    self		,      lowerCamelCase_		,      lowerCamelCase_=1_3		,      lowerCamelCase_=7		,      lowerCamelCase_=True		,      lowerCamelCase_=True		,      lowerCamelCase_=False		,      lowerCamelCase_=True		,      lowerCamelCase_=9_9		,      lowerCamelCase_=3_2		,      lowerCamelCase_=5		,      lowerCamelCase_=4		,      lowerCamelCase_=3_7		,      lowerCamelCase_="gelu"		,      lowerCamelCase_=0.1		,      lowerCamelCase_=0.1		,      lowerCamelCase_=5_1_2		,      lowerCamelCase_=1_6		,      lowerCamelCase_=2		,      lowerCamelCase_=0.02		,      lowerCamelCase_=3		,      lowerCamelCase_=4		,      lowerCamelCase_=None		,      )      ->    str:
    _a					:  int						=  parent
    _a					:  str						=  batch_size
    _a					:  Any						=  seq_length
    _a					:  Tuple						=  is_training
    _a					:  int						=  use_input_mask
    _a					:  Any						=  use_token_type_ids
    _a					:  List[Any]						=  use_labels
    _a					:  Optional[int]						=  vocab_size
    _a					:  str						=  hidden_size
    _a					:  Any						=  num_hidden_layers
    _a					:  List[Any]						=  num_attention_heads
    _a					:  Tuple						=  intermediate_size
    _a					:  Optional[int]						=  hidden_act
    _a					:  str						=  hidden_dropout_prob
    _a					:  Tuple						=  attention_probs_dropout_prob
    _a					:  List[Any]						=  max_position_embeddings
    _a					:  Union[str, Any]						=  type_vocab_size
    _a					:  Dict						=  type_sequence_label_size
    _a					:  List[Any]						=  initializer_range
    _a					:  Optional[Any]						=  num_labels
    _a					:  Dict						=  num_choices
    _a					:  Dict						=  scope




 def   __UpperCamelCase   (    self      )      ->    Dict:
    _a					:  Any						=  ids_tensor([self.batch_size, self.seq_length]		,      self.vocab_size      )

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

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

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

    _a					:  List[str]						=  self.get_config()

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




 def   __UpperCamelCase   (    self      )      ->    List[Any]:
    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   __UpperCamelCase   (    self		,      lowerCamelCase_		,      lowerCamelCase_		,      lowerCamelCase_		,      lowerCamelCase_		,      lowerCamelCase_		,      lowerCamelCase_		,      lowerCamelCase_      )      ->    int:
    _a					:  List[Any]						=  LlamaModel(config=lowerCamelCase_      )
    model.to(lowerCamelCase_      )
    model.eval()
    _a					:  Any						=  model(lowerCamelCase_		,      attention_mask=lowerCamelCase_      )
    _a					:  List[Any]						=  model(lowerCamelCase_      )
    self.parent.assertEqual(result.last_hidden_state.shape		,      (self.batch_size, self.seq_length, self.hidden_size)      )




 def   __UpperCamelCase   (    self		,      lowerCamelCase_		,      lowerCamelCase_		,      lowerCamelCase_		,      lowerCamelCase_		,      lowerCamelCase_		,      lowerCamelCase_		,      lowerCamelCase_		,      lowerCamelCase_		,      lowerCamelCase_		,      )      ->    Any:
    _a					:  Dict						=  True
    _a					:  Tuple						=  LlamaModel(lowerCamelCase_      )
    model.to(lowerCamelCase_      )
    model.eval()
    _a					:  List[Any]						=  model(
        lowerCamelCase_		,      attention_mask=lowerCamelCase_		,      encoder_hidden_states=lowerCamelCase_		,      encoder_attention_mask=lowerCamelCase_		,      )
    _a					:  Optional[Any]						=  model(
        lowerCamelCase_		,      attention_mask=lowerCamelCase_		,      encoder_hidden_states=lowerCamelCase_		,      )
    _a					:  str						=  model(lowerCamelCase_		,      attention_mask=lowerCamelCase_      )
    self.parent.assertEqual(result.last_hidden_state.shape		,      (self.batch_size, self.seq_length, self.hidden_size)      )




 def   __UpperCamelCase   (    self		,      lowerCamelCase_		,      lowerCamelCase_		,      lowerCamelCase_		,      lowerCamelCase_		,      lowerCamelCase_		,      lowerCamelCase_		,      lowerCamelCase_		,      lowerCamelCase_		,      lowerCamelCase_		,      )      ->    Dict:
    _a					:  Dict						=  LlamaForCausalLM(config=lowerCamelCase_      )
    model.to(lowerCamelCase_      )
    model.eval()
    _a					:  int						=  model(lowerCamelCase_		,      attention_mask=lowerCamelCase_		,      labels=lowerCamelCase_      )
    self.parent.assertEqual(result.logits.shape		,      (self.batch_size, self.seq_length, self.vocab_size)      )




 def   __UpperCamelCase   (    self		,      lowerCamelCase_		,      lowerCamelCase_		,      lowerCamelCase_		,      lowerCamelCase_		,      lowerCamelCase_		,      lowerCamelCase_		,      lowerCamelCase_		,      lowerCamelCase_		,      lowerCamelCase_		,      )      ->    str:
    _a					:  Optional[Any]						=  True
    _a					:  Tuple						=  True
    _a					:  Optional[int]						=  LlamaForCausalLM(config=lowerCamelCase_      )
    model.to(lowerCamelCase_      )
    model.eval()

    # first forward pass
    _a					:  str						=  model(
        lowerCamelCase_		,      attention_mask=lowerCamelCase_		,      encoder_hidden_states=lowerCamelCase_		,      encoder_attention_mask=lowerCamelCase_		,      use_cache=lowerCamelCase_		,      )
    _a					:  Union[str, Any]						=  outputs.past_key_values

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

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

    _a					:  Any						=  model(
        lowerCamelCase_		,      attention_mask=lowerCamelCase_		,      encoder_hidden_states=lowerCamelCase_		,      encoder_attention_mask=lowerCamelCase_		,      output_hidden_states=lowerCamelCase_		,      )['hidden_states'][0]
    _a					:  List[Any]						=  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
    _a					:  List[Any]						=  ids_tensor((1,)		,      output_from_past.shape[-1]      ).item()
    _a					:  int						=  output_from_no_past[:, -3:, random_slice_idx].detach()
    _a					:  Optional[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   __UpperCamelCase   (    self      )      ->    Tuple:
    _a					:  Optional[int]						=  self.prepare_config_and_inputs()
    (
        (
        _a
    )		,						(
        _a
    )		,						(
        _a
    )		,						(
        _a
    )		,						(
        _a
    )		,						(
        _a
    )		,						(
        _a
    )		,						
    )					:  Dict						=  config_and_inputs
    _a					:  Tuple						=  {'input_ids': input_ids, 'attention_mask': input_mask}
    return config, inputs_dict







@require_torch
class 					a			(				snake_case__			,							snake_case__			,							snake_case__			,							unittest.TestCase  ):
 '''simple docstring'''




 __lowerCAmelCase						: Optional[int]							  =		(LlamaModel, LlamaForCausalLM, LlamaForSequenceClassification) if is_torch_available() else ()
 __lowerCAmelCase						: int							  =		(LlamaForCausalLM,) if is_torch_available() else ()
 __lowerCAmelCase						: int							  =		(
     {
         """feature-extraction""": LlamaModel,
         """text-classification""": LlamaForSequenceClassification,
         """text-generation""": LlamaForCausalLM,
         """zero-shot""": LlamaForSequenceClassification,
     }
     if is_torch_available()
     else {}
 )
 __lowerCAmelCase						: str							  =		False
 __lowerCAmelCase						: List[Any]							  =		False




 def   __UpperCamelCase   (    self      )      ->    str:
    _a					:  Optional[int]						=  LlamaModelTester(self      )
    _a					:  Tuple						=  ConfigTester(self		,      config_class=lowerCamelCase_		,      hidden_size=3_7      )




 def   __UpperCamelCase   (    self      )      ->    Any:
    self.config_tester.run_common_tests()




 def   __UpperCamelCase   (    self      )      ->    Union[str, Any]:
    _a					:  Dict						=  self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_model(*lowerCamelCase_      )




 def   __UpperCamelCase   (    self      )      ->    Optional[Any]:
    _a					:  Tuple						=  self.model_tester.prepare_config_and_inputs()
    for type in ["absolute", "relative_key", "relative_key_query"]:
       _a					:  List[str]						=  type
       self.model_tester.create_and_check_model(*lowerCamelCase_      )




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




 def   __UpperCamelCase   (    self      )      ->    List[str]:
    _a		,						_a					:  Tuple						=  self.model_tester.prepare_config_and_inputs_for_common()
    _a					:  List[str]						=  3
    _a					:  List[str]						=  'single_label_classification'
    _a					:  Union[str, Any]						=  input_dict['input_ids']
    _a					:  str						=  input_ids.ne(1      ).to(lowerCamelCase_      )
    _a					:  Any						=  ids_tensor([self.model_tester.batch_size]		,      self.model_tester.type_sequence_label_size      )
    _a					:  str						=  LlamaForSequenceClassification(lowerCamelCase_      )
    model.to(lowerCamelCase_      )
    model.eval()
    _a					:  List[Any]						=  model(lowerCamelCase_		,      attention_mask=lowerCamelCase_		,      labels=lowerCamelCase_      )
    self.assertEqual(result.logits.shape		,      (self.model_tester.batch_size, self.model_tester.num_labels)      )




 def   __UpperCamelCase   (    self      )      ->    Tuple:
    _a		,						_a					:  Union[str, Any]						=  self.model_tester.prepare_config_and_inputs_for_common()
    _a					:  Union[str, Any]						=  3
    _a					:  str						=  'multi_label_classification'
    _a					:  Union[str, Any]						=  input_dict['input_ids']
    _a					:  Union[str, Any]						=  input_ids.ne(1      ).to(lowerCamelCase_      )
    _a					:  str						=  ids_tensor(
        [self.model_tester.batch_size, config.num_labels]		,      self.model_tester.type_sequence_label_size      ).to(torch.float      )
    _a					:  str						=  LlamaForSequenceClassification(lowerCamelCase_      )
    model.to(lowerCamelCase_      )
    model.eval()
    _a					:  int						=  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   __UpperCamelCase   (    self      )      ->    Optional[int]:
    pass




 @parameterized.expand([('linear',), ('dynamic',)]      )
 def   __UpperCamelCase   (    self		,      lowerCamelCase_      )      ->    List[str]:
    _a		,						_a					:  Dict						=  self.model_tester.prepare_config_and_inputs_for_common()
    _a					:  Union[str, Any]						=  ids_tensor([1, 1_0]		,      config.vocab_size      )
    _a					:  Optional[Any]						=  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					:  int						=  LlamaModel(lowerCamelCase_      )
    original_model.to(lowerCamelCase_      )
    original_model.eval()
    _a					:  str						=  original_model(lowerCamelCase_      ).last_hidden_state
    _a					:  Union[str, Any]						=  original_model(lowerCamelCase_      ).last_hidden_state

    set_seed(4_2      )  # Fixed seed at init time so the two models get the same random weights
    _a					:  Optional[Any]						=  {'type': scaling_type, 'factor': 10.0}
    _a					:  Any						=  LlamaModel(lowerCamelCase_      )
    scaled_model.to(lowerCamelCase_      )
    scaled_model.eval()
    _a					:  Optional[int]						=  scaled_model(lowerCamelCase_      ).last_hidden_state
    _a					:  int						=  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 					a			(				unittest.TestCase  ):
 '''simple docstring'''




 @unittest.skip('Logits are not exactly the same, once we fix the instabalities somehow, will update!'      )
 @slow
 def   __UpperCamelCase   (    self      )      ->    int:
    _a					:  Optional[Any]						=  [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					:  Optional[int]						=  LlamaForCausalLM.from_pretrained('meta-llama/Llama-2-7b-hf'		,      device_map='auto'      )
    _a					:  Tuple						=  model(torch.tensor([input_ids]      )      )
    # Expected mean on dim = -1
    _a					:  List[Any]						=  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
    _a					:  str						=  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, :3_0]		,      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   __UpperCamelCase   (    self      )      ->    Optional[int]:
    _a					:  Any						=  [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					:  Any						=  LlamaForCausalLM.from_pretrained('meta-llama/Llama-2-13b-hf'		,      device_map='auto'      )
    _a					:  List[Any]						=  model(torch.tensor(lowerCamelCase_      )      )
    # Expected mean on dim = -1
    _a					:  Optional[int]						=  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
    _a					:  List[Any]						=  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, :3_0]		,      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   __UpperCamelCase   (    self      )      ->    Any:
    _a					:  Optional[int]						=  [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					:  Union[str, Any]						=  LlamaForCausalLM.from_pretrained('meta-llama/Llama-2-13b-chat-hf'		,      device_map='auto'      )
    _a					:  str						=  model(torch.tensor(lowerCamelCase_      )      )
    # Expected mean on dim = -1
    _a					:  int						=  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
    _a					:  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   __UpperCamelCase   (    self      )      ->    Dict:
    _a					:  Dict						=  [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					:  str						=  LlamaForCausalLM.from_pretrained('meta-llama/Llama-2-70b-hf'		,      device_map='auto'      )
    _a					:  Dict						=  model(torch.tensor(lowerCamelCase_      )      )

    _a					:  str						=  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
    _a					:  Any						=  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, :3_0]		,      lowerCamelCase_		,      atol=1e-5		,      rtol=1e-5      )




 @unittest.skip('Model is curently gated'      )
 @slow
 def   __UpperCamelCase   (    self      )      ->    Optional[Any]:
    _a					:  List[Any]						=  '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					:  List[Any]						=  'Simply put, the theory of relativity states that '
    _a					:  List[Any]						=  LlamaTokenizer.from_pretrained('meta-llama/Llama-2-13b-chat-hf'      )
    _a					:  Any						=  tokenizer.encode(lowerCamelCase_		,      return_tensors='pt'      )
    _a					:  Union[str, Any]						=  LlamaForCausalLM.from_pretrained(
        'meta-llama/Llama-2-13b-chat-hf'		,      device_map='sequential'		,      use_safetensors=lowerCamelCase_      )

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


