






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			,     a			,     a=3			,     a=7			,     a=True			,     a=True			,     a=False			,     a=True			,     a=99			,     a=32			,     a=5			,     a=4			,     a=37			,     a="gelu"			,     a=0.1			,     a=0.1			,     a=5_12			,     a=16			,     a=2			,     a=0.02			,     a=3			,     a=4			,     a=None			,     )			->       int:
								snake_case_           =				parent
								snake_case_           =				batch_size
								snake_case_           =				seq_length
								snake_case_           =				is_training
								snake_case_           =				use_input_mask
								snake_case_           =				use_token_type_ids
								snake_case_           =				use_labels
								snake_case_           =				vocab_size
								snake_case_           =				hidden_size
								snake_case_           =				num_hidden_layers
								snake_case_           =				num_attention_heads
								snake_case_           =				intermediate_size
								snake_case_           =				hidden_act
								snake_case_           =				hidden_dropout_prob
								snake_case_           =				attention_probs_dropout_prob
								snake_case_           =				max_position_embeddings
								snake_case_           =				type_vocab_size
								snake_case_           =				type_sequence_label_size
								snake_case_           =				initializer_range
								snake_case_           =				num_labels
								snake_case_           =				num_choices
								snake_case_           =				scope




	def 				_UpperCamelCase     (			self   )			->       List[str]:
								snake_case_           =				ids_tensor([self.batch_size, self.seq_length]			,     self.vocab_size   )

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

								snake_case_           =				None

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

								snake_case_           =				self.get_config()

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




	def 				_UpperCamelCase     (			self   )			->       Optional[Any]:
								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=a			,     initializer_range=self.initializer_range			,     pad_token_id=1			,     new_decoder_architecture=a			,     )




	def 				_UpperCamelCase     (			self			,     a			,     a			,     a			,     a			,     a			,     a			,     a   )			->       str:
								snake_case_           =				FalconModel(config=a   )
								model.to(a   )
								model.eval()
								snake_case_           =				model(a			,     attention_mask=a   )
								snake_case_           =				model(a   )
								self.parent.assertEqual(result.last_hidden_state.shape			,     (self.batch_size, self.seq_length, self.hidden_size)   )




	def 				_UpperCamelCase     (			self			,     a			,     a			,     a			,     a			,     a			,     a			,     a			,     a			,     a			,     )			->       List[Any]:
								snake_case_           =				True
								snake_case_           =				FalconModel(a   )
								model.to(a   )
								model.eval()
								snake_case_           =				model(
								    a			,     attention_mask=a			,     encoder_hidden_states=a			,     encoder_attention_mask=a			,     )
								snake_case_           =				model(
								    a			,     attention_mask=a			,     encoder_hidden_states=a			,     )
								snake_case_           =				model(a			,     attention_mask=a   )
								self.parent.assertEqual(result.last_hidden_state.shape			,     (self.batch_size, self.seq_length, self.hidden_size)   )




	def 				_UpperCamelCase     (			self			,     a			,     a			,     a			,     a			,     a			,     a			,     a			,     a			,     a			,     )			->       int:
								snake_case_           =				FalconForCausalLM(config=a   )
								model.to(a   )
								model.eval()
								snake_case_           =				model(a			,     attention_mask=a			,     labels=a   )
								self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.seq_length, self.vocab_size)   )




	def 				_UpperCamelCase     (			self			,     a			,     a			,     a			,     a			,     a			,     a			,     a			,     a			,     a			,     )			->       Union[str, Any]:
								snake_case_           =				True
								snake_case_           =				True
								snake_case_           =				FalconForCausalLM(config=a   )
								model.to(a   )
								model.eval()

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

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

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

								snake_case_           =				model(
								    a			,     attention_mask=a			,     encoder_hidden_states=a			,     encoder_attention_mask=a			,     output_hidden_states=a			,     )['hidden_states'][0]
								snake_case_           =				model(
								    a			,     attention_mask=a			,     encoder_hidden_states=a			,     encoder_attention_mask=a			,     past_key_values=a			,     output_hidden_states=a			,     )['hidden_states'][0]

								# select random slice
								snake_case_           =				ids_tensor((1,)			,     output_from_past.shape[-1]   ).item()
								snake_case_           =				output_from_no_past[:, -3:, random_slice_idx].detach()
								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(a			,     a			,     atol=1E-3   )   )






	def 				_UpperCamelCase     (			self   )			->       Tuple:
								snake_case_           =				self.prepare_config_and_inputs()
								(
								    (
								    snake_case_
								)     ,						(
								    snake_case_
								)     ,						(
								    snake_case_
								)     ,						(
								    snake_case_
								)     ,						(
								    snake_case_
								)     ,						(
								    snake_case_
								)     ,						(
								    snake_case_
								)     ,						
								)           =				config_and_inputs
								snake_case_           =				{'input_ids': input_ids, 'attention_mask': input_mask}
								return config, inputs_dict






