




from collections import deque





class        lowerCamelCase_							:


 '''simple docstring'''







 def __init__(							self  :		int				,				_lowerCAmelCase  :		str				,				_lowerCAmelCase  :		int				,				_lowerCAmelCase  :		int						):
       SCREAMING_SNAKE_CASE_							=			process_name  # process name
       SCREAMING_SNAKE_CASE_							=			arrival_time  # arrival time of the process
       # completion time of finished process or last interrupted time
       SCREAMING_SNAKE_CASE_							=			arrival_time
       SCREAMING_SNAKE_CASE_							=			burst_time  # remaining burst time
       SCREAMING_SNAKE_CASE_							=			0  # total time of the process wait in ready queue
       SCREAMING_SNAKE_CASE_							=			0  # time from arrival time to completion time





class        lowerCamelCase_							:


 '''simple docstring'''







 def __init__(							self  :		str				,				_lowerCAmelCase  :		int				,				_lowerCAmelCase  :		list[int]				,				_lowerCAmelCase  :		deque[Process]				,				_lowerCAmelCase  :		int				,				):
       # total number of mlfq's queues
       SCREAMING_SNAKE_CASE_							=			number_of_queues
       # time slice of queues that round robin algorithm applied
       SCREAMING_SNAKE_CASE_							=			time_slices
       # unfinished process is in this ready_queue
       SCREAMING_SNAKE_CASE_							=			queue
       # current time
       SCREAMING_SNAKE_CASE_							=			current_time
       # finished process is in this sequence queue
       SCREAMING_SNAKE_CASE_							=			deque()



 def       lowerCAmelCase_  (							self  :		Any						):
       SCREAMING_SNAKE_CASE_							=			[]
       for i in range(len(self.finish_queue						)						):
             sequence.append(self.finish_queue[i].process_name						)
       return sequence



 def       lowerCAmelCase_  (							self  :		Optional[Any]				,				_lowerCAmelCase  :		list[Process]						):
       SCREAMING_SNAKE_CASE_							=			[]
       for i in range(len(_lowerCAmelCase						)						):
             waiting_times.append(queue[i].waiting_time						)
       return waiting_times



 def       lowerCAmelCase_  (							self  :		Optional[int]				,				_lowerCAmelCase  :		list[Process]						):
       SCREAMING_SNAKE_CASE_							=			[]
       for i in range(len(_lowerCAmelCase						)						):
             turnaround_times.append(queue[i].turnaround_time						)
       return turnaround_times



 def       lowerCAmelCase_  (							self  :		Union[str, Any]				,				_lowerCAmelCase  :		list[Process]						):
       SCREAMING_SNAKE_CASE_							=			[]
       for i in range(len(_lowerCAmelCase						)						):
             completion_times.append(queue[i].stop_time						)
       return completion_times



 def       lowerCAmelCase_  (							self  :		str				,				_lowerCAmelCase  :		deque[Process]						):
       return [q.burst_time for q in queue]



 def       lowerCAmelCase_  (							self  :		Optional[Any]				,				_lowerCAmelCase  :		Process						):
       process.waiting_time += self.current_time - process.stop_time
       return process.waiting_time



 def       lowerCAmelCase_  (							self  :		List[Any]				,				_lowerCAmelCase  :		deque[Process]						):
       SCREAMING_SNAKE_CASE_							=			deque()  # sequence deque of finished process
       while len(_lowerCAmelCase						) != 0:
             SCREAMING_SNAKE_CASE_							=			ready_queue.popleft()  # current process

             # if process's arrival time is later than current time, update current time
             if self.current_time < cp.arrival_time:
                   self.current_time += cp.arrival_time

             # update waiting time of current process
             self.update_waiting_time(_lowerCAmelCase						)
             # update current time
             self.current_time += cp.burst_time
             # finish the process and set the process's burst-time 0
             SCREAMING_SNAKE_CASE_							=			0
             # set the process's turnaround time because it is finished
             SCREAMING_SNAKE_CASE_							=			self.current_time - cp.arrival_time
             # set the completion time
             SCREAMING_SNAKE_CASE_							=			self.current_time
             # add the process to queue that has finished queue
             finished.append(_lowerCAmelCase						)

       self.finish_queue.extend(_lowerCAmelCase						)  # add finished process to finish queue
       # FCFS will finish all remaining processes
       return finished



 def       lowerCAmelCase_  (							self  :		Dict				,				_lowerCAmelCase  :		deque[Process]				,				_lowerCAmelCase  :		int						):
       SCREAMING_SNAKE_CASE_							=			deque()  # sequence deque of terminated process
       # just for 1 cycle and unfinished processes will go back to queue
       for _ in range(len(_lowerCAmelCase						)						):
             SCREAMING_SNAKE_CASE_							=			ready_queue.popleft()  # current process

             # if process's arrival time is later than current time, update current time
             if self.current_time < cp.arrival_time:
                   self.current_time += cp.arrival_time

             # update waiting time of unfinished processes
             self.update_waiting_time(_lowerCAmelCase						)
             # if the burst time of process is bigger than time-slice
             if cp.burst_time > time_slice:
                   # use CPU for only time-slice
                   self.current_time += time_slice
                   # update remaining burst time
                   cp.burst_time -= time_slice
                   # update end point time
                   SCREAMING_SNAKE_CASE_							=			self.current_time
                   # locate the process behind the queue because it is not finished
                   ready_queue.append(_lowerCAmelCase						)
             else:
                   # use CPU for remaining burst time
                   self.current_time += cp.burst_time
                   # set burst time 0 because the process is finished
                   SCREAMING_SNAKE_CASE_							=			0
                   # set the finish time
                   SCREAMING_SNAKE_CASE_							=			self.current_time
                   # update the process' turnaround time because it is finished
                   SCREAMING_SNAKE_CASE_							=			self.current_time - cp.arrival_time
                   # add the process to queue that has finished queue
                   finished.append(_lowerCAmelCase						)

       self.finish_queue.extend(_lowerCAmelCase						)  # add finished process to finish queue
       # return finished processes queue and remaining processes queue
       return finished, ready_queue




 def       lowerCAmelCase_  (							self  :		Tuple						):

       #  all queues except last one have round_robin algorithm
       for i in range(self.number_of_queues - 1						):
             SCREAMING_SNAKE_CASE_						, SCREAMING_SNAKE_CASE_							=			self.round_robin(
                 self.ready_queue				,				self.time_slices[i]						)
       #  the last queue has first_come_first_served algorithm
       self.first_come_first_served(self.ready_queue						)

       return self.finish_queue


