
"""simple docstring"""







import unittest

from transformers import AutoTokenizer, FalconConfig, is_torch_available
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 (
						    FalconForCausalLM,
						    FalconForQuestionAnswering,
						    FalconForSequenceClassification,
						    FalconForTokenClassification,
						    FalconModel,
						)




class 				A__ :

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

		def 							__lowerCamelCase							(   self				):
			__lowerCAmelCase    :		Union[str, Any]		    =   ids_tensor([self.batch_size, self.seq_length] ,	self.vocab_size				)

			__lowerCAmelCase    :		Any		    =   None
			if self.use_input_mask:
				__lowerCAmelCase    :		List[Any]		    =   random_attention_mask([self.batch_size, self.seq_length]				)

			__lowerCAmelCase    :		str		    =   None

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

			__lowerCAmelCase    :		Any		    =   self.get_config()

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

		def 							__lowerCamelCase							(   self				):
			return FalconConfig(
			    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 ,	pad_token_id=1 ,	new_decoder_architecture=lowerCAmelCase_ ,	)

		def 							__lowerCamelCase							(   self ,	_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE				):
			__lowerCAmelCase    :		Optional[int]		    =   FalconModel(config=lowerCAmelCase_				)
			model.to(lowerCAmelCase_				)
			model.eval()
			__lowerCAmelCase    :		Optional[Any]		    =   model(lowerCAmelCase_ ,	attention_mask=lowerCAmelCase_				)
			__lowerCAmelCase    :		Optional[Any]		    =   model(lowerCAmelCase_				)
			self.parent.assertEqual(result.last_hidden_state.shape ,	(self.batch_size, self.seq_length, self.hidden_size)				)

		def 							__lowerCamelCase							(   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 ,	):
			__lowerCAmelCase    :		Optional[int]		    =   True
			__lowerCAmelCase    :		Dict		    =   FalconModel(lowerCAmelCase_				)
			model.to(lowerCAmelCase_				)
			model.eval()
			__lowerCAmelCase    :		Dict		    =   model(
			    lowerCAmelCase_ ,	attention_mask=lowerCAmelCase_ ,	encoder_hidden_states=lowerCAmelCase_ ,	encoder_attention_mask=lowerCAmelCase_ ,	)
			__lowerCAmelCase    :		List[str]		    =   model(
			    lowerCAmelCase_ ,	attention_mask=lowerCAmelCase_ ,	encoder_hidden_states=lowerCAmelCase_ ,	)
			__lowerCAmelCase    :		Union[str, Any]		    =   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 ,	_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 ,	):
			__lowerCAmelCase    :		str		    =   FalconForCausalLM(config=lowerCAmelCase_				)
			model.to(lowerCAmelCase_				)
			model.eval()
			__lowerCAmelCase    :		int		    =   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 ,	_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 ,	):
			__lowerCAmelCase    :		List[Any]		    =   True
			__lowerCAmelCase    :		Any		    =   True
			__lowerCAmelCase    :		List[Any]		    =   FalconForCausalLM(config=lowerCAmelCase_				)
			model.to(lowerCAmelCase_				)
			model.eval()

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

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

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

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