@require_torch
class 					UpperCamelCase_ (     snake_case_			,   snake_case_			,   snake_case_			,   unittest.TestCase							):



	'''simple docstring'''




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




	def 				_UpperCamelCase     (			self   )			->       Optional[int]:
								snake_case_           =				FalconModelTester(self   )
								snake_case_           =				ConfigTester(self			,     config_class=a			,     hidden_size=37   )




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




	def 				_UpperCamelCase     (			self   )			->       List[str]:
								snake_case_           =				self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*a   )




	def 				_UpperCamelCase     (			self   )			->       str:
								snake_case_     ,						*snake_case_           =				self.model_tester.prepare_config_and_inputs()
								for alibi in [True, False]:
															snake_case_           =				alibi
															self.model_tester.create_and_check_model(a			,     *a   )




	def 				_UpperCamelCase     (			self   )			->       str:
								snake_case_     ,						snake_case_           =				self.model_tester.prepare_config_and_inputs_for_common()
								snake_case_           =				3
								snake_case_           =				input_dict['input_ids']
								snake_case_           =				input_ids.ne(1   ).to(a   )
								snake_case_           =				ids_tensor([self.model_tester.batch_size]			,     self.model_tester.type_sequence_label_size   )
								snake_case_           =				FalconForSequenceClassification(a   )
								model.to(a   )
								model.eval()
								snake_case_           =				model(a			,     attention_mask=a			,     labels=a   )
								self.assertEqual(result.logits.shape			,     (self.model_tester.batch_size, self.model_tester.num_labels)   )




	def 				_UpperCamelCase     (			self   )			->       Union[str, Any]:
								snake_case_     ,						snake_case_           =				self.model_tester.prepare_config_and_inputs_for_common()
								snake_case_           =				3
								snake_case_           =				'single_label_classification'
								snake_case_           =				input_dict['input_ids']
								snake_case_           =				input_ids.ne(1   ).to(a   )
								snake_case_           =				ids_tensor([self.model_tester.batch_size]			,     self.model_tester.type_sequence_label_size   )
								snake_case_           =				FalconForSequenceClassification(a   )
								model.to(a   )
								model.eval()
								snake_case_           =				model(a			,     attention_mask=a			,     labels=a   )
								self.assertEqual(result.logits.shape			,     (self.model_tester.batch_size, self.model_tester.num_labels)   )




	def 				_UpperCamelCase     (			self   )			->       List[str]:
								snake_case_     ,						snake_case_           =				self.model_tester.prepare_config_and_inputs_for_common()
								snake_case_           =				input_dict['input_ids']
								snake_case_           =				FalconForCausalLM(a   )
								model.to(a   )
								model.eval()
								snake_case_           =				model(a			,     use_cache=a   )
								snake_case_           =				input_ids.shape[0]
								snake_case_           =				model._convert_to_rw_cache(result.past_key_values   )
								snake_case_           =				model._convert_cache_to_standard_format(a			,     a   )
								for layer in range(len(a   )   ):
															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 				_UpperCamelCase     (			self   )			->       Optional[Any]:
								snake_case_     ,						snake_case_           =				self.model_tester.prepare_config_and_inputs_for_common()
								snake_case_           =				3
								snake_case_           =				'multi_label_classification'
								snake_case_           =				input_dict['input_ids']
								snake_case_           =				input_ids.ne(1   ).to(a   )
								snake_case_           =				ids_tensor(
								    [self.model_tester.batch_size, config.num_labels]			,     self.model_tester.type_sequence_label_size   ).to(torch.float   )
								snake_case_           =				FalconForSequenceClassification(a   )
								model.to(a   )
								model.eval()
								snake_case_           =				model(a			,     attention_mask=a			,     labels=a   )
								self.assertEqual(result.logits.shape			,     (self.model_tester.batch_size, self.model_tester.num_labels)   )






	def 				_UpperCamelCase     (			self   )			->       List[str]:
								# 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:
															snake_case_     ,						snake_case_           =				self.model_tester.prepare_config_and_inputs_for_common()

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

															snake_case_           =				model_class(a   ).to(a   )
															if "use_cache" not in inputs:
																						snake_case_           =				True
															snake_case_           =				model(**a   )

															# 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

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

															snake_case_           =				outputs['past_key_values']
															self.assertEqual(len(a   )			,     a   )

															snake_case_     ,						snake_case_           =				inputs['input_ids'].shape
															for i in range(a   ):
																						if config.new_decoder_architecture:
																													snake_case_           =				config.num_attention_heads
																						elif config.multi_query:
																													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 				_UpperCamelCase     (			self   )			->       Optional[Any]:
								snake_case_           =				AutoTokenizer.from_pretrained('Rocketknight1/falcon-rw-1b'   )
								snake_case_           =				FalconForCausalLM.from_pretrained('Rocketknight1/falcon-rw-1b'   )
								model.eval()
								model.to(a   )
								snake_case_           =				tokenizer('My favorite food is'			,     return_tensors='pt'   ).to(a   )

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

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

								self.assertEqual(a			,     a   )




	@slow
	def 				_UpperCamelCase     (			self   )			->       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"]:
															snake_case_           =				AutoTokenizer.from_pretrained(a   )
															snake_case_           =				FalconForCausalLM.from_pretrained(a   )
															model.eval()
															model.to(a   )
															snake_case_           =				tokenizer('My favorite food is'			,     return_tensors='pt'   ).to(a   )

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






	@slow
	def 				_UpperCamelCase     (			self   )			->       str:
								# 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",
															]:
																						snake_case_           =				AutoTokenizer.from_pretrained(a   )
																						snake_case_           =				FalconForCausalLM.from_pretrained(a   )
																						model.eval()
																						model.to(device=a   )
																						snake_case_           =				tokenizer('My favorite food is'			,     return_tensors='pt'   ).to(a   )

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













def 		__UpperCAmelCase     (	a_ = 10**9):
							snake_case_           =				1
							snake_case_           =				2

							snake_case_           =				0
							snake_case_           =				0
							snake_case_           =				0
							while perimeter <= max_perimeter:
														perimeters_sum += perimeter

														prev_value += 2 * value
														value += prev_value

														snake_case_           =				2 * value + 2 if i % 2 == 0 else 2 * value - 2
														i += 1

							return perimeters_sum


if __name__ == "__main__":
	print(f'{solution() = }')





