




"""simple docstring"""




import json
import os
import shutil
import tempfile
import unittest

from transformers import BatchEncoding, CanineTokenizer
from transformers.testing_utils import require_tokenizers, require_torch
from transformers.tokenization_utils import AddedToken
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin






class        __magic_name__				(			UpperCAmelCase__		,   unittest.TestCase							):






				'''simple docstring'''
				__UpperCamelCase         =		CanineTokenizer
				__UpperCamelCase         =		False





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							super().setUp()
							lowerCamelCase      =   CanineTokenizer()
							tokenizer.save_pretrained(self.tmpdirname					)





				@cached_property
				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							return CanineTokenizer.from_pretrained("""google/canine-s"""					)





				def   _lowerCAmelCase							(			self						,					**_a					):





							"""simple docstring"""
							lowerCamelCase      =   self.tokenizer_class.from_pretrained(self.tmpdirname						,					**_a					)
							lowerCamelCase      =   1_024
							return tokenizer





				@require_torch
				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   self.canine_tokenizer
							lowerCamelCase      =   ["""Life is like a box of chocolates.""", """You never know what you're gonna get."""]
							# fmt: off
							lowerCamelCase      =   [57_344, 76, 105, 102, 101, 32, 105, 115, 32, 108, 105, 107, 101, 32, 97, 32, 98, 111, 120, 32, 111, 102, 32, 99, 104, 111, 99, 111, 108, 97, 116, 101, 115, 46, 57_345, 0, 0, 0, 0]
							# fmt: on
							lowerCamelCase      =   tokenizer(_a						,					padding=_a						,					return_tensors="""pt"""					)
							self.assertIsInstance(_a						,					_a					)

							lowerCamelCase      =   list(batch.input_ids.numpy()[0]					)

							self.assertListEqual(_a						,					_a					)

							self.assertEqual((2, 39)						,					batch.input_ids.shape					)
							self.assertEqual((2, 39)						,					batch.attention_mask.shape					)





				@require_torch
				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   self.canine_tokenizer
							lowerCamelCase      =   ["""Once there was a man.""", """He wrote a test in HuggingFace Tranformers."""]
							lowerCamelCase      =   tokenizer(_a						,					padding=_a						,					return_tensors="""pt"""					)
							# check if input_ids, attention_mask and token_type_ids are returned
							self.assertIn("""input_ids"""						,					_a					)
							self.assertIn("""attention_mask"""						,					_a					)
							self.assertIn("""token_type_ids"""						,					_a					)





				@require_torch
				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   self.canine_tokenizer
							lowerCamelCase      =   [
							    """What's the weater?""",
							    """It's about 25 degrees.""",
							]
							lowerCamelCase      =   tokenizer(
							    text_target=_a						,					max_length=32						,					padding="""max_length"""						,					truncation=_a						,					return_tensors="""pt"""					)
							self.assertEqual(32						,					targets["""input_ids"""].shape[1]					)





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							# safety check on max_len default value so we are sure the test works
							lowerCamelCase      =   self.get_tokenizers()
							for tokenizer in tokenizers:
										with self.subTest(f'{tokenizer.__class__.__name__}'					):
													self.assertNotEqual(tokenizer.model_max_length						,					42					)

        # Now let's start the test
							lowerCamelCase      =   self.get_tokenizers()
							for tokenizer in tokenizers:
										with self.subTest(f'{tokenizer.__class__.__name__}'					):
													# Isolate this from the other tests because we save additional tokens/etc
													lowerCamelCase      =   tempfile.mkdtemp()

													lowerCamelCase      =   """ He is very happy, UNwant\u00E9d,running"""
													lowerCamelCase      =   tokenizer.encode(_a						,					add_special_tokens=_a					)
													tokenizer.save_pretrained(_a					)

													lowerCamelCase      =   tokenizer.__class__.from_pretrained(_a					)
													lowerCamelCase      =   after_tokenizer.encode(_a						,					add_special_tokens=_a					)
													self.assertListEqual(_a						,					_a					)

													shutil.rmtree(_a					)

							lowerCamelCase      =   self.get_tokenizers(model_max_length=42					)
							for tokenizer in tokenizers:
										with self.subTest(f'{tokenizer.__class__.__name__}'					):
													# Isolate this from the other tests because we save additional tokens/etc
													lowerCamelCase      =   tempfile.mkdtemp()

													lowerCamelCase      =   """ He is very happy, UNwant\u00E9d,running"""

													lowerCamelCase      =   tokenizer.additional_special_tokens

													# We can add a new special token for Canine as follows:
													lowerCamelCase      =   chr(0Xe007					)
													additional_special_tokens.append(_a					)
													tokenizer.add_special_tokens({"""additional_special_tokens""": additional_special_tokens}					)
													lowerCamelCase      =   tokenizer.encode(_a						,					add_special_tokens=_a					)
													tokenizer.save_pretrained(_a					)

													lowerCamelCase      =   tokenizer.__class__.from_pretrained(_a					)
													lowerCamelCase      =   after_tokenizer.encode(_a						,					add_special_tokens=_a					)
													self.assertListEqual(_a						,					_a					)
													self.assertIn(_a						,					after_tokenizer.additional_special_tokens					)
													self.assertEqual(after_tokenizer.model_max_length						,					42					)

													lowerCamelCase      =   tokenizer.__class__.from_pretrained(_a						,					model_max_length=43					)
													self.assertEqual(tokenizer.model_max_length						,					43					)

													shutil.rmtree(_a					)





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   self.get_tokenizers(do_lower_case=_a					)
							for tokenizer in tokenizers:
										with self.subTest(f'{tokenizer.__class__.__name__}'					):
													lowerCamelCase ,  lowerCamelCase      =   self.get_clean_sequence(_a					)

													# a special token for Canine can be defined as follows:
													lowerCamelCase      =   0Xe005
													lowerCamelCase      =   chr(_a					)

													tokenizer.add_special_tokens({"""cls_token""": special_token}					)
													lowerCamelCase      =   tokenizer.encode(_a						,					add_special_tokens=_a					)
													self.assertEqual(len(_a					)						,					1					)

													lowerCamelCase      =   tokenizer.decode(ids + encoded_special_token						,					clean_up_tokenization_spaces=_a					)
													lowerCamelCase      =   tokenizer.encode(_a						,					add_special_tokens=_a					)

													lowerCamelCase      =   tokenizer.encode(_a						,					add_special_tokens=_a					)
													lowerCamelCase      =   tokenizer.encode(_a						,					add_special_tokens=_a					)
													self.assertEqual(_a						,					input_encoded + special_token_id					)

													lowerCamelCase      =   tokenizer.decode(_a						,					skip_special_tokens=_a					)
													self.assertTrue(special_token not in decoded					)





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   self.get_tokenizers(do_lower_case=_a					)
							for tokenizer in tokenizers:
										with self.subTest(f'{tokenizer.__class__.__name__}'					):
													lowerCamelCase      =   chr(0Xe005					)
													lowerCamelCase      =   chr(0Xe006					)

													# `add_tokens` method stores special tokens only in `tokenizer.unique_no_split_tokens`. (in tokenization_utils.py)
													tokenizer.add_tokens([SPECIAL_TOKEN_1]						,					special_tokens=_a					)
													# `add_special_tokens` method stores special tokens in `tokenizer.additional_special_tokens`,
													# which also occur in `tokenizer.all_special_tokens`. (in tokenization_utils_base.py)
													tokenizer.add_special_tokens({"""additional_special_tokens""": [SPECIAL_TOKEN_2]}					)

													lowerCamelCase      =   tokenizer.tokenize(_a					)
													lowerCamelCase      =   tokenizer.tokenize(_a					)

													self.assertEqual(len(_a					)						,					1					)
													self.assertEqual(len(_a					)						,					1					)
													self.assertEqual(token_a[0]						,					_a					)
													self.assertEqual(token_a[0]						,					_a					)





				@require_tokenizers
				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   self.get_tokenizers(do_lower_case=_a					)
							for tokenizer in tokenizers:
										with self.subTest(f'{tokenizer.__class__.__name__}'					):
													# a special token for Canine can be defined as follows:
													lowerCamelCase      =   0Xe006
													lowerCamelCase      =   chr(_a					)

													lowerCamelCase      =   AddedToken(_a						,					lstrip=_a					)
													tokenizer.add_special_tokens({"""additional_special_tokens""": [new_token]}					)

													with tempfile.TemporaryDirectory() as tmp_dir_name:
																tokenizer.save_pretrained(_a					)
																tokenizer.from_pretrained(_a					)





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   []
							if self.test_slow_tokenizer:
										tokenizer_list.append((self.tokenizer_class, self.get_tokenizer())					)

							if self.test_rust_tokenizer:
										tokenizer_list.append((self.rust_tokenizer_class, self.get_rust_tokenizer())					)

							for tokenizer_class, tokenizer_utils in tokenizer_list:
										with tempfile.TemporaryDirectory() as tmp_dir:
													tokenizer_utils.save_pretrained(_a					)

													with open(os.path.join(_a						,					"""special_tokens_map.json"""					)						,					encoding="""utf-8"""					) as json_file:
																lowerCamelCase      =   json.load(_a					)

													with open(os.path.join(_a						,					"""tokenizer_config.json"""					)						,					encoding="""utf-8"""					) as json_file:
																lowerCamelCase      =   json.load(_a					)

													# a special token for Canine can be defined as follows:
													lowerCamelCase      =   0Xe006
													lowerCamelCase      =   chr(_a					)

													lowerCamelCase      =   [new_token_a]
													lowerCamelCase      =   [new_token_a]

													with open(os.path.join(_a						,					"""special_tokens_map.json"""					)						,					"""w"""						,					encoding="""utf-8"""					) as outfile:
																json.dump(_a						,					_a					)
													with open(os.path.join(_a						,					"""tokenizer_config.json"""					)						,					"""w"""						,					encoding="""utf-8"""					) as outfile:
																json.dump(_a						,					_a					)

													# the following checks allow us to verify that our test works as expected, i.e. that the tokenizer takes
													# into account the new value of additional_special_tokens given in the "tokenizer_config.json" and
													# "special_tokens_map.json" files
													lowerCamelCase      =   tokenizer_class.from_pretrained(_a						,					extra_ids=0					)
													self.assertIn(_a						,					tokenizer_without_change_in_init.additional_special_tokens					)
													# self.assertIn("an_additional_special_token",tokenizer_without_change_in_init.get_vocab()) # ByT5Tokenization no vocab
													self.assertEqual(
													    [new_token_a]						,					tokenizer_without_change_in_init.convert_ids_to_tokens(
													        tokenizer_without_change_in_init.convert_tokens_to_ids([new_token_a]					)					)						,					)

													lowerCamelCase      =   0Xe007
													lowerCamelCase      =   chr(_a					)
													# Now we test that we can change the value of additional_special_tokens in the from_pretrained
													lowerCamelCase      =   [AddedToken(_a						,					lstrip=_a					)]
													lowerCamelCase      =   tokenizer_class.from_pretrained(
													    _a						,					additional_special_tokens=_a						,					extra_ids=0					)

													self.assertIn(_a						,					tokenizer.additional_special_tokens					)
													# self.assertIn(new_token_2,tokenizer.get_vocab()) # ByT5Tokenization no vocab
													self.assertEqual(
													    [new_token_a]						,					tokenizer.convert_ids_to_tokens(tokenizer.convert_tokens_to_ids([new_token_a]					)					)					)





				@require_tokenizers
				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   self.get_tokenizers(do_lower_case=_a					)
							for tokenizer in tokenizers:
										with self.subTest(f'{tokenizer.__class__.__name__}'					):
													lowerCamelCase      =   """hello world"""
													if self.space_between_special_tokens:
																lowerCamelCase      =   """[CLS] hello world [SEP]"""
													else:
																lowerCamelCase      =   input
													lowerCamelCase      =   tokenizer.encode(_a						,					add_special_tokens=_a					)
													lowerCamelCase      =   tokenizer.decode(_a						,					spaces_between_special_tokens=self.space_between_special_tokens					)
													self.assertIn(_a						,					[output, output.lower()]					)





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   self.get_tokenizers()
							for tokenizer in tokenizers:
										with self.subTest(f'{tokenizer.__class__.__name__}'					):
													lowerCamelCase      =   [
													    """bos_token""",
													    """eos_token""",
													    """unk_token""",
													    """sep_token""",
													    """pad_token""",
													    """cls_token""",
													    """mask_token""",
													]

							lowerCamelCase      =   """a"""
							lowerCamelCase      =   ord(_a					)

							for attr in attributes_list:
										setattr(_a						,					attr + """_id"""						,					_a					)
										self.assertEqual(getattr(_a						,					_a					)						,					_a					)
										self.assertEqual(getattr(_a						,					attr + """_id"""					)						,					_a					)

										setattr(_a						,					attr + """_id"""						,					_a					)
										self.assertEqual(getattr(_a						,					_a					)						,					_a					)
										self.assertEqual(getattr(_a						,					attr + """_id"""					)						,					_a					)

							setattr(_a						,					"""additional_special_tokens_ids"""						,					[]					)
							self.assertListEqual(getattr(_a						,					"""additional_special_tokens"""					)						,					[]					)
							self.assertListEqual(getattr(_a						,					"""additional_special_tokens_ids"""					)						,					[]					)

							lowerCamelCase      =   0Xe006
							lowerCamelCase      =   chr(_a					)
							setattr(_a						,					"""additional_special_tokens_ids"""						,					[additional_special_token_id]					)
							self.assertListEqual(getattr(_a						,					"""additional_special_tokens"""					)						,					[additional_special_token]					)
							self.assertListEqual(getattr(_a						,					"""additional_special_tokens_ids"""					)						,					[additional_special_token_id]					)





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							pass





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							pass





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							pass





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							pass





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							pass





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							pass





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							pass





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							pass









