


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					:




			def __init__(						self							:		Any       ,       __magic_name__							:		Any       ,       __magic_name__							:		Union[str, Any]=3       ,       __magic_name__							:		Optional[int]=7       ,       __magic_name__							:		List[Any]=True       ,       __magic_name__							:		Union[str, Any]=True       ,       __magic_name__							:		Optional[int]=False       ,       __magic_name__							:		List[Any]=True       ,       __magic_name__							:		str=9_9       ,       __magic_name__							:		Optional[Any]=3_2       ,       __magic_name__							:		Tuple=5       ,       __magic_name__							:		List[str]=4       ,       __magic_name__							:		int=3_7       ,       __magic_name__							:		Optional[Any]="gelu"       ,       __magic_name__							:		Optional[int]=0.1       ,       __magic_name__							:		Optional[int]=0.1       ,       __magic_name__							:		Union[str, Any]=5_1_2       ,       __magic_name__							:		int=1_6       ,       __magic_name__							:		List[str]=2       ,       __magic_name__							:		Union[str, Any]=0.02       ,       __magic_name__							:		Any=3       ,       __magic_name__							:		int=4       ,       __magic_name__							:		Optional[int]=None       ,       ):







						"""simple docstring"""







						UpperCamelCase         =					parent
						UpperCamelCase         =					batch_size
						UpperCamelCase         =					seq_length
						UpperCamelCase         =					is_training
						UpperCamelCase         =					use_input_mask
						UpperCamelCase         =					use_token_type_ids
						UpperCamelCase         =					use_labels
						UpperCamelCase         =					vocab_size
						UpperCamelCase         =					hidden_size
						UpperCamelCase         =					num_hidden_layers
						UpperCamelCase         =					num_attention_heads
						UpperCamelCase         =					intermediate_size
						UpperCamelCase         =					hidden_act
						UpperCamelCase         =					hidden_dropout_prob
						UpperCamelCase         =					attention_probs_dropout_prob
						UpperCamelCase         =					max_position_embeddings
						UpperCamelCase         =					type_vocab_size
						UpperCamelCase         =					type_sequence_label_size
						UpperCamelCase         =					initializer_range
						UpperCamelCase         =					num_labels
						UpperCamelCase         =					num_choices
						UpperCamelCase         =					scope




			def   lowerCamelCase_					(						self							:		List[Any]						):







						"""simple docstring"""







						UpperCamelCase         =					ids_tensor([self.batch_size, self.seq_length]       ,       self.vocab_size						)

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

						UpperCamelCase         =					None

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

						UpperCamelCase         =					self.get_config()

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




			def   lowerCamelCase_					(						self							:		str						):







						"""simple docstring"""







						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=_UpperCAmelCase       ,       initializer_range=self.initializer_range       ,       pad_token_id=1       ,       new_decoder_architecture=_UpperCAmelCase       ,       )




			def   lowerCamelCase_					(						self							:		str       ,       __magic_name__							:		int       ,       __magic_name__							:		List[Any]       ,       __magic_name__							:		str       ,       __magic_name__							:		int       ,       __magic_name__							:		str       ,       __magic_name__							:		Optional[int]       ,       __magic_name__							:		Union[str, Any]						):







						"""simple docstring"""







						UpperCamelCase         =					FalconModel(config=_UpperCAmelCase						)
						model.to(_UpperCAmelCase						)
						model.eval()
						UpperCamelCase         =					model(_UpperCAmelCase       ,       attention_mask=_UpperCAmelCase						)
						UpperCamelCase         =					model(_UpperCAmelCase						)
						self.parent.assertEqual(result.last_hidden_state.shape       ,       (self.batch_size, self.seq_length, self.hidden_size)						)




			def   lowerCamelCase_					(						self							:		Tuple       ,       __magic_name__							:		Tuple       ,       __magic_name__							:		List[str]       ,       __magic_name__							:		Optional[int]       ,       __magic_name__							:		str       ,       __magic_name__							:		Any       ,       __magic_name__							:		Optional[int]       ,       __magic_name__							:		Dict       ,       __magic_name__							:		int       ,       __magic_name__							:		int       ,       ):







						"""simple docstring"""







						UpperCamelCase         =					True
						UpperCamelCase         =					FalconModel(_UpperCAmelCase						)
						model.to(_UpperCAmelCase						)
						model.eval()
						UpperCamelCase         =					model(
						    _UpperCAmelCase       ,       attention_mask=_UpperCAmelCase       ,       encoder_hidden_states=_UpperCAmelCase       ,       encoder_attention_mask=_UpperCAmelCase       ,       )
						UpperCamelCase         =					model(
						    _UpperCAmelCase       ,       attention_mask=_UpperCAmelCase       ,       encoder_hidden_states=_UpperCAmelCase       ,       )
						UpperCamelCase         =					model(_UpperCAmelCase       ,       attention_mask=_UpperCAmelCase						)
						self.parent.assertEqual(result.last_hidden_state.shape       ,       (self.batch_size, self.seq_length, self.hidden_size)						)




			def   lowerCamelCase_					(						self							:		Union[str, Any]       ,       __magic_name__							:		Optional[int]       ,       __magic_name__							:		Optional[int]       ,       __magic_name__							:		Optional[Any]       ,       __magic_name__							:		Any       ,       __magic_name__							:		Dict       ,       __magic_name__							:		Union[str, Any]       ,       __magic_name__							:		Dict       ,       __magic_name__							:		Optional[int]       ,       __magic_name__							:		Optional[Any]       ,       ):







						"""simple docstring"""







						UpperCamelCase         =					FalconForCausalLM(config=_UpperCAmelCase						)
						model.to(_UpperCAmelCase						)
						model.eval()
						UpperCamelCase         =					model(_UpperCAmelCase       ,       attention_mask=_UpperCAmelCase       ,       labels=_UpperCAmelCase						)
						self.parent.assertEqual(result.logits.shape       ,       (self.batch_size, self.seq_length, self.vocab_size)						)




			def   lowerCamelCase_					(						self							:		Dict       ,       __magic_name__							:		Any       ,       __magic_name__							:		Dict       ,       __magic_name__							:		Union[str, Any]       ,       __magic_name__							:		Any       ,       __magic_name__							:		int       ,       __magic_name__							:		Union[str, Any]       ,       __magic_name__							:		str       ,       __magic_name__							:		Dict       ,       __magic_name__							:		Any       ,       ):







						"""simple docstring"""







						UpperCamelCase         =					True
						UpperCamelCase         =					True
						UpperCamelCase         =					FalconForCausalLM(config=_UpperCAmelCase						)
						model.to(_UpperCAmelCase						)
						model.eval()

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

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

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

						UpperCamelCase         =					model(
						    _UpperCAmelCase       ,       attention_mask=_UpperCAmelCase       ,       encoder_hidden_states=_UpperCAmelCase       ,       encoder_attention_mask=_UpperCAmelCase       ,       output_hidden_states=_UpperCAmelCase       ,       )['''hidden_states'''][0]
						UpperCamelCase         =					model(
						    _UpperCAmelCase       ,       attention_mask=_UpperCAmelCase       ,       encoder_hidden_states=_UpperCAmelCase       ,       encoder_attention_mask=_UpperCAmelCase       ,       past_key_values=_UpperCAmelCase       ,       output_hidden_states=_UpperCAmelCase       ,       )['''hidden_states'''][0]

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





			def   lowerCamelCase_					(						self							:		Tuple						):







						"""simple docstring"""







						UpperCamelCase         =					self.prepare_config_and_inputs()
						(
						    UpperCamelCase						
						)         =					config_and_inputs
						UpperCamelCase         =					{'''input_ids''': input_ids, '''attention_mask''': input_mask}
						return config, inputs_dict




