





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				,						lowerCAmelCase_				,						lowerCAmelCase_=3				,						lowerCAmelCase_=7				,						lowerCAmelCase_=True				,						lowerCAmelCase_=True				,						lowerCAmelCase_=False				,						lowerCAmelCase_=True				,						lowerCAmelCase_=99				,						lowerCAmelCase_=32				,						lowerCAmelCase_=5				,						lowerCAmelCase_=4				,						lowerCAmelCase_=37				,						lowerCAmelCase_="gelu"				,						lowerCAmelCase_=0.1				,						lowerCAmelCase_=0.1				,						lowerCAmelCase_=512				,						lowerCAmelCase_=16				,						lowerCAmelCase_=2				,						lowerCAmelCase_=0.02				,						lowerCAmelCase_=3				,						lowerCAmelCase_=4				,						lowerCAmelCase_=None				,						)		->							List[str]:
										_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 	lowerCAmelCase			(		self  )		->							Optional[int]:
										_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 	lowerCAmelCase			(		self  )		->							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 	lowerCAmelCase			(		self				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_  )		->							List[Any]:
										_snake_case									=				FalconModel(config=lowerCAmelCase_  )
										model.to(lowerCAmelCase_  )
										model.eval()
										_snake_case									=				model(lowerCAmelCase_				,						attention_mask=lowerCAmelCase_  )
										_snake_case									=				model(lowerCAmelCase_  )
										self.parent.assertEqual(result.last_hidden_state.shape				,						(self.batch_size, self.seq_length, self.hidden_size)  )




					def 	lowerCAmelCase			(		self				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						)		->							Tuple:
										_snake_case									=				True
										_snake_case									=				FalconModel(lowerCAmelCase_  )
										model.to(lowerCAmelCase_  )
										model.eval()
										_snake_case									=				model(
										    lowerCAmelCase_				,						attention_mask=lowerCAmelCase_				,						encoder_hidden_states=lowerCAmelCase_				,						encoder_attention_mask=lowerCAmelCase_				,						)
										_snake_case									=				model(
										    lowerCAmelCase_				,						attention_mask=lowerCAmelCase_				,						encoder_hidden_states=lowerCAmelCase_				,						)
										_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 	lowerCAmelCase			(		self				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						)		->							str:
										_snake_case									=				FalconForCausalLM(config=lowerCAmelCase_  )
										model.to(lowerCAmelCase_  )
										model.eval()
										_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 	lowerCAmelCase			(		self				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						)		->							int:
										_snake_case									=				True
										_snake_case									=				True
										_snake_case									=				FalconForCausalLM(config=lowerCAmelCase_  )
										model.to(lowerCAmelCase_  )
										model.eval()

										# first forward pass
										_snake_case									=				model(
										    lowerCAmelCase_				,						attention_mask=lowerCAmelCase_				,						encoder_hidden_states=lowerCAmelCase_				,						encoder_attention_mask=lowerCAmelCase_				,						use_cache=lowerCAmelCase_				,						)
										_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(
										    lowerCAmelCase_				,						attention_mask=lowerCAmelCase_				,						encoder_hidden_states=lowerCAmelCase_				,						encoder_attention_mask=lowerCAmelCase_				,						output_hidden_states=lowerCAmelCase_				,						)['hidden_states'][0]
										_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
										_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(lowerCAmelCase_				,						lowerCAmelCase_				,						atol=1E-3  )  )






					def 	lowerCAmelCase			(		self  )		->							List[Any]:
										_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_		(  _lowerCamelCase							,  _lowerCamelCase							,  _lowerCamelCase							,  unittest.TestCase					):
					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 	lowerCAmelCase			(		self  )		->							List[Any]:
										_snake_case									=				FalconModelTester(self  )
										_snake_case									=				ConfigTester(self				,						config_class=lowerCAmelCase_				,						hidden_size=37  )




					def 	lowerCAmelCase			(		self  )		->							int:
										self.config_tester.run_common_tests()




					def 	lowerCAmelCase			(		self  )		->							Optional[int]:
										_snake_case									=				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*lowerCAmelCase_  )




					def 	lowerCAmelCase			(		self  )		->							Optional[Any]:
										_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(lowerCAmelCase_				,						*lowerCAmelCase_  )




					def 	lowerCAmelCase			(		self  )		->							Union[str, Any]:
										_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(lowerCAmelCase_  )
										_snake_case									=				ids_tensor([self.model_tester.batch_size]				,						self.model_tester.type_sequence_label_size  )
										_snake_case									=				FalconForSequenceClassification(lowerCAmelCase_  )
										model.to(lowerCAmelCase_  )
										model.eval()
										_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 	lowerCAmelCase			(		self  )		->							Optional[int]:
										_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(lowerCAmelCase_  )
										_snake_case									=				ids_tensor([self.model_tester.batch_size]				,						self.model_tester.type_sequence_label_size  )
										_snake_case									=				FalconForSequenceClassification(lowerCAmelCase_  )
										model.to(lowerCAmelCase_  )
										model.eval()
										_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 	lowerCAmelCase			(		self  )		->							Optional[int]:
										_snake_case							,     _snake_case									=				self.model_tester.prepare_config_and_inputs_for_common()
										_snake_case									=				input_dict['input_ids']
										_snake_case									=				FalconForCausalLM(lowerCAmelCase_  )
										model.to(lowerCAmelCase_  )
										model.eval()
										_snake_case									=				model(lowerCAmelCase_				,						use_cache=lowerCAmelCase_  )
										_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(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  )		->							Union[str, 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(lowerCAmelCase_  )
										_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(lowerCAmelCase_  )
										model.to(lowerCAmelCase_  )
										model.eval()
										_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 	lowerCAmelCase			(		self  )		->							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:
															_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(lowerCAmelCase_				,						'use_cache'  ):
																				return

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

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

															_snake_case									=				outputs['past_key_values']
															self.assertEqual(len(lowerCAmelCase_  )				,						lowerCAmelCase_  )

															_snake_case							,     _snake_case									=				inputs['input_ids'].shape
															for i in range(lowerCAmelCase_  ):
																				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					):




					@slow
					def 	lowerCAmelCase			(		self  )		->							Optional[int]:
										_snake_case									=				AutoTokenizer.from_pretrained('Rocketknight1/falcon-rw-1b'  )
										_snake_case									=				FalconForCausalLM.from_pretrained('Rocketknight1/falcon-rw-1b'  )
										model.eval()
										model.to(lowerCAmelCase_  )
										_snake_case									=				tokenizer('My favorite food is'				,						return_tensors='pt'  ).to(lowerCAmelCase_  )

										_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(**lowerCAmelCase_				,						do_sample=lowerCAmelCase_				,						max_new_tokens=19  )
										_snake_case									=				tokenizer.batch_decode(lowerCAmelCase_  )[0]

										self.assertEqual(lowerCAmelCase_				,						lowerCAmelCase_  )




					@slow
					def 	lowerCAmelCase			(		self  )		->							Dict:
										# 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(lowerCAmelCase_  )
															_snake_case									=				FalconForCausalLM.from_pretrained(lowerCAmelCase_  )
															model.eval()
															model.to(lowerCAmelCase_  )
															_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 	lowerCAmelCase			(		self  )		->							Dict:
										# 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(lowerCAmelCase_  )
																				_snake_case									=				FalconForCausalLM.from_pretrained(lowerCAmelCase_  )
																				model.eval()
																				model.to(device=lowerCAmelCase_  )
																				_snake_case									=				tokenizer('My favorite food is'				,						return_tensors='pt'  ).to(lowerCAmelCase_  )

																				# Test results are the same with and without cache
																				_snake_case									=				model.generate(**lowerCAmelCase_				,						do_sample=lowerCAmelCase_				,						max_new_tokens=20				,						use_cache=lowerCAmelCase_  )
																				_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 						lowerCamelCase__     (     UpperCamelCase__			:       list[int]       ,    UpperCamelCase__			:       int						)			-> bool:



					'''simple docstring'''




					_snake_case									=				len(UpperCamelCase__						)
					_snake_case									=				[[False] * (required_sum + 1) for _ in range(arr_len + 1						)]

					# for each arr value, a sum of zero(0) can be formed by not taking any element
					# hence True/1
					for i in range(arr_len + 1						):
										_snake_case									=				True

					# sum is not zero and set is empty then false
					for i in range(1       ,    required_sum + 1						):
										_snake_case									=				False

					for i in range(1       ,    arr_len + 1						):
										for j in range(1       ,    required_sum + 1						):
															if arr[i - 1] > j:
																				_snake_case									=				subset[i - 1][j]
															if arr[i - 1] <= j:
																				_snake_case									=				subset[i - 1][j] or subset[i - 1][j - arr[i - 1]]

					return subset[arr_len][required_sum]


if __name__ == "__main__":
					import doctest

					doctest.testmod()



