






import unittest

from parameterized import parameterized

from transformers import OpenLlamaConfig, is_torch_available, set_seed
from transformers.testing_utils import require_torch, 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 OpenLlamaForCausalLM, OpenLlamaForSequenceClassification, OpenLlamaModel
class 						lowerCamelCase_				:







				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       ,					):
								"""simple docstring"""
								__magic_name__		:Union[str, Any]        =      parent
								__magic_name__		:Tuple        =      batch_size
								__magic_name__		:Union[str, Any]        =      seq_length
								__magic_name__		:int        =      is_training
								__magic_name__		:Tuple        =      use_input_mask
								__magic_name__		:Optional[int]        =      use_token_type_ids
								__magic_name__		:Union[str, Any]        =      use_labels
								__magic_name__		:Dict        =      vocab_size
								__magic_name__		:int        =      hidden_size
								__magic_name__		:Union[str, Any]        =      num_hidden_layers
								__magic_name__		:Any        =      num_attention_heads
								__magic_name__		:str        =      intermediate_size
								__magic_name__		:List[Any]        =      hidden_act
								__magic_name__		:Tuple        =      hidden_dropout_prob
								__magic_name__		:Any        =      attention_probs_dropout_prob
								__magic_name__		:Tuple        =      max_position_embeddings
								__magic_name__		:str        =      type_vocab_size
								__magic_name__		:Tuple        =      type_sequence_label_size
								__magic_name__		:Tuple        =      initializer_range
								__magic_name__		:Any        =      num_labels
								__magic_name__		:Tuple        =      num_choices
								__magic_name__		:int        =      scope







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Optional[Any]        =      ids_tensor([self.batch_size, self.seq_length]       ,					self.vocab_size     )

								__magic_name__		:Optional[Any]        =      None
								if self.use_input_mask:
												__magic_name__		:Tuple        =      random_attention_mask([self.batch_size, self.seq_length]     )

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

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

								__magic_name__		:List[Any]        =      self.get_config()

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







				def 			A	(						self     ):
								"""simple docstring"""
								return OpenLlamaConfig(
								    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       ,					use_stable_embedding=__lowerCAmelCase       ,					)







				def 			A	(						self       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase     ):
								"""simple docstring"""
								__magic_name__		:Optional[int]        =      OpenLlamaModel(config=__lowerCAmelCase     )
								model.to(__lowerCAmelCase     )
								model.eval()
								__magic_name__		:Optional[Any]        =      model(__lowerCAmelCase       ,					attention_mask=__lowerCAmelCase     )
								__magic_name__		:Optional[int]        =      model(__lowerCAmelCase     )
								self.parent.assertEqual(result.last_hidden_state.shape       ,					(self.batch_size, self.seq_length, self.hidden_size)     )







				def 			A	(						self       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					):
								"""simple docstring"""
								__magic_name__		:str        =      True
								__magic_name__		:Any        =      OpenLlamaModel(__lowerCAmelCase     )
								model.to(__lowerCAmelCase     )
								model.eval()
								__magic_name__		:Union[str, Any]        =      model(
								    __lowerCAmelCase       ,					attention_mask=__lowerCAmelCase       ,					encoder_hidden_states=__lowerCAmelCase       ,					encoder_attention_mask=__lowerCAmelCase       ,					)
								__magic_name__		:Optional[Any]        =      model(
								    __lowerCAmelCase       ,					attention_mask=__lowerCAmelCase       ,					encoder_hidden_states=__lowerCAmelCase       ,					)
								__magic_name__		:Optional[int]        =      model(__lowerCAmelCase       ,					attention_mask=__lowerCAmelCase     )
								self.parent.assertEqual(result.last_hidden_state.shape       ,					(self.batch_size, self.seq_length, self.hidden_size)     )







				def 			A	(						self       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					):
								"""simple docstring"""
								__magic_name__		:int        =      OpenLlamaForCausalLM(config=__lowerCAmelCase     )
								model.to(__lowerCAmelCase     )
								model.eval()
								__magic_name__		:Optional[Any]        =      model(__lowerCAmelCase       ,					attention_mask=__lowerCAmelCase       ,					labels=__lowerCAmelCase     )
								self.parent.assertEqual(result.logits.shape       ,					(self.batch_size, self.seq_length, self.vocab_size)     )







				def 			A	(						self       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					):
								"""simple docstring"""
								__magic_name__		:List[Any]        =      True
								__magic_name__		:List[str]        =      True
								__magic_name__		:str        =      OpenLlamaForCausalLM(config=__lowerCAmelCase     )
								model.to(__lowerCAmelCase     )
								model.eval()

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

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

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

								__magic_name__		:Union[str, Any]        =      model(
								    __lowerCAmelCase       ,					attention_mask=__lowerCAmelCase       ,					encoder_hidden_states=__lowerCAmelCase       ,					encoder_attention_mask=__lowerCAmelCase       ,					output_hidden_states=__lowerCAmelCase       ,					)['''hidden_states'''][0]
								__magic_name__		: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
								__magic_name__		:str        =      ids_tensor((1,)       ,					output_from_past.shape[-1]     ).item()
								__magic_name__		:str        =      output_from_no_past[:, -3:, random_slice_idx].detach()
								__magic_name__		: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 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Optional[int]        =      self.prepare_config_and_inputs()
								(
								    (
								    __magic_name__
								)     ,				(
								    __magic_name__
								)     ,				(
								    __magic_name__
								)     ,				(
								    __magic_name__
								)     ,				(
								    __magic_name__
								)     ,				(
								    __magic_name__
								)     ,				(
								    __magic_name__
								)     ,				
								)		:Optional[int]        =      config_and_inputs
								__magic_name__		:Optional[Any]        =      {'''input_ids''': input_ids, '''attention_mask''': input_mask}
								return config, inputs_dict