if __name__ == "__main__":
   import doctest

   lowerCamelCase__ :   Tuple					=							Process('P1', 0, 53)
   lowerCamelCase__ :   Optional[int]					=							Process('P2', 0, 17)
   lowerCamelCase__ :   Tuple					=							Process('P3', 0, 68)
   lowerCamelCase__ :   Optional[Any]					=							Process('P4', 0, 24)
   lowerCamelCase__ :   Dict					=							3
   lowerCamelCase__ :   int					=							[17, 25]
   lowerCamelCase__ :   str					=							deque([Pa, Pa, Pa, Pa])

   if len(time_slices) != number_of_queues - 1:
      raise SystemExit(0)

   doctest.testmod(extraglobs={'queue': deque([Pa, Pa, Pa, Pa])})

   lowerCamelCase__ :   Tuple					=							Process('P1', 0, 53)
   lowerCamelCase__ :   Optional[int]					=							Process('P2', 0, 17)
   lowerCamelCase__ :   Union[str, Any]					=							Process('P3', 0, 68)
   lowerCamelCase__ :   Any					=							Process('P4', 0, 24)
   lowerCamelCase__ :   Tuple					=							3
   lowerCamelCase__ :   str					=							[17, 25]
   lowerCamelCase__ :   Dict					=							deque([Pa, Pa, Pa, Pa])
   lowerCamelCase__ :   List[Any]					=							MLFQ(number_of_queues, time_slices, queue, 0)
   lowerCamelCase__ :   str					=							mlfq.multi_level_feedback_queue()

   # print total waiting times of processes(P1, P2, P3, P4)
   print(
       f'''waiting time:\
        \t\t\t{MLFQ.calculate_waiting_time(mlfq, [Pa, Pa, Pa, Pa])}'''
   )
   # print completion times of processes(P1, P2, P3, P4)
   print(
       f'''completion time:\
        \t\t{MLFQ.calculate_completion_time(mlfq, [Pa, Pa, Pa, Pa])}'''
   )
   # print total turnaround times of processes(P1, P2, P3, P4)
   print(
       f'''turnaround time:\
        \t\t{MLFQ.calculate_turnaround_time(mlfq, [Pa, Pa, Pa, Pa])}'''
   )
   # print sequence of finished processes
   print(
       f'''sequence of finished processes:\
        {mlfq.calculate_sequence_of_finish_queue()}'''
   )





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


 '''simple docstring'''







 def __init__(							self  :		Optional[Any]				,				_lowerCAmelCase  :		str				,				_lowerCAmelCase  :		Tuple=13				,				_lowerCAmelCase  :		List[str]=7				,				_lowerCAmelCase  :		Dict=True				,				_lowerCAmelCase  :		Dict=True				,				_lowerCAmelCase  :		Optional[int]=False				,				_lowerCAmelCase  :		Any=True				,				_lowerCAmelCase  :		str=99				,				_lowerCAmelCase  :		List[str]=32				,				_lowerCAmelCase  :		Tuple=5				,				_lowerCAmelCase  :		List[str]=4				,				_lowerCAmelCase  :		str=37				,				_lowerCAmelCase  :		Any="gelu"				,				_lowerCAmelCase  :		str=0.1				,				_lowerCAmelCase  :		Union[str, Any]=0.1				,				_lowerCAmelCase  :		Optional[int]=512				,				_lowerCAmelCase  :		Union[str, Any]=16				,				_lowerCAmelCase  :		Tuple=2				,				_lowerCAmelCase  :		Tuple=0.02				,				_lowerCAmelCase  :		Tuple=3				,				_lowerCAmelCase  :		Dict=4				,				_lowerCAmelCase  :		Union[str, Any]=None				,				):
       SCREAMING_SNAKE_CASE_							=			parent
       SCREAMING_SNAKE_CASE_							=			batch_size
       SCREAMING_SNAKE_CASE_							=			seq_length
       SCREAMING_SNAKE_CASE_							=			is_training
       SCREAMING_SNAKE_CASE_							=			use_input_mask
       SCREAMING_SNAKE_CASE_							=			use_token_type_ids
       SCREAMING_SNAKE_CASE_							=			use_labels
       SCREAMING_SNAKE_CASE_							=			vocab_size
       SCREAMING_SNAKE_CASE_							=			hidden_size
       SCREAMING_SNAKE_CASE_							=			num_hidden_layers
       SCREAMING_SNAKE_CASE_							=			num_attention_heads
       SCREAMING_SNAKE_CASE_							=			intermediate_size
       SCREAMING_SNAKE_CASE_							=			hidden_act
       SCREAMING_SNAKE_CASE_							=			hidden_dropout_prob
       SCREAMING_SNAKE_CASE_							=			attention_probs_dropout_prob
       SCREAMING_SNAKE_CASE_							=			max_position_embeddings
       SCREAMING_SNAKE_CASE_							=			type_vocab_size
       SCREAMING_SNAKE_CASE_							=			type_sequence_label_size
       SCREAMING_SNAKE_CASE_							=			initializer_range
       SCREAMING_SNAKE_CASE_							=			num_labels
       SCREAMING_SNAKE_CASE_							=			num_choices
       SCREAMING_SNAKE_CASE_							=			scope



 def       lowerCAmelCase_  (							self  :		List[str]						):
       SCREAMING_SNAKE_CASE_							=			ids_tensor([self.batch_size, self.seq_length]				,				self.vocab_size						)

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

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

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

       SCREAMING_SNAKE_CASE_							=			self.get_config()

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



 def       lowerCAmelCase_  (							self  :		Optional[int]						):
       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       lowerCAmelCase_  (							self  :		Optional[Any]				,				_lowerCAmelCase  :		Tuple				,				_lowerCAmelCase  :		List[Any]				,				_lowerCAmelCase  :		List[Any]				,				_lowerCAmelCase  :		Union[str, Any]				,				_lowerCAmelCase  :		str				,				_lowerCAmelCase  :		str				,				_lowerCAmelCase  :		Optional[Any]						):
       SCREAMING_SNAKE_CASE_							=			LlamaModel(config=_lowerCAmelCase						)
       model.to(_lowerCAmelCase						)
       model.eval()
       SCREAMING_SNAKE_CASE_							=			model(_lowerCAmelCase				,				attention_mask=_lowerCAmelCase						)
       SCREAMING_SNAKE_CASE_							=			model(_lowerCAmelCase						)
       self.parent.assertEqual(result.last_hidden_state.shape				,				(self.batch_size, self.seq_length, self.hidden_size)						)



 def       lowerCAmelCase_  (							self  :		Any				,				_lowerCAmelCase  :		Dict				,				_lowerCAmelCase  :		Optional[Any]				,				_lowerCAmelCase  :		Any				,				_lowerCAmelCase  :		Dict				,				_lowerCAmelCase  :		Any				,				_lowerCAmelCase  :		Tuple				,				_lowerCAmelCase  :		Optional[int]				,				_lowerCAmelCase  :		Optional[Any]				,				_lowerCAmelCase  :		List[str]				,				):
       SCREAMING_SNAKE_CASE_							=			True
       SCREAMING_SNAKE_CASE_							=			LlamaModel(_lowerCAmelCase						)
       model.to(_lowerCAmelCase						)
       model.eval()
       SCREAMING_SNAKE_CASE_							=			model(
           _lowerCAmelCase				,				attention_mask=_lowerCAmelCase				,				encoder_hidden_states=_lowerCAmelCase				,				encoder_attention_mask=_lowerCAmelCase				,				)
       SCREAMING_SNAKE_CASE_							=			model(
           _lowerCAmelCase				,				attention_mask=_lowerCAmelCase				,				encoder_hidden_states=_lowerCAmelCase				,				)
       SCREAMING_SNAKE_CASE_							=			model(_lowerCAmelCase				,				attention_mask=_lowerCAmelCase						)
       self.parent.assertEqual(result.last_hidden_state.shape				,				(self.batch_size, self.seq_length, self.hidden_size)						)



 def       lowerCAmelCase_  (							self  :		int				,				_lowerCAmelCase  :		str				,				_lowerCAmelCase  :		str				,				_lowerCAmelCase  :		List[str]				,				_lowerCAmelCase  :		Any				,				_lowerCAmelCase  :		str				,				_lowerCAmelCase  :		List[Any]				,				_lowerCAmelCase  :		Any				,				_lowerCAmelCase  :		Union[str, Any]				,				_lowerCAmelCase  :		str				,				):
       SCREAMING_SNAKE_CASE_							=			LlamaForCausalLM(config=_lowerCAmelCase						)
       model.to(_lowerCAmelCase						)
       model.eval()
       SCREAMING_SNAKE_CASE_							=			model(_lowerCAmelCase				,				attention_mask=_lowerCAmelCase				,				labels=_lowerCAmelCase						)
       self.parent.assertEqual(result.logits.shape				,				(self.batch_size, self.seq_length, self.vocab_size)						)



 def       lowerCAmelCase_  (							self  :		List[str]				,				_lowerCAmelCase  :		List[str]				,				_lowerCAmelCase  :		Union[str, Any]				,				_lowerCAmelCase  :		List[Any]				,				_lowerCAmelCase  :		Dict				,				_lowerCAmelCase  :		List[Any]				,				_lowerCAmelCase  :		List[Any]				,				_lowerCAmelCase  :		Any				,				_lowerCAmelCase  :		List[str]				,				_lowerCAmelCase  :		List[str]				,				):
       SCREAMING_SNAKE_CASE_							=			True
       SCREAMING_SNAKE_CASE_							=			True
       SCREAMING_SNAKE_CASE_							=			LlamaForCausalLM(config=_lowerCAmelCase						)
       model.to(_lowerCAmelCase						)
       model.eval()

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

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

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

       SCREAMING_SNAKE_CASE_							=			model(
           _lowerCAmelCase				,				attention_mask=_lowerCAmelCase				,				encoder_hidden_states=_lowerCAmelCase				,				encoder_attention_mask=_lowerCAmelCase				,				output_hidden_states=_lowerCAmelCase				,				)['hidden_states'][0]
       SCREAMING_SNAKE_CASE_							=			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
       SCREAMING_SNAKE_CASE_							=			ids_tensor((1,)				,				output_from_past.shape[-1]						).item()
       SCREAMING_SNAKE_CASE_							=			output_from_no_past[:, -3:, random_slice_idx].detach()
       SCREAMING_SNAKE_CASE_							=			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       lowerCAmelCase_  (							self  :		List[str]						):
       SCREAMING_SNAKE_CASE_							=			self.prepare_config_and_inputs()
       (
           (
           SCREAMING_SNAKE_CASE_
       )						, (
           SCREAMING_SNAKE_CASE_
       )						, (
           SCREAMING_SNAKE_CASE_
       )						, (
           SCREAMING_SNAKE_CASE_
       )						, (
           SCREAMING_SNAKE_CASE_
       )						, (
           SCREAMING_SNAKE_CASE_
       )						, (
           SCREAMING_SNAKE_CASE_
       )						, 
       )							=			config_and_inputs
       SCREAMING_SNAKE_CASE_							=			{'input_ids': input_ids, 'attention_mask': input_mask}
       return config, inputs_dict