@require_torch
class 				A__ (			__UpperCAmelCase ,  __UpperCAmelCase ,  __UpperCAmelCase ,  unittest.TestCase):
		A_		: List[str]            =			(
		    (
		        FalconModel,
		        FalconForCausalLM,
		        FalconForSequenceClassification,
		        FalconForTokenClassification,
		        FalconForQuestionAnswering,
		    )
		    if is_torch_available()
		    else ()
		)
		A_		: Optional[int]            =			(FalconForCausalLM,) if is_torch_available() else ()
		A_		: List[Any]            =			(
		    {
		        'feature-extraction': FalconModel,
		        'text-classification': FalconForSequenceClassification,
		        'text-generation': FalconForCausalLM,
		        'question-answering': FalconForQuestionAnswering,
		        'token-classification': FalconForTokenClassification,
		        'zero-shot': FalconForSequenceClassification,
		    }
		    if is_torch_available()
		    else {}
		)
		A_		: Any            =			False
		A_		: str            =			False

		def 							__lowerCamelCase							(   self				):
			__lowerCAmelCase    :		Union[str, Any]		    =   FalconModelTester(self				)
			__lowerCAmelCase    :		List[Any]		    =   ConfigTester(self ,	config_class=lowerCAmelCase_ ,	hidden_size=37				)

		def 							__lowerCamelCase							(   self				):
			self.config_tester.run_common_tests()

		def 							__lowerCamelCase							(   self				):
			__lowerCAmelCase    :		Dict		    =   self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_model(*lowerCAmelCase_				)

		def 							__lowerCamelCase							(   self				):
			__lowerCAmelCase    ,     *__lowerCAmelCase    :		List[str]		    =   self.model_tester.prepare_config_and_inputs()
			for alibi in [True, False]:
				__lowerCAmelCase    :		Optional[int]		    =   alibi
				self.model_tester.create_and_check_model(lowerCAmelCase_ ,	*lowerCAmelCase_				)

		def 							__lowerCamelCase							(   self				):
			__lowerCAmelCase    ,     __lowerCAmelCase    :		Union[str, Any]		    =   self.model_tester.prepare_config_and_inputs_for_common()
			__lowerCAmelCase    :		Optional[int]		    =   3
			__lowerCAmelCase    :		Optional[Any]		    =   input_dict['input_ids']
			__lowerCAmelCase    :		Optional[Any]		    =   input_ids.ne(1				).to(lowerCAmelCase_				)
			__lowerCAmelCase    :		Optional[int]		    =   ids_tensor([self.model_tester.batch_size] ,	self.model_tester.type_sequence_label_size				)
			__lowerCAmelCase    :		List[str]		    =   FalconForSequenceClassification(lowerCAmelCase_				)
			model.to(lowerCAmelCase_				)
			model.eval()
			__lowerCAmelCase    :		str		    =   model(lowerCAmelCase_ ,	attention_mask=lowerCAmelCase_ ,	labels=lowerCAmelCase_				)
			self.assertEqual(result.logits.shape ,	(self.model_tester.batch_size, self.model_tester.num_labels)				)

		def 							__lowerCamelCase							(   self				):
			__lowerCAmelCase    ,     __lowerCAmelCase    :		Tuple		    =   self.model_tester.prepare_config_and_inputs_for_common()
			__lowerCAmelCase    :		Any		    =   3
			__lowerCAmelCase    :		Any		    =   'single_label_classification'
			__lowerCAmelCase    :		Optional[int]		    =   input_dict['input_ids']
			__lowerCAmelCase    :		Optional[int]		    =   input_ids.ne(1				).to(lowerCAmelCase_				)
			__lowerCAmelCase    :		List[Any]		    =   ids_tensor([self.model_tester.batch_size] ,	self.model_tester.type_sequence_label_size				)
			__lowerCAmelCase    :		Union[str, Any]		    =   FalconForSequenceClassification(lowerCAmelCase_				)
			model.to(lowerCAmelCase_				)
			model.eval()
			__lowerCAmelCase    :		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 							__lowerCamelCase							(   self				):
			__lowerCAmelCase    ,     __lowerCAmelCase    :		Optional[Any]		    =   self.model_tester.prepare_config_and_inputs_for_common()
			__lowerCAmelCase    :		List[str]		    =   input_dict['input_ids']
			__lowerCAmelCase    :		List[str]		    =   FalconForCausalLM(lowerCAmelCase_				)
			model.to(lowerCAmelCase_				)
			model.eval()
			__lowerCAmelCase    :		Any		    =   model(lowerCAmelCase_ ,	use_cache=lowerCAmelCase_				)
			__lowerCAmelCase    :		List[str]		    =   input_ids.shape[0]
			__lowerCAmelCase    :		Tuple		    =   model._convert_to_rw_cache(result.past_key_values				)
			__lowerCAmelCase    :		List[str]		    =   model._convert_cache_to_standard_format(lowerCAmelCase_ ,	lowerCAmelCase_				)
			for layer in range(len(lowerCAmelCase_				)				):
				for tensor_idx in range(2				):
					self.assertTrue(rw_cache[layer][tensor_idx].ndim == 3				)
					self.assertTrue(result.past_key_values[layer][tensor_idx].ndim == 4				)
					self.assertTrue(
					    torch.all(result.past_key_values[layer][tensor_idx] == standard_cache[layer][tensor_idx]				)				)

		def 							__lowerCamelCase							(   self				):
			__lowerCAmelCase    ,     __lowerCAmelCase    :		Union[str, Any]		    =   self.model_tester.prepare_config_and_inputs_for_common()
			__lowerCAmelCase    :		Tuple		    =   3
			__lowerCAmelCase    :		Any		    =   'multi_label_classification'
			__lowerCAmelCase    :		Tuple		    =   input_dict['input_ids']
			__lowerCAmelCase    :		List[Any]		    =   input_ids.ne(1				).to(lowerCAmelCase_				)
			__lowerCAmelCase    :		int		    =   ids_tensor(
			    [self.model_tester.batch_size, config.num_labels] ,	self.model_tester.type_sequence_label_size				).to(torch.float				)
			__lowerCAmelCase    :		int		    =   FalconForSequenceClassification(lowerCAmelCase_				)
			model.to(lowerCAmelCase_				)
			model.eval()
			__lowerCAmelCase    :		str		    =   model(lowerCAmelCase_ ,	attention_mask=lowerCAmelCase_ ,	labels=lowerCAmelCase_				)
			self.assertEqual(result.logits.shape ,	(self.model_tester.batch_size, self.model_tester.num_labels)				)







		def 							__lowerCamelCase							(   self				):







			for model_class in self.all_generative_model_classes:
				__lowerCAmelCase    ,     __lowerCAmelCase    :		Any		    =   self.model_tester.prepare_config_and_inputs_for_common()

				# If it doesn't support cache, pass the test
				if not hasattr(lowerCAmelCase_ ,	'use_cache'				):
					return

				__lowerCAmelCase    :		Optional[Any]		    =   model_class(lowerCAmelCase_				).to(lowerCAmelCase_				)
				if "use_cache" not in inputs:
					__lowerCAmelCase    :		Optional[Any]		    =   True
				__lowerCAmelCase    :		Optional[int]		    =   model(**lowerCAmelCase_				)

				# If "past_key_values" is not returned, pass the test (e.g. RWKV uses a different cache name and format)
				if "past_key_values" not in outputs:
					return

				__lowerCAmelCase    :		Tuple		    =   (
				    getattr(lowerCAmelCase_ ,	'decoder_layers' ,	lowerCAmelCase_				)
				    or getattr(lowerCAmelCase_ ,	'num_decoder_layers' ,	lowerCAmelCase_				)
				    or config.num_hidden_layers
				)
				__lowerCAmelCase    :		Dict		    =   getattr(lowerCAmelCase_ ,	'num_kv_heads' ,	config.num_attention_heads				)
				__lowerCAmelCase    :		List[Any]		    =   getattr(lowerCAmelCase_ ,	'd_model' ,	config.hidden_size				)
				__lowerCAmelCase    :		List[Any]		    =   embed_dim // num_attention_heads

				__lowerCAmelCase    :		Dict		    =   outputs['past_key_values']
				self.assertEqual(len(lowerCAmelCase_				) ,	lowerCAmelCase_				)

				__lowerCAmelCase    ,     __lowerCAmelCase    :		int		    =   inputs['input_ids'].shape
				for i in range(lowerCAmelCase_				):
					if config.new_decoder_architecture:
						__lowerCAmelCase    :		int		    =   config.num_attention_heads
					elif config.multi_query:
						__lowerCAmelCase    :		Tuple		    =   1
					self.assertEqual(len(past_kv[0]				) ,	2				)  # K V for the decoder = 2
					self.assertEqual(
					    past_kv[i][0].shape ,	(batch_size, num_attention_heads, seq_length, per_head_embed_dim)				)
					self.assertEqual(
					    past_kv[i][1].shape ,	(batch_size, num_attention_heads, seq_length, per_head_embed_dim)				)




@require_torch
class 				A__ (			unittest.TestCase):

		@slow
		def 							__lowerCamelCase							(   self				):
			__lowerCAmelCase    :		Union[str, Any]		    =   AutoTokenizer.from_pretrained('Rocketknight1/falcon-rw-1b'				)
			__lowerCAmelCase    :		Any		    =   FalconForCausalLM.from_pretrained('Rocketknight1/falcon-rw-1b'				)
			model.eval()
			model.to(lowerCAmelCase_				)
			__lowerCAmelCase    :		List[Any]		    =   tokenizer('My favorite food is' ,	return_tensors='pt'				).to(lowerCAmelCase_				)

			__lowerCAmelCase    :		str		    =   (
			    'My favorite food is pizza. I love it so much that I have a pizza party every year for my birthday.'
			)

			__lowerCAmelCase    :		Optional[Any]		    =   model.generate(**lowerCAmelCase_ ,	do_sample=lowerCAmelCase_ ,	max_new_tokens=19				)
			__lowerCAmelCase    :		str		    =   tokenizer.batch_decode(lowerCAmelCase_				)[0]

			self.assertEqual(lowerCAmelCase_ ,	lowerCAmelCase_				)

		@slow
		def 							__lowerCamelCase							(   self				):







			for repo in ["Rocketknight1/tiny-random-falcon-7b", "Rocketknight1/tiny-random-falcon-40b"]:
				__lowerCAmelCase    :		int		    =   AutoTokenizer.from_pretrained(lowerCAmelCase_				)
				__lowerCAmelCase    :		List[str]		    =   FalconForCausalLM.from_pretrained(lowerCAmelCase_				)
				model.eval()
				model.to(lowerCAmelCase_				)
				__lowerCAmelCase    :		Any		    =   tokenizer('My favorite food is' ,	return_tensors='pt'				).to(lowerCAmelCase_				)

				# We just test that these run without errors - the models are randomly initialized
				# and so the actual text outputs will be garbage
				model.generate(**lowerCAmelCase_ ,	do_sample=lowerCAmelCase_ ,	max_new_tokens=4				)
				model.generate(**lowerCAmelCase_ ,	do_sample=lowerCAmelCase_ ,	max_new_tokens=4				)
				model.generate(**lowerCAmelCase_ ,	num_beams=2 ,	max_new_tokens=4				)







		@slow
		def 							__lowerCamelCase							(   self				):







			with torch.no_grad():
				for repo in [
				    "Rocketknight1/falcon-rw-1b",
				    "Rocketknight1/tiny-random-falcon-7b",
				    "Rocketknight1/tiny-random-falcon-40b",
				]:
					__lowerCAmelCase    :		Optional[Any]		    =   AutoTokenizer.from_pretrained(lowerCAmelCase_				)
					__lowerCAmelCase    :		Any		    =   FalconForCausalLM.from_pretrained(lowerCAmelCase_				)
					model.eval()
					model.to(device=lowerCAmelCase_				)
					__lowerCAmelCase    :		Tuple		    =   tokenizer('My favorite food is' ,	return_tensors='pt'				).to(lowerCAmelCase_				)

					# Test results are the same with and without cache
					__lowerCAmelCase    :		Dict		    =   model.generate(**lowerCAmelCase_ ,	do_sample=lowerCAmelCase_ ,	max_new_tokens=20 ,	use_cache=lowerCAmelCase_				)
					__lowerCAmelCase    :		str		    =   model.generate(**lowerCAmelCase_ ,	do_sample=lowerCAmelCase_ ,	max_new_tokens=20 ,	use_cache=lowerCAmelCase_				)
					self.assertTrue((outputs_cache - outputs_no_cache).sum().item() == 0				)

"""simple docstring"""







def 					__lowerCAmelCase       (_UpperCamelCase ,						_UpperCamelCase	):

	if density <= 0:
		raise ValueError('Impossible fluid density'	)
	if bulk_modulus <= 0:
		raise ValueError('Impossible bulk modulus'	)

	return (bulk_modulus / density) ** 0.5


if __name__ == "__main__":
							import doctest

							doctest.testmod()