

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






		"""simple docstring"""


		def __init__(							self						:		Optional[int]     ,       __lowerCamelCase						:		Any     ,       __lowerCamelCase						:		str=3     ,       __lowerCamelCase						:		Union[str, Any]=7     ,       __lowerCamelCase						:		List[Any]=True     ,       __lowerCamelCase						:		List[str]=True     ,       __lowerCamelCase						:		List[str]=False     ,       __lowerCamelCase						:		Tuple=True     ,       __lowerCamelCase						:		Any=99     ,       __lowerCamelCase						:		Tuple=32     ,       __lowerCamelCase						:		List[str]=5     ,       __lowerCamelCase						:		Optional[int]=4     ,       __lowerCamelCase						:		Optional[int]=37     ,       __lowerCamelCase						:		Optional[int]="gelu"     ,       __lowerCamelCase						:		Union[str, Any]=0.1     ,       __lowerCamelCase						:		str=0.1     ,       __lowerCamelCase						:		str=512     ,       __lowerCamelCase						:		List[Any]=16     ,       __lowerCamelCase						:		List[str]=2     ,       __lowerCamelCase						:		int=0.02     ,       __lowerCamelCase						:		Dict=3     ,       __lowerCamelCase						:		Union[str, Any]=4     ,       __lowerCamelCase						:		Optional[int]=None     ,       )		->							Any:
							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 				lowercase_		(							self						:		List[str] )		->							Optional[Any]:
							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

							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 				lowercase_		(							self						:		Optional[int] )		->							int:
							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 				lowercase_		(							self						:		str     ,       __lowerCamelCase						:		Any     ,       __lowerCamelCase						:		Union[str, Any]     ,       __lowerCamelCase						:		Optional[Any]     ,       __lowerCamelCase						:		Tuple     ,       __lowerCamelCase						:		Dict     ,       __lowerCamelCase						:		Tuple     ,       __lowerCamelCase						:		Optional[Any] )		->							Union[str, Any]:
							SCREAMING_SNAKE_CASE__   =   FalconModel(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 				lowercase_		(							self						:		List[Any]     ,       __lowerCamelCase						:		Dict     ,       __lowerCamelCase						:		List[Any]     ,       __lowerCamelCase						:		List[Any]     ,       __lowerCamelCase						:		List[str]     ,       __lowerCamelCase						:		str     ,       __lowerCamelCase						:		Optional[int]     ,       __lowerCamelCase						:		Optional[int]     ,       __lowerCamelCase						:		Dict     ,       __lowerCamelCase						:		Dict     ,       )		->							Optional[int]:
							SCREAMING_SNAKE_CASE__   =   True
							SCREAMING_SNAKE_CASE__   =   FalconModel(__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 				lowercase_		(							self						:		Dict     ,       __lowerCamelCase						:		Union[str, Any]     ,       __lowerCamelCase						:		List[Any]     ,       __lowerCamelCase						:		int     ,       __lowerCamelCase						:		Tuple     ,       __lowerCamelCase						:		Any     ,       __lowerCamelCase						:		Tuple     ,       __lowerCamelCase						:		Any     ,       __lowerCamelCase						:		Union[str, Any]     ,       __lowerCamelCase						:		List[str]     ,       )		->							Optional[Any]:
							SCREAMING_SNAKE_CASE__   =   FalconForCausalLM(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 				lowercase_		(							self						:		Any     ,       __lowerCamelCase						:		str     ,       __lowerCamelCase						:		Optional[int]     ,       __lowerCamelCase						:		List[Any]     ,       __lowerCamelCase						:		str     ,       __lowerCamelCase						:		Dict     ,       __lowerCamelCase						:		str     ,       __lowerCamelCase						:		Any     ,       __lowerCamelCase						:		Dict     ,       __lowerCamelCase						:		List[str]     ,       )		->							Union[str, Any]:
							SCREAMING_SNAKE_CASE__   =   True
							SCREAMING_SNAKE_CASE__   =   True
							SCREAMING_SNAKE_CASE__   =   FalconForCausalLM(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 				lowercase_		(							self						:		Optional[int] )		->							Dict:
							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 	UpperCAmelCase__		(	A__						,					A__						,					A__						,					unittest.TestCase	):






		"""simple docstring"""


		a									= (
		    (
		        FalconModel,
		        FalconForCausalLM,
		        FalconForSequenceClassification,
		        FalconForTokenClassification,
		        FalconForQuestionAnswering,
		    )
		    if is_torch_available()
		    else ()
		)
		a									= (FalconForCausalLM,) if is_torch_available() else ()
		a									= (
		    {
		        "feature-extraction": FalconModel,
		        "text-classification": FalconForSequenceClassification,
		        "text-generation": FalconForCausalLM,
		        "question-answering": FalconForQuestionAnswering,
		        "token-classification": FalconForTokenClassification,
		        "zero-shot": FalconForSequenceClassification,
		    }
		    if is_torch_available()
		    else {}
		)
		a									= False
		a									= False






		def 				lowercase_		(							self						:		int )		->							Optional[int]:
							SCREAMING_SNAKE_CASE__   =   FalconModelTester(self )
							SCREAMING_SNAKE_CASE__   =   ConfigTester(self     ,       config_class=__lowerCamelCase     ,       hidden_size=37 )






		def 				lowercase_		(							self						:		Any )		->							Union[str, Any]:
							self.config_tester.run_common_tests()






		def 				lowercase_		(							self						:		int )		->							List[Any]:
							SCREAMING_SNAKE_CASE__   =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*__lowerCamelCase )






		def 				lowercase_		(							self						:		Union[str, Any] )		->							List[Any]:
							SCREAMING_SNAKE_CASE__,*SCREAMING_SNAKE_CASE__   =   self.model_tester.prepare_config_and_inputs()
							for alibi in [True, False]:
												SCREAMING_SNAKE_CASE__   =   alibi
												self.model_tester.create_and_check_model(__lowerCamelCase     ,       *__lowerCamelCase )






		def 				lowercase_		(							self						:		List[Any] )		->							Optional[Any]:
							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__   =   FalconForSequenceClassification(__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 				lowercase_		(							self						:		List[Any] )		->							Optional[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__   =   FalconForSequenceClassification(__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 				lowercase_		(							self						:		str )		->							List[Any]:
							SCREAMING_SNAKE_CASE__,SCREAMING_SNAKE_CASE__   =   self.model_tester.prepare_config_and_inputs_for_common()
							SCREAMING_SNAKE_CASE__   =   input_dict['''input_ids''']
							SCREAMING_SNAKE_CASE__   =   FalconForCausalLM(__lowerCamelCase )
							model.to(__lowerCamelCase )
							model.eval()
							SCREAMING_SNAKE_CASE__   =   model(__lowerCamelCase     ,       use_cache=__lowerCamelCase )
							SCREAMING_SNAKE_CASE__   =   input_ids.shape[0]
							SCREAMING_SNAKE_CASE__   =   model._convert_to_rw_cache(result.past_key_values )
							SCREAMING_SNAKE_CASE__   =   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 				lowercase_		(							self						:		str )		->							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__   =   FalconForSequenceClassification(__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 				lowercase_		(							self						:		str )		->							Tuple:
							# Falcon can have different numbers of KV-heads than the number of query heads, so we need
							# to override this test to use the right head counts.
							for model_class in self.all_generative_model_classes:
												SCREAMING_SNAKE_CASE__,SCREAMING_SNAKE_CASE__   =   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

												SCREAMING_SNAKE_CASE__   =   model_class(__lowerCamelCase ).to(__lowerCamelCase )
												if "use_cache" not in inputs:
																	SCREAMING_SNAKE_CASE__   =   True
												SCREAMING_SNAKE_CASE__   =   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

												SCREAMING_SNAKE_CASE__   =   (
												    getattr(__lowerCamelCase     ,       '''decoder_layers'''     ,       __lowerCamelCase )
												    or getattr(__lowerCamelCase     ,       '''num_decoder_layers'''     ,       __lowerCamelCase )
												    or config.num_hidden_layers
												)
												SCREAMING_SNAKE_CASE__   =   getattr(__lowerCamelCase     ,       '''num_kv_heads'''     ,       config.num_attention_heads )
												SCREAMING_SNAKE_CASE__   =   getattr(__lowerCamelCase     ,       '''d_model'''     ,       config.hidden_size )
												SCREAMING_SNAKE_CASE__   =   embed_dim // num_attention_heads

												SCREAMING_SNAKE_CASE__   =   outputs['''past_key_values''']
												self.assertEqual(len(__lowerCamelCase )     ,       __lowerCamelCase )

												SCREAMING_SNAKE_CASE__,SCREAMING_SNAKE_CASE__   =   inputs['''input_ids'''].shape
												for i in range(__lowerCamelCase ):
																	if config.new_decoder_architecture:
																						SCREAMING_SNAKE_CASE__   =   config.num_attention_heads
																	elif config.multi_query:
																						SCREAMING_SNAKE_CASE__   =   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 	UpperCAmelCase__		(	unittest.TestCase	):






		"""simple docstring"""


		@slow
		def 				lowercase_		(							self						:		str )		->							Tuple:
							SCREAMING_SNAKE_CASE__   =   AutoTokenizer.from_pretrained('''Rocketknight1/falcon-rw-1b''' )
							SCREAMING_SNAKE_CASE__   =   FalconForCausalLM.from_pretrained('''Rocketknight1/falcon-rw-1b''' )
							model.eval()
							model.to(__lowerCamelCase )
							SCREAMING_SNAKE_CASE__   =   tokenizer('''My favorite food is'''     ,       return_tensors='''pt''' ).to(__lowerCamelCase )

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

							SCREAMING_SNAKE_CASE__   =   model.generate(**__lowerCamelCase     ,       do_sample=__lowerCamelCase     ,       max_new_tokens=19 )
							SCREAMING_SNAKE_CASE__   =   tokenizer.batch_decode(__lowerCamelCase )[0]

							self.assertEqual(__lowerCamelCase     ,       __lowerCamelCase )






		@slow
		def 				lowercase_		(							self						:		Optional[Any] )		->							Optional[Any]:
							# The big models are way too big for the CI, so we use tiny random models that resemble their
							# architectures but with much smaller and fewer layers
							for repo in ["Rocketknight1/tiny-random-falcon-7b", "Rocketknight1/tiny-random-falcon-40b"]:
												SCREAMING_SNAKE_CASE__   =   AutoTokenizer.from_pretrained(__lowerCamelCase )
												SCREAMING_SNAKE_CASE__   =   FalconForCausalLM.from_pretrained(__lowerCamelCase )
												model.eval()
												model.to(__lowerCamelCase )
												SCREAMING_SNAKE_CASE__   =   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 				lowercase_		(							self						:		Tuple )		->							Optional[Any]:
							# The big models are way too big for the CI, so we use tiny random models that resemble their
							# architectures but with much smaller and fewer layers
							with torch.no_grad():
												for repo in [
												    "Rocketknight1/falcon-rw-1b",
												    "Rocketknight1/tiny-random-falcon-7b",
												    "Rocketknight1/tiny-random-falcon-40b",
												]:
																	SCREAMING_SNAKE_CASE__   =   AutoTokenizer.from_pretrained(__lowerCamelCase )
																	SCREAMING_SNAKE_CASE__   =   FalconForCausalLM.from_pretrained(__lowerCamelCase )
																	model.eval()
																	model.to(device=__lowerCamelCase )
																	SCREAMING_SNAKE_CASE__   =   tokenizer('''My favorite food is'''     ,       return_tensors='''pt''' ).to(__lowerCamelCase )

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





def     UpperCAmelCase_       (						_A    ):





     '''simple docstring'''




     if not isinstance(_A				,		_A    ):
          raise ValueError('''multiplicative_persistence() only accepts integral values'''    )
     if num < 0:
          raise ValueError('''multiplicative_persistence() does not accept negative values'''    )

     SCREAMING_SNAKE_CASE__   =   0
     SCREAMING_SNAKE_CASE__   =   str(_A    )

     while len(_A    ) != 1:
          SCREAMING_SNAKE_CASE__   =   [int(_A    ) for i in num_string]

          SCREAMING_SNAKE_CASE__   =   1
          for i in range(0				,		len(_A    )    ):
               total *= numbers[i]

          SCREAMING_SNAKE_CASE__   =   str(_A    )

          steps += 1
     return steps
def     UpperCAmelCase_       (						_A    ):





     '''simple docstring'''




     if not isinstance(_A				,		_A    ):
          raise ValueError('''additive_persistence() only accepts integral values'''    )
     if num < 0:
          raise ValueError('''additive_persistence() does not accept negative values'''    )

     SCREAMING_SNAKE_CASE__   =   0
     SCREAMING_SNAKE_CASE__   =   str(_A    )

     while len(_A    ) != 1:
          SCREAMING_SNAKE_CASE__   =   [int(_A    ) for i in num_string]

          SCREAMING_SNAKE_CASE__   =   0
          for i in range(0				,		len(_A    )    ):
               total += numbers[i]

          SCREAMING_SNAKE_CASE__   =   str(_A    )

          steps += 1
     return steps


if __name__ == "__main__":
       import doctest

       doctest.testmod()