@require_torch
class 						lowerCamelCase_				(      lowerCamelCase			,				lowerCamelCase			,				lowerCamelCase			,				unittest.TestCase ):
				a__					       =  (
				    (OpenLlamaModel, OpenLlamaForCausalLM, OpenLlamaForSequenceClassification) if is_torch_available() else ()
				)
				a__					       =  (OpenLlamaForCausalLM,) if is_torch_available() else ()
				a__					       =  (
				    {
				        '''feature-extraction''': OpenLlamaModel,
				        '''text-classification''': OpenLlamaForSequenceClassification,
				        '''text-generation''': OpenLlamaForCausalLM,
				        '''zero-shot''': OpenLlamaForSequenceClassification,
				    }
				    if is_torch_available()
				    else {}
				)
				a__					       =  False
				a__					       =  False







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Union[str, Any]        =      OpenLlamaModelTester(self     )
								__magic_name__		:List[str]        =      ConfigTester(self       ,					config_class=__lowerCAmelCase       ,					hidden_size=3_7     )







				def 			A	(						self     ):
								"""simple docstring"""
								self.config_tester.run_common_tests()







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Optional[Any]        =      self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*__lowerCAmelCase     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:str        =      self.model_tester.prepare_config_and_inputs()
								for type in ["absolute", "relative_key", "relative_key_query"]:
												__magic_name__		:List[str]        =      type
												self.model_tester.create_and_check_model(*__lowerCAmelCase     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__     ,				__magic_name__		:List[Any]        =      self.model_tester.prepare_config_and_inputs_for_common()
								__magic_name__		:int        =      3
								__magic_name__		:Dict        =      input_dict['''input_ids''']
								__magic_name__		:int        =      input_ids.ne(1     ).to(__lowerCAmelCase     )
								__magic_name__		:List[Any]        =      ids_tensor([self.model_tester.batch_size]       ,					self.model_tester.type_sequence_label_size     )
								__magic_name__		:Any        =      OpenLlamaForSequenceClassification(__lowerCAmelCase     )
								model.to(__lowerCAmelCase     )
								model.eval()
								__magic_name__		:Dict        =      model(__lowerCAmelCase       ,					attention_mask=__lowerCAmelCase       ,					labels=__lowerCAmelCase     )
								self.assertEqual(result.logits.shape       ,					(self.model_tester.batch_size, self.model_tester.num_labels)     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__     ,				__magic_name__		:List[Any]        =      self.model_tester.prepare_config_and_inputs_for_common()
								__magic_name__		:Dict        =      3
								__magic_name__		:int        =      '''single_label_classification'''
								__magic_name__		:Dict        =      input_dict['''input_ids''']
								__magic_name__		:int        =      input_ids.ne(1     ).to(__lowerCAmelCase     )
								__magic_name__		:Optional[int]        =      ids_tensor([self.model_tester.batch_size]       ,					self.model_tester.type_sequence_label_size     )
								__magic_name__		:Union[str, Any]        =      OpenLlamaForSequenceClassification(__lowerCAmelCase     )
								model.to(__lowerCAmelCase     )
								model.eval()
								__magic_name__		:Optional[int]        =      model(__lowerCAmelCase       ,					attention_mask=__lowerCAmelCase       ,					labels=__lowerCAmelCase     )
								self.assertEqual(result.logits.shape       ,					(self.model_tester.batch_size, self.model_tester.num_labels)     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__     ,				__magic_name__		:Optional[Any]        =      self.model_tester.prepare_config_and_inputs_for_common()
								__magic_name__		:Any        =      3
								__magic_name__		:Any        =      '''multi_label_classification'''
								__magic_name__		:Optional[int]        =      input_dict['''input_ids''']
								__magic_name__		:Optional[int]        =      input_ids.ne(1     ).to(__lowerCAmelCase     )
								__magic_name__		:Dict        =      ids_tensor(
								    [self.model_tester.batch_size, config.num_labels]       ,					self.model_tester.type_sequence_label_size     ).to(torch.float     )
								__magic_name__		:Dict        =      OpenLlamaForSequenceClassification(__lowerCAmelCase     )
								model.to(__lowerCAmelCase     )
								model.eval()
								__magic_name__		:Tuple        =      model(__lowerCAmelCase       ,					attention_mask=__lowerCAmelCase       ,					labels=__lowerCAmelCase     )
								self.assertEqual(result.logits.shape       ,					(self.model_tester.batch_size, self.model_tester.num_labels)     )







				@unittest.skip('''Open-Llama buffers include complex numbers, which breaks this test'''     )
				def 			A	(						self     ):
								"""simple docstring"""
								pass







				@parameterized.expand([('''linear''',), ('''dynamic''',)]     )
				def 			A	(						self       ,					__lowerCAmelCase     ):
								"""simple docstring"""
								__magic_name__     ,				__magic_name__		:List[str]        =      self.model_tester.prepare_config_and_inputs_for_common()
								__magic_name__		:Dict        =      ids_tensor([1, 1_0]       ,					config.vocab_size     )
								__magic_name__		: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
								__magic_name__		:List[str]        =      OpenLlamaModel(__lowerCAmelCase     )
								original_model.to(__lowerCAmelCase     )
								original_model.eval()
								__magic_name__		:str        =      original_model(__lowerCAmelCase     ).last_hidden_state
								__magic_name__		:int        =      original_model(__lowerCAmelCase     ).last_hidden_state

								set_seed(4_2     )  # Fixed seed at init time so the two models get the same random weights
								__magic_name__		:Dict        =      {'''type''': scaling_type, '''factor''': 10.0}
								__magic_name__		:str        =      OpenLlamaModel(__lowerCAmelCase     )
								scaled_model.to(__lowerCAmelCase     )
								scaled_model.eval()
								__magic_name__		:Union[str, Any]        =      scaled_model(__lowerCAmelCase     ).last_hidden_state
								__magic_name__		: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     )     )














from __future__ import annotations

from math import pi, sqrt

def      __lowercase					( snake_case,  snake_case ):







				"""simple docstring"""






				if inductance <= 0:
								raise ValueError('''Inductance cannot be 0 or negative''' )

				elif capacitance <= 0:
								raise ValueError('''Capacitance cannot be 0 or negative''' )

				else:
								return (
								    "Resonant frequency",
								    float(1 / (2 * pi * (sqrt(inductance * capacitance ))) ),
								)


if __name__ == "__main__":
					import doctest

					doctest.testmod()