@require_torch
class        lowerCamelCase_							(      _SCREAMING_SNAKE_CASE       ,   _SCREAMING_SNAKE_CASE       ,   _SCREAMING_SNAKE_CASE       ,   unittest.TestCase					):


 '''simple docstring'''







 lowercase_				    =    (LlamaModel, LlamaForCausalLM, LlamaForSequenceClassification) if is_torch_available() else ()
 lowercase_				    =    (LlamaForCausalLM,) if is_torch_available() else ()
 lowercase_				    =    (
     {
         "feature-extraction": LlamaModel,
         "text-classification": LlamaForSequenceClassification,
         "text-generation": LlamaForCausalLM,
         "zero-shot": LlamaForSequenceClassification,
     }
     if is_torch_available()
     else {}
 )
 lowercase_				    =    False
 lowercase_				    =    False



 def       lowerCAmelCase_  (							self  :		Dict						):
       SCREAMING_SNAKE_CASE_							=			LlamaModelTester(self						)
       SCREAMING_SNAKE_CASE_							=			ConfigTester(self				,				config_class=_lowerCAmelCase				,				hidden_size=37						)



 def       lowerCAmelCase_  (							self  :		Any						):
       self.config_tester.run_common_tests()



 def       lowerCAmelCase_  (							self  :		List[Any]						):
       SCREAMING_SNAKE_CASE_							=			self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*_lowerCAmelCase						)



 def       lowerCAmelCase_  (							self  :		Union[str, Any]						):
       SCREAMING_SNAKE_CASE_							=			self.model_tester.prepare_config_and_inputs()
       for type in ["absolute", "relative_key", "relative_key_query"]:
             SCREAMING_SNAKE_CASE_							=			type
             self.model_tester.create_and_check_model(*_lowerCAmelCase						)



 def       lowerCAmelCase_  (							self  :		str						):
       SCREAMING_SNAKE_CASE_						, SCREAMING_SNAKE_CASE_							=			self.model_tester.prepare_config_and_inputs_for_common()
       SCREAMING_SNAKE_CASE_							=			3
       SCREAMING_SNAKE_CASE_							=			input_dict['input_ids']
       SCREAMING_SNAKE_CASE_							=			input_ids.ne(1						).to(_lowerCAmelCase						)
       SCREAMING_SNAKE_CASE_							=			ids_tensor([self.model_tester.batch_size]				,				self.model_tester.type_sequence_label_size						)
       SCREAMING_SNAKE_CASE_							=			LlamaForSequenceClassification(_lowerCAmelCase						)
       model.to(_lowerCAmelCase						)
       model.eval()
       SCREAMING_SNAKE_CASE_							=			model(_lowerCAmelCase				,				attention_mask=_lowerCAmelCase				,				labels=_lowerCAmelCase						)
       self.assertEqual(result.logits.shape				,				(self.model_tester.batch_size, self.model_tester.num_labels)						)



 def       lowerCAmelCase_  (							self  :		Union[str, Any]						):
       SCREAMING_SNAKE_CASE_						, SCREAMING_SNAKE_CASE_							=			self.model_tester.prepare_config_and_inputs_for_common()
       SCREAMING_SNAKE_CASE_							=			3
       SCREAMING_SNAKE_CASE_							=			'single_label_classification'
       SCREAMING_SNAKE_CASE_							=			input_dict['input_ids']
       SCREAMING_SNAKE_CASE_							=			input_ids.ne(1						).to(_lowerCAmelCase						)
       SCREAMING_SNAKE_CASE_							=			ids_tensor([self.model_tester.batch_size]				,				self.model_tester.type_sequence_label_size						)
       SCREAMING_SNAKE_CASE_							=			LlamaForSequenceClassification(_lowerCAmelCase						)
       model.to(_lowerCAmelCase						)
       model.eval()
       SCREAMING_SNAKE_CASE_							=			model(_lowerCAmelCase				,				attention_mask=_lowerCAmelCase				,				labels=_lowerCAmelCase						)
       self.assertEqual(result.logits.shape				,				(self.model_tester.batch_size, self.model_tester.num_labels)						)



 def       lowerCAmelCase_  (							self  :		List[Any]						):
       SCREAMING_SNAKE_CASE_						, SCREAMING_SNAKE_CASE_							=			self.model_tester.prepare_config_and_inputs_for_common()
       SCREAMING_SNAKE_CASE_							=			3
       SCREAMING_SNAKE_CASE_							=			'multi_label_classification'
       SCREAMING_SNAKE_CASE_							=			input_dict['input_ids']
       SCREAMING_SNAKE_CASE_							=			input_ids.ne(1						).to(_lowerCAmelCase						)
       SCREAMING_SNAKE_CASE_							=			ids_tensor(
           [self.model_tester.batch_size, config.num_labels]				,				self.model_tester.type_sequence_label_size						).to(torch.float						)
       SCREAMING_SNAKE_CASE_							=			LlamaForSequenceClassification(_lowerCAmelCase						)
       model.to(_lowerCAmelCase						)
       model.eval()
       SCREAMING_SNAKE_CASE_							=			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       lowerCAmelCase_  (							self  :		int						):
       pass




 @parameterized.expand([('linear',), ('dynamic',)]						)
 def       lowerCAmelCase_  (							self  :		str				,				_lowerCAmelCase  :		Tuple						):
       SCREAMING_SNAKE_CASE_						, SCREAMING_SNAKE_CASE_							=			self.model_tester.prepare_config_and_inputs_for_common()
       SCREAMING_SNAKE_CASE_							=			ids_tensor([1, 10]				,				config.vocab_size						)
       SCREAMING_SNAKE_CASE_							=			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
       SCREAMING_SNAKE_CASE_							=			LlamaModel(_lowerCAmelCase						)
       original_model.to(_lowerCAmelCase						)
       original_model.eval()
       SCREAMING_SNAKE_CASE_							=			original_model(_lowerCAmelCase						).last_hidden_state
       SCREAMING_SNAKE_CASE_							=			original_model(_lowerCAmelCase						).last_hidden_state

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


 '''simple docstring'''







 @unittest.skip('Logits are not exactly the same, once we fix the instabalities somehow, will update!'						)
 @slow
 def       lowerCAmelCase_  (							self  :		List[str]						):
       SCREAMING_SNAKE_CASE_							=			[1, 306, 4_658, 278, 6_593, 310, 2_834, 338]
       SCREAMING_SNAKE_CASE_							=			LlamaForCausalLM.from_pretrained('meta-llama/Llama-2-7b-hf'				,				device_map='auto'						)
       SCREAMING_SNAKE_CASE_							=			model(torch.tensor([input_ids]						)						)
       # Expected mean on dim = -1
       SCREAMING_SNAKE_CASE_							=			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
       SCREAMING_SNAKE_CASE_							=			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       lowerCAmelCase_  (							self  :		Optional[int]						):
       SCREAMING_SNAKE_CASE_							=			[1, 306, 4_658, 278, 6_593, 310, 2_834, 338]
       SCREAMING_SNAKE_CASE_							=			LlamaForCausalLM.from_pretrained('meta-llama/Llama-2-13b-hf'				,				device_map='auto'						)
       SCREAMING_SNAKE_CASE_							=			model(torch.tensor(_lowerCAmelCase						)						)
       # Expected mean on dim = -1
       SCREAMING_SNAKE_CASE_							=			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
       SCREAMING_SNAKE_CASE_							=			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       lowerCAmelCase_  (							self  :		int						):
       SCREAMING_SNAKE_CASE_							=			[1, 306, 4_658, 278, 6_593, 310, 2_834, 338]
       SCREAMING_SNAKE_CASE_							=			LlamaForCausalLM.from_pretrained('meta-llama/Llama-2-13b-chat-hf'				,				device_map='auto'						)
       SCREAMING_SNAKE_CASE_							=			model(torch.tensor(_lowerCAmelCase						)						)
       # Expected mean on dim = -1
       SCREAMING_SNAKE_CASE_							=			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
       SCREAMING_SNAKE_CASE_							=			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       lowerCAmelCase_  (							self  :		int						):
       SCREAMING_SNAKE_CASE_							=			[1, 306, 4_658, 278, 6_593, 310, 2_834, 338]
       SCREAMING_SNAKE_CASE_							=			LlamaForCausalLM.from_pretrained('meta-llama/Llama-2-70b-hf'				,				device_map='auto'						)
       SCREAMING_SNAKE_CASE_							=			model(torch.tensor(_lowerCAmelCase						)						)

       SCREAMING_SNAKE_CASE_							=			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
       SCREAMING_SNAKE_CASE_							=			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       lowerCAmelCase_  (							self  :		Optional[Any]						):
       SCREAMING_SNAKE_CASE_							=			'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'
       SCREAMING_SNAKE_CASE_							=			'Simply put, the theory of relativity states that '
       SCREAMING_SNAKE_CASE_							=			LlamaTokenizer.from_pretrained('meta-llama/Llama-2-13b-chat-hf'						)
       SCREAMING_SNAKE_CASE_							=			tokenizer.encode(_lowerCAmelCase				,				return_tensors='pt'						)
       SCREAMING_SNAKE_CASE_							=			LlamaForCausalLM.from_pretrained(
           'meta-llama/Llama-2-13b-chat-hf'				,				device_map='sequential'				,				use_safetensors=_lowerCAmelCase						)

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