


"""simple docstring"""






from __future__ import annotations


def __lowercase     (      lowerCamelCase_  :      list						,					lowerCamelCase_  :      int						,					lowerCamelCase_  :      int						,					lowerCamelCase_  :      int  ):
    SCREAMING_SNAKE_CASE__     							=				[]
    SCREAMING_SNAKE_CASE__							,      SCREAMING_SNAKE_CASE__     							=				input_list[low:mid], input_list[mid : high + 1]
    while left and right:
        result.append((left if left[0] <= right[0] else right).pop(0  )  )
    SCREAMING_SNAKE_CASE__     							=				result + left + right
    return input_list


def __lowercase     (      lowerCamelCase_  :      list  ):
    if len(lowerCamelCase_  ) <= 1:
        return input_list
    SCREAMING_SNAKE_CASE__     							=				list(lowerCamelCase_  )

    # iteration for two-way merging
    SCREAMING_SNAKE_CASE__     							=				2
    while p <= len(lowerCamelCase_  ):
        # getting low, high and middle value for merge-sort of single list
        for i in range(0						,					len(lowerCamelCase_  )						,					lowerCamelCase_  ):
            SCREAMING_SNAKE_CASE__     							=				i
            SCREAMING_SNAKE_CASE__     							=				i + p - 1
            SCREAMING_SNAKE_CASE__     							=				(low + high + 1) // 2
            SCREAMING_SNAKE_CASE__     							=				merge(lowerCamelCase_						,					lowerCamelCase_						,					lowerCamelCase_						,					lowerCamelCase_  )
        # final merge of last two parts
        if p * 2 >= len(lowerCamelCase_  ):
            SCREAMING_SNAKE_CASE__     							=				i
            SCREAMING_SNAKE_CASE__     							=				merge(lowerCamelCase_						,					0						,					lowerCamelCase_						,					len(lowerCamelCase_  ) - 1  )
            break
        p *= 2

    return input_list


if __name__ == "__main__":
 _lowerCamelCase     =  input('Enter numbers separated by a comma:\n').strip()
 if user_input == "":
  _lowerCamelCase     =  []
 else:
  _lowerCamelCase     =  [int(item.strip()) for item in user_input.split(',')]
 print(iter_merge_sort(unsorted))




"""simple docstring"""






import unittest

from transformers import AutoTokenizer, FalconConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
	import torch

	from transformers import (
	    FalconForCausalLM,
	    FalconForQuestionAnswering,
	    FalconForSequenceClassification,
	    FalconForTokenClassification,
	    FalconModel,
	)


class 			lowerCamelCase_		:





				"""simple docstring"""







				def __init__(						self       ,		UpperCAmelCase__       ,		UpperCAmelCase__=3       ,		UpperCAmelCase__=7       ,		UpperCAmelCase__=True       ,		UpperCAmelCase__=True       ,		UpperCAmelCase__=False       ,		UpperCAmelCase__=True       ,		UpperCAmelCase__=99       ,		UpperCAmelCase__=32       ,		UpperCAmelCase__=5       ,		UpperCAmelCase__=4       ,		UpperCAmelCase__=37       ,		UpperCAmelCase__="gelu"       ,		UpperCAmelCase__=0.1       ,		UpperCAmelCase__=0.1       ,		UpperCAmelCase__=512       ,		UpperCAmelCase__=16       ,		UpperCAmelCase__=2       ,		UpperCAmelCase__=0.02       ,		UpperCAmelCase__=3       ,		UpperCAmelCase__=4       ,		UpperCAmelCase__=None       ,		):
								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   lowerCAmelCase__		(						self     ):
								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   lowerCAmelCase__		(						self     ):
								return FalconConfig(
								    vocab_size=self.vocab_size       ,		hidden_size=self.hidden_size       ,		num_hidden_layers=self.num_hidden_layers       ,		num_attention_heads=self.num_attention_heads       ,		intermediate_size=self.intermediate_size       ,		hidden_act=self.hidden_act       ,		hidden_dropout_prob=self.hidden_dropout_prob       ,		attention_probs_dropout_prob=self.attention_probs_dropout_prob       ,		max_position_embeddings=self.max_position_embeddings       ,		type_vocab_size=self.type_vocab_size       ,		is_decoder=UpperCAmelCase__       ,		initializer_range=self.initializer_range       ,		pad_token_id=1       ,		new_decoder_architecture=UpperCAmelCase__       ,		)



				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__     ):
								SCREAMING_SNAKE_CASE__     							=				FalconModel(config=UpperCAmelCase__     )
								model.to(UpperCAmelCase__     )
								model.eval()
								SCREAMING_SNAKE_CASE__     							=				model(UpperCAmelCase__       ,		attention_mask=UpperCAmelCase__     )
								SCREAMING_SNAKE_CASE__     							=				model(UpperCAmelCase__     )
								self.parent.assertEqual(result.last_hidden_state.shape       ,		(self.batch_size, self.seq_length, self.hidden_size)     )



				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		):
								SCREAMING_SNAKE_CASE__     							=				True
								SCREAMING_SNAKE_CASE__     							=				FalconModel(UpperCAmelCase__     )
								model.to(UpperCAmelCase__     )
								model.eval()
								SCREAMING_SNAKE_CASE__     							=				model(
								    UpperCAmelCase__       ,		attention_mask=UpperCAmelCase__       ,		encoder_hidden_states=UpperCAmelCase__       ,		encoder_attention_mask=UpperCAmelCase__       ,		)
								SCREAMING_SNAKE_CASE__     							=				model(
								    UpperCAmelCase__       ,		attention_mask=UpperCAmelCase__       ,		encoder_hidden_states=UpperCAmelCase__       ,		)
								SCREAMING_SNAKE_CASE__     							=				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       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		):
								SCREAMING_SNAKE_CASE__     							=				FalconForCausalLM(config=UpperCAmelCase__     )
								model.to(UpperCAmelCase__     )
								model.eval()
								SCREAMING_SNAKE_CASE__     							=				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       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		):
								SCREAMING_SNAKE_CASE__     							=				True
								SCREAMING_SNAKE_CASE__     							=				True
								SCREAMING_SNAKE_CASE__     							=				FalconForCausalLM(config=UpperCAmelCase__     )
								model.to(UpperCAmelCase__     )
								model.eval()

								# first forward pass
								SCREAMING_SNAKE_CASE__     							=				model(
								    UpperCAmelCase__       ,		attention_mask=UpperCAmelCase__       ,		encoder_hidden_states=UpperCAmelCase__       ,		encoder_attention_mask=UpperCAmelCase__       ,		use_cache=UpperCAmelCase__       ,		)
								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(
								    UpperCAmelCase__       ,		attention_mask=UpperCAmelCase__       ,		encoder_hidden_states=UpperCAmelCase__       ,		encoder_attention_mask=UpperCAmelCase__       ,		output_hidden_states=UpperCAmelCase__       ,		)["hidden_states"][0]
								SCREAMING_SNAKE_CASE__     							=				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
								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(UpperCAmelCase__       ,		UpperCAmelCase__       ,		atol=1e-3     )     )






				def   lowerCAmelCase__		(						self     ):
								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 			lowerCamelCase_		(			lowercase       ,  lowercase       ,  lowercase       ,  unittest.TestCase   ):





				"""simple docstring"""







				_lowerCAmelCase      :      Optional[Any]      							=					(
				    (
				        FalconModel,
				        FalconForCausalLM,
				        FalconForSequenceClassification,
				        FalconForTokenClassification,
				        FalconForQuestionAnswering,
				    )
				    if is_torch_available()
				    else ()
				)
				_lowerCAmelCase      :      str      							=					(FalconForCausalLM,) if is_torch_available() else ()
				_lowerCAmelCase      :      Optional[int]      							=					(
				    {
				        "feature-extraction": FalconModel,
				        "text-classification": FalconForSequenceClassification,
				        "text-generation": FalconForCausalLM,
				        "question-answering": FalconForQuestionAnswering,
				        "token-classification": FalconForTokenClassification,
				        "zero-shot": FalconForSequenceClassification,
				    }
				    if is_torch_available()
				    else {}
				)
				_lowerCAmelCase      :      str      							=					False
				_lowerCAmelCase      :      Dict      							=					False



				def   lowerCAmelCase__		(						self     ):
								SCREAMING_SNAKE_CASE__     							=				FalconModelTester(self     )
								SCREAMING_SNAKE_CASE__     							=				ConfigTester(self       ,		config_class=UpperCAmelCase__       ,		hidden_size=37     )



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



				def   lowerCAmelCase__		(						self     ):
								SCREAMING_SNAKE_CASE__     							=				self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*UpperCAmelCase__     )



				def   lowerCAmelCase__		(						self     ):
								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(UpperCAmelCase__       ,		*UpperCAmelCase__     )



				def   lowerCAmelCase__		(						self     ):
								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(UpperCAmelCase__     )
								SCREAMING_SNAKE_CASE__     							=				ids_tensor([self.model_tester.batch_size]       ,		self.model_tester.type_sequence_label_size     )
								SCREAMING_SNAKE_CASE__     							=				FalconForSequenceClassification(UpperCAmelCase__     )
								model.to(UpperCAmelCase__     )
								model.eval()
								SCREAMING_SNAKE_CASE__     							=				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     ):
								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(UpperCAmelCase__     )
								SCREAMING_SNAKE_CASE__     							=				ids_tensor([self.model_tester.batch_size]       ,		self.model_tester.type_sequence_label_size     )
								SCREAMING_SNAKE_CASE__     							=				FalconForSequenceClassification(UpperCAmelCase__     )
								model.to(UpperCAmelCase__     )
								model.eval()
								SCREAMING_SNAKE_CASE__     							=				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     ):
								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(UpperCAmelCase__     )
								model.to(UpperCAmelCase__     )
								model.eval()
								SCREAMING_SNAKE_CASE__     							=				model(UpperCAmelCase__       ,		use_cache=UpperCAmelCase__     )
								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(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     ):
								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(UpperCAmelCase__     )
								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(UpperCAmelCase__     )
								model.to(UpperCAmelCase__     )
								model.eval()
								SCREAMING_SNAKE_CASE__     							=				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     ):
								# 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(UpperCAmelCase__       ,		"use_cache"     ):
																return

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

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

												SCREAMING_SNAKE_CASE__     							=				outputs["past_key_values"]
												self.assertEqual(len(UpperCAmelCase__     )       ,		UpperCAmelCase__     )

												SCREAMING_SNAKE_CASE__							,      SCREAMING_SNAKE_CASE__     							=				inputs["input_ids"].shape
												for i in range(UpperCAmelCase__     ):
																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 			lowerCamelCase_		(			unittest.TestCase   ):





				"""simple docstring"""







				@slow
				def   lowerCAmelCase__		(						self     ):
								SCREAMING_SNAKE_CASE__     							=				AutoTokenizer.from_pretrained("Rocketknight1/falcon-rw-1b"     )
								SCREAMING_SNAKE_CASE__     							=				FalconForCausalLM.from_pretrained("Rocketknight1/falcon-rw-1b"     )
								model.eval()
								model.to(UpperCAmelCase__     )
								SCREAMING_SNAKE_CASE__     							=				tokenizer("My favorite food is"       ,		return_tensors="pt"     ).to(UpperCAmelCase__     )

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

								self.assertEqual(UpperCAmelCase__       ,		UpperCAmelCase__     )



				@slow
				def   lowerCAmelCase__		(						self     ):
								# 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(UpperCAmelCase__     )
												SCREAMING_SNAKE_CASE__     							=				FalconForCausalLM.from_pretrained(UpperCAmelCase__     )
												model.eval()
												model.to(UpperCAmelCase__     )
												SCREAMING_SNAKE_CASE__     							=				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     ):
								# 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(UpperCAmelCase__     )
																SCREAMING_SNAKE_CASE__     							=				FalconForCausalLM.from_pretrained(UpperCAmelCase__     )
																model.eval()
																model.to(device=UpperCAmelCase__     )
																SCREAMING_SNAKE_CASE__     							=				tokenizer("My favorite food is"       ,		return_tensors="pt"     ).to(UpperCAmelCase__     )

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