
"""simple docstring"""




from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    convert_to_rgb,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    OPENAI_CLIP_MEAN,
    OPENAI_CLIP_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


a		:       str     						=       logging.get_logger(__name__)


if is_vision_available():
    import PIL







class     lowercase(_lowercase       ):
     __snake_case:	str						=     ['pixel_values']



     def __init__(							self     ,				__SCREAMING_SNAKE_CASE = True     ,				__SCREAMING_SNAKE_CASE = None     ,				__SCREAMING_SNAKE_CASE = PILImageResampling.BICUBIC     ,				__SCREAMING_SNAKE_CASE = True     ,				__SCREAMING_SNAKE_CASE = None     ,				__SCREAMING_SNAKE_CASE = True     ,				__SCREAMING_SNAKE_CASE = 1 / 2_5_5     ,				__SCREAMING_SNAKE_CASE = True     ,				__SCREAMING_SNAKE_CASE = None     ,				__SCREAMING_SNAKE_CASE = None     ,				__SCREAMING_SNAKE_CASE = True     ,				**__SCREAMING_SNAKE_CASE     ,				)		->     None:







         """simple docstring"""



         super().__init__(**__SCREAMING_SNAKE_CASE   )
         a__		=			size if size is not None else {'shortest_edge': 2_2_4}
         a__		=			get_size_dict(__SCREAMING_SNAKE_CASE     ,				default_to_square=__SCREAMING_SNAKE_CASE   )
         a__		=			crop_size if crop_size is not None else {'height': 2_2_4, 'width': 2_2_4}
         a__		=			get_size_dict(__SCREAMING_SNAKE_CASE     ,				default_to_square=__SCREAMING_SNAKE_CASE     ,				param_name='crop_size'   )

         a__		=			do_resize
         a__		=			size
         a__		=			resample
         a__		=			do_center_crop
         a__		=			crop_size
         a__		=			do_rescale
         a__		=			rescale_factor
         a__		=			do_normalize
         a__		=			image_mean if image_mean is not None else OPENAI_CLIP_MEAN
         a__		=			image_std if image_std is not None else OPENAI_CLIP_STD
         a__		=			do_convert_rgb



     def 			lowercase__  (							self     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE = PILImageResampling.BICUBIC     ,				__SCREAMING_SNAKE_CASE = None     ,				**__SCREAMING_SNAKE_CASE     ,				)		->     np.ndarray:







         """simple docstring"""



         a__		=			get_size_dict(__SCREAMING_SNAKE_CASE     ,				default_to_square=__SCREAMING_SNAKE_CASE   )
         if "shortest_edge" not in size:
             raise ValueError(f'The `size` parameter must contain the key `shortest_edge`. Got {size.keys()}'   )
         a__		=			get_resize_output_image_size(__SCREAMING_SNAKE_CASE     ,				size=size['shortest_edge']     ,				default_to_square=__SCREAMING_SNAKE_CASE   )
         return resize(__SCREAMING_SNAKE_CASE     ,				size=__SCREAMING_SNAKE_CASE     ,				resample=__SCREAMING_SNAKE_CASE     ,				data_format=__SCREAMING_SNAKE_CASE     ,				**__SCREAMING_SNAKE_CASE   )



     def 			lowercase__  (							self     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE = None     ,				**__SCREAMING_SNAKE_CASE     ,				)		->     np.ndarray:







         """simple docstring"""



         a__		=			get_size_dict(__SCREAMING_SNAKE_CASE   )
         if "height" not in size or "width" not in size:
             raise ValueError(f'The `size` parameter must contain the keys (height, width). Got {size.keys()}'   )
         return center_crop(__SCREAMING_SNAKE_CASE     ,				size=(size['height'], size['width'])     ,				data_format=__SCREAMING_SNAKE_CASE     ,				**__SCREAMING_SNAKE_CASE   )



     def 			lowercase__  (							self     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE = None     ,				**__SCREAMING_SNAKE_CASE     ,				)		->     List[Any]:







         """simple docstring"""



         return rescale(__SCREAMING_SNAKE_CASE     ,				scale=__SCREAMING_SNAKE_CASE     ,				data_format=__SCREAMING_SNAKE_CASE     ,				**__SCREAMING_SNAKE_CASE   )



     def 			lowercase__  (							self     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE = None     ,				**__SCREAMING_SNAKE_CASE     ,				)		->     np.ndarray:







         """simple docstring"""



         return normalize(__SCREAMING_SNAKE_CASE     ,				mean=__SCREAMING_SNAKE_CASE     ,				std=__SCREAMING_SNAKE_CASE     ,				data_format=__SCREAMING_SNAKE_CASE     ,				**__SCREAMING_SNAKE_CASE   )




     def 			lowercase__  (							self     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE = None     ,				__SCREAMING_SNAKE_CASE = None     ,				__SCREAMING_SNAKE_CASE = None     ,				__SCREAMING_SNAKE_CASE = None     ,				__SCREAMING_SNAKE_CASE = None     ,				__SCREAMING_SNAKE_CASE = None     ,				__SCREAMING_SNAKE_CASE = None     ,				__SCREAMING_SNAKE_CASE = None     ,				__SCREAMING_SNAKE_CASE = None     ,				__SCREAMING_SNAKE_CASE = None     ,				__SCREAMING_SNAKE_CASE = None     ,				__SCREAMING_SNAKE_CASE = None     ,				__SCREAMING_SNAKE_CASE = ChannelDimension.FIRST     ,				**__SCREAMING_SNAKE_CASE     ,				)		->     PIL.Image.Image:







         """simple docstring"""



         a__		=			do_resize if do_resize is not None else self.do_resize
         a__		=			size if size is not None else self.size
         a__		=			get_size_dict(__SCREAMING_SNAKE_CASE     ,				param_name='size'     ,				default_to_square=__SCREAMING_SNAKE_CASE   )
         a__		=			resample if resample is not None else self.resample
         a__		=			do_center_crop if do_center_crop is not None else self.do_center_crop
         a__		=			crop_size if crop_size is not None else self.crop_size
         a__		=			get_size_dict(__SCREAMING_SNAKE_CASE     ,				param_name='crop_size'     ,				default_to_square=__SCREAMING_SNAKE_CASE   )
         a__		=			do_rescale if do_rescale is not None else self.do_rescale
         a__		=			rescale_factor if rescale_factor is not None else self.rescale_factor
         a__		=			do_normalize if do_normalize is not None else self.do_normalize
         a__		=			image_mean if image_mean is not None else self.image_mean
         a__		=			image_std if image_std is not None else self.image_std
         a__		=			do_convert_rgb if do_convert_rgb is not None else self.do_convert_rgb

         a__		=			make_list_of_images(__SCREAMING_SNAKE_CASE   )

         if not valid_images(__SCREAMING_SNAKE_CASE   ):
             raise ValueError(
                 'Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, '
                 'torch.Tensor, tf.Tensor or jax.ndarray.'   )

         if do_resize and size is None:
             raise ValueError('Size must be specified if do_resize is True.'   )

         if do_center_crop and crop_size is None:
             raise ValueError('Crop size must be specified if do_center_crop is True.'   )

         if do_rescale and rescale_factor is None:
             raise ValueError('Rescale factor must be specified if do_rescale is True.'   )

         if do_normalize and (image_mean is None or image_std is None):
             raise ValueError('Image mean and std must be specified if do_normalize is True.'   )

         # PIL RGBA images are converted to RGB
         if do_convert_rgb:
             a__		=			[convert_to_rgb(__SCREAMING_SNAKE_CASE   ) for image in images]

         # All transformations expect numpy arrays.
         a__		=			[to_numpy_array(__SCREAMING_SNAKE_CASE   ) for image in images]

         if do_resize:
             a__		=			[self.resize(image=__SCREAMING_SNAKE_CASE     ,				size=__SCREAMING_SNAKE_CASE     ,				resample=__SCREAMING_SNAKE_CASE   ) for image in images]

         if do_center_crop:
             a__		=			[self.center_crop(image=__SCREAMING_SNAKE_CASE     ,				size=__SCREAMING_SNAKE_CASE   ) for image in images]

         if do_rescale:
             a__		=			[self.rescale(image=__SCREAMING_SNAKE_CASE     ,				scale=__SCREAMING_SNAKE_CASE   ) for image in images]

         if do_normalize:
             a__		=			[self.normalize(image=__SCREAMING_SNAKE_CASE     ,				mean=__SCREAMING_SNAKE_CASE     ,				std=__SCREAMING_SNAKE_CASE   ) for image in images]

         a__		=			[to_channel_dimension_format(__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE   ) for image in images]

         a__		=			{'pixel_values': images}
         return BatchFeature(data=__SCREAMING_SNAKE_CASE     ,				tensor_type=__SCREAMING_SNAKE_CASE   )




"""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   )