"""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        __magic_name__				:






				'''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=512						,					_a=16						,					_a=2						,					_a=0.02						,					_a=3						,					_a=4						,					_a=None						,					):





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





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   ids_tensor([self.batch_size, self.seq_length]						,					self.vocab_size					)

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

							lowerCamelCase      =   None

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

							lowerCamelCase      =   self.get_config()

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





				def   _lowerCAmelCase							(			self					):





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





				def   _lowerCAmelCase							(			self						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a					):





							"""simple docstring"""
							lowerCamelCase      =   FalconModel(config=_a					)
							model.to(_a					)
							model.eval()
							lowerCamelCase      =   model(_a						,					attention_mask=_a					)
							lowerCamelCase      =   model(_a					)
							self.parent.assertEqual(result.last_hidden_state.shape						,					(self.batch_size, self.seq_length, self.hidden_size)					)





				def   _lowerCAmelCase							(			self						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					):





							"""simple docstring"""
							lowerCamelCase      =   True
							lowerCamelCase      =   FalconModel(_a					)
							model.to(_a					)
							model.eval()
							lowerCamelCase      =   model(
							    _a						,					attention_mask=_a						,					encoder_hidden_states=_a						,					encoder_attention_mask=_a						,					)
							lowerCamelCase      =   model(
							    _a						,					attention_mask=_a						,					encoder_hidden_states=_a						,					)
							lowerCamelCase      =   model(_a						,					attention_mask=_a					)
							self.parent.assertEqual(result.last_hidden_state.shape						,					(self.batch_size, self.seq_length, self.hidden_size)					)





				def   _lowerCAmelCase							(			self						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					):





							"""simple docstring"""
							lowerCamelCase      =   FalconForCausalLM(config=_a					)
							model.to(_a					)
							model.eval()
							lowerCamelCase      =   model(_a						,					attention_mask=_a						,					labels=_a					)
							self.parent.assertEqual(result.logits.shape						,					(self.batch_size, self.seq_length, self.vocab_size)					)





				def   _lowerCAmelCase							(			self						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					):





							"""simple docstring"""
							lowerCamelCase      =   True
							lowerCamelCase      =   True
							lowerCamelCase      =   FalconForCausalLM(config=_a					)
							model.to(_a					)
							model.eval()

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

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

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

							lowerCamelCase      =   model(
							    _a						,					attention_mask=_a						,					encoder_hidden_states=_a						,					encoder_attention_mask=_a						,					output_hidden_states=_a						,					)["""hidden_states"""][0]
							lowerCamelCase      =   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
							lowerCamelCase      =   ids_tensor((1,)						,					output_from_past.shape[-1]					).item()
							lowerCamelCase      =   output_from_no_past[:, -3:, random_slice_idx].detach()
							lowerCamelCase      =   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   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   self.prepare_config_and_inputs()
							(
							    (
							    lowerCamelCase
							) ,  (
							    lowerCamelCase
							) ,  (
							    lowerCamelCase
							) ,  (
							    lowerCamelCase
							) ,  (
							    lowerCamelCase
							) ,  (
							    lowerCamelCase
							) ,  (
							    lowerCamelCase
							) ,  
							)      =   config_and_inputs
							lowerCamelCase      =   {"""input_ids""": input_ids, """attention_mask""": input_mask}
							return config, inputs_dict






@require_torch
class        __magic_name__				(			UpperCAmelCase__		,   UpperCAmelCase__		,   UpperCAmelCase__		,   unittest.TestCase							):






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





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   FalconModelTester(self					)
							lowerCamelCase      =   ConfigTester(self						,					config_class=_a						,					hidden_size=37					)





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							self.config_tester.run_common_tests()





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*_a					)





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase ,  *lowerCamelCase      =   self.model_tester.prepare_config_and_inputs()
							for alibi in [True, False]:
										lowerCamelCase      =   alibi
										self.model_tester.create_and_check_model(_a						,					*_a					)





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase ,  lowerCamelCase      =   self.model_tester.prepare_config_and_inputs_for_common()
							lowerCamelCase      =   3
							lowerCamelCase      =   input_dict["""input_ids"""]
							lowerCamelCase      =   input_ids.ne(1					).to(_a					)
							lowerCamelCase      =   ids_tensor([self.model_tester.batch_size]						,					self.model_tester.type_sequence_label_size					)
							lowerCamelCase      =   FalconForSequenceClassification(_a					)
							model.to(_a					)
							model.eval()
							lowerCamelCase      =   model(_a						,					attention_mask=_a						,					labels=_a					)
							self.assertEqual(result.logits.shape						,					(self.model_tester.batch_size, self.model_tester.num_labels)					)





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase ,  lowerCamelCase      =   self.model_tester.prepare_config_and_inputs_for_common()
							lowerCamelCase      =   3
							lowerCamelCase      =   """single_label_classification"""
							lowerCamelCase      =   input_dict["""input_ids"""]
							lowerCamelCase      =   input_ids.ne(1					).to(_a					)
							lowerCamelCase      =   ids_tensor([self.model_tester.batch_size]						,					self.model_tester.type_sequence_label_size					)
							lowerCamelCase      =   FalconForSequenceClassification(_a					)
							model.to(_a					)
							model.eval()
							lowerCamelCase      =   model(_a						,					attention_mask=_a						,					labels=_a					)
							self.assertEqual(result.logits.shape						,					(self.model_tester.batch_size, self.model_tester.num_labels)					)





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase ,  lowerCamelCase      =   self.model_tester.prepare_config_and_inputs_for_common()
							lowerCamelCase      =   input_dict["""input_ids"""]
							lowerCamelCase      =   FalconForCausalLM(_a					)
							model.to(_a					)
							model.eval()
							lowerCamelCase      =   model(_a						,					use_cache=_a					)
							lowerCamelCase      =   input_ids.shape[0]
							lowerCamelCase      =   model._convert_to_rw_cache(result.past_key_values					)
							lowerCamelCase      =   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   _lowerCAmelCase							(			self					):





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





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							# 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:
										lowerCamelCase ,  lowerCamelCase      =   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

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

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

										lowerCamelCase      =   outputs["""past_key_values"""]
										self.assertEqual(len(_a					)						,					_a					)

										lowerCamelCase ,  lowerCamelCase      =   inputs["""input_ids"""].shape
										for i in range(_a					):
													if config.new_decoder_architecture:
																lowerCamelCase      =   config.num_attention_heads
													elif config.multi_query:
																lowerCamelCase      =   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        __magic_name__				(			unittest.TestCase							):






				'''simple docstring'''





				@slow
				def   _lowerCAmelCase							(			self					):





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

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

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

							self.assertEqual(_a						,					_a					)





				@slow
				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							# 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"]:
										lowerCamelCase      =   AutoTokenizer.from_pretrained(_a					)
										lowerCamelCase      =   FalconForCausalLM.from_pretrained(_a					)
										model.eval()
										model.to(_a					)
										lowerCamelCase      =   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   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							# 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",
										]:
													lowerCamelCase      =   AutoTokenizer.from_pretrained(_a					)
													lowerCamelCase      =   FalconForCausalLM.from_pretrained(_a					)
													model.eval()
													model.to(device=_a					)
													lowerCamelCase      =   tokenizer("""My favorite food is"""						,					return_tensors="""pt"""					).to(_a					)

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