@require_torch
class    UpperCAmelCase					(       _UpperCamelCase      , _UpperCamelCase      , _UpperCamelCase      , unittest.TestCase    ):
			lowercase						= (
			    (
			        FalconModel,
			        FalconForCausalLM,
			        FalconForSequenceClassification,
			        FalconForTokenClassification,
			        FalconForQuestionAnswering,
			    )
			    if is_torch_available()
			    else ()
			)
			lowercase						= (FalconForCausalLM,) if is_torch_available() else ()
			lowercase						= (
			    {
			        """feature-extraction""": FalconModel,
			        """text-classification""": FalconForSequenceClassification,
			        """text-generation""": FalconForCausalLM,
			        """question-answering""": FalconForQuestionAnswering,
			        """token-classification""": FalconForTokenClassification,
			        """zero-shot""": FalconForSequenceClassification,
			    }
			    if is_torch_available()
			    else {}
			)
			lowercase						= False
			lowercase						= False




			def   lowerCamelCase_					(						self							:		Any						):







						"""simple docstring"""







						UpperCamelCase         =					FalconModelTester(self						)
						UpperCamelCase         =					ConfigTester(self       ,       config_class=_UpperCAmelCase       ,       hidden_size=3_7						)




			def   lowerCamelCase_					(						self							:		Union[str, Any]						):







						"""simple docstring"""







						self.config_tester.run_common_tests()




			def   lowerCamelCase_					(						self							:		List[str]						):







						"""simple docstring"""







						UpperCamelCase         =					self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*_UpperCAmelCase						)




			def   lowerCamelCase_					(						self							:		Optional[Any]						):







						"""simple docstring"""







						UpperCamelCase         =					self.model_tester.prepare_config_and_inputs()
						for alibi in [True, False]:
									UpperCamelCase         =					alibi
									self.model_tester.create_and_check_model(_UpperCAmelCase       ,       *_UpperCAmelCase						)




			def   lowerCamelCase_					(						self							:		Dict						):







						"""simple docstring"""







						UpperCamelCase         =					self.model_tester.prepare_config_and_inputs_for_common()
						UpperCamelCase         =					3
						UpperCamelCase         =					input_dict['''input_ids''']
						UpperCamelCase         =					input_ids.ne(1						).to(_UpperCAmelCase						)
						UpperCamelCase         =					ids_tensor([self.model_tester.batch_size]       ,       self.model_tester.type_sequence_label_size						)
						UpperCamelCase         =					FalconForSequenceClassification(_UpperCAmelCase						)
						model.to(_UpperCAmelCase						)
						model.eval()
						UpperCamelCase         =					model(_UpperCAmelCase       ,       attention_mask=_UpperCAmelCase       ,       labels=_UpperCAmelCase						)
						self.assertEqual(result.logits.shape       ,       (self.model_tester.batch_size, self.model_tester.num_labels)						)




			def   lowerCamelCase_					(						self							:		List[Any]						):







						"""simple docstring"""







						UpperCamelCase         =					self.model_tester.prepare_config_and_inputs_for_common()
						UpperCamelCase         =					3
						UpperCamelCase         =					'''single_label_classification'''
						UpperCamelCase         =					input_dict['''input_ids''']
						UpperCamelCase         =					input_ids.ne(1						).to(_UpperCAmelCase						)
						UpperCamelCase         =					ids_tensor([self.model_tester.batch_size]       ,       self.model_tester.type_sequence_label_size						)
						UpperCamelCase         =					FalconForSequenceClassification(_UpperCAmelCase						)
						model.to(_UpperCAmelCase						)
						model.eval()
						UpperCamelCase         =					model(_UpperCAmelCase       ,       attention_mask=_UpperCAmelCase       ,       labels=_UpperCAmelCase						)
						self.assertEqual(result.logits.shape       ,       (self.model_tester.batch_size, self.model_tester.num_labels)						)




			def   lowerCamelCase_					(						self							:		List[Any]						):







						"""simple docstring"""







						UpperCamelCase         =					self.model_tester.prepare_config_and_inputs_for_common()
						UpperCamelCase         =					input_dict['''input_ids''']
						UpperCamelCase         =					FalconForCausalLM(_UpperCAmelCase						)
						model.to(_UpperCAmelCase						)
						model.eval()
						UpperCamelCase         =					model(_UpperCAmelCase       ,       use_cache=_UpperCAmelCase						)
						UpperCamelCase         =					input_ids.shape[0]
						UpperCamelCase         =					model._convert_to_rw_cache(result.past_key_values						)
						UpperCamelCase         =					model._convert_cache_to_standard_format(_UpperCAmelCase       ,       _UpperCAmelCase						)
						for layer in range(len(_UpperCAmelCase						)						):
									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							:		Tuple						):







						"""simple docstring"""







						UpperCamelCase         =					self.model_tester.prepare_config_and_inputs_for_common()
						UpperCamelCase         =					3
						UpperCamelCase         =					'''multi_label_classification'''
						UpperCamelCase         =					input_dict['''input_ids''']
						UpperCamelCase         =					input_ids.ne(1						).to(_UpperCAmelCase						)
						UpperCamelCase         =					ids_tensor(
						    [self.model_tester.batch_size, config.num_labels]       ,       self.model_tester.type_sequence_label_size						).to(torch.float						)
						UpperCamelCase         =					FalconForSequenceClassification(_UpperCAmelCase						)
						model.to(_UpperCAmelCase						)
						model.eval()
						UpperCamelCase         =					model(_UpperCAmelCase       ,       attention_mask=_UpperCAmelCase       ,       labels=_UpperCAmelCase						)
						self.assertEqual(result.logits.shape       ,       (self.model_tester.batch_size, self.model_tester.num_labels)						)





			def   lowerCamelCase_					(						self							:		Optional[Any]						):







						"""simple docstring"""







						for model_class in self.all_generative_model_classes:
									UpperCamelCase         =					self.model_tester.prepare_config_and_inputs_for_common()

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

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

									# 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

									UpperCamelCase         =					(
									    getattr(_UpperCAmelCase       ,       """decoder_layers"""       ,       _UpperCAmelCase						)
									    or getattr(_UpperCAmelCase       ,       """num_decoder_layers"""       ,       _UpperCAmelCase						)
									    or config.num_hidden_layers
									)
									UpperCamelCase         =					getattr(_UpperCAmelCase       ,       """num_kv_heads"""       ,       config.num_attention_heads						)
									UpperCamelCase         =					getattr(_UpperCAmelCase       ,       """d_model"""       ,       config.hidden_size						)
									UpperCamelCase         =					embed_dim // num_attention_heads

									UpperCamelCase         =					outputs['''past_key_values''']
									self.assertEqual(len(_UpperCAmelCase						)       ,       _UpperCAmelCase						)

									UpperCamelCase         =					inputs['''input_ids'''].shape
									for i in range(_UpperCAmelCase						):
												if config.new_decoder_architecture:
															UpperCamelCase         =					config.num_attention_heads
												elif config.multi_query:
															UpperCamelCase         =					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    ):




			@slow
			def   lowerCamelCase_					(						self							:		List[str]						):







						"""simple docstring"""







						UpperCamelCase         =					AutoTokenizer.from_pretrained("""Rocketknight1/falcon-rw-1b"""						)
						UpperCamelCase         =					FalconForCausalLM.from_pretrained("""Rocketknight1/falcon-rw-1b"""						)
						model.eval()
						model.to(_UpperCAmelCase						)
						UpperCamelCase         =					tokenizer("""My favorite food is"""       ,       return_tensors="""pt"""						).to(_UpperCAmelCase						)

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

						UpperCamelCase         =					model.generate(**_UpperCAmelCase       ,       do_sample=_UpperCAmelCase       ,       max_new_tokens=1_9						)
						UpperCamelCase         =					tokenizer.batch_decode(_UpperCAmelCase						)[0]

						self.assertEqual(_UpperCAmelCase       ,       _UpperCAmelCase						)




			@slow
			def   lowerCamelCase_					(						self							:		Optional[Any]						):







						"""simple docstring"""







						for repo in ["Rocketknight1/tiny-random-falcon-7b", "Rocketknight1/tiny-random-falcon-40b"]:
									UpperCamelCase         =					AutoTokenizer.from_pretrained(_UpperCAmelCase						)
									UpperCamelCase         =					FalconForCausalLM.from_pretrained(_UpperCAmelCase						)
									model.eval()
									model.to(_UpperCAmelCase						)
									UpperCamelCase         =					tokenizer("""My favorite food is"""       ,       return_tensors="""pt"""						).to(_UpperCAmelCase						)

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





			@slow
			def   lowerCamelCase_					(						self							:		Union[str, Any]						):







						"""simple docstring"""







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

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








import math






def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		int = 100	):





			"""simple docstring"""




			UpperCamelCase         =					sum(i * i for i in range(1       ,  n + 1	)	)
			UpperCamelCase         =					int(math.pow(sum(range(1       ,  n + 1	)	)       ,  2	)	)
			return square_of_sum - sum_of_squares


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




