






"""simple docstring"""






from __future__ import annotations

import unittest

from transformers import XGLMConfig, XGLMTokenizer, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
  import tensorflow as tf

  from transformers.models.xglm.modeling_tf_xglm import (
      TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFXGLMForCausalLM,
      TFXGLMModel,
  )




@require_tf
class 							lowerCAmelCase__       :






      '''simple docstring'''

      __UpperCamelCase							=						XGLMConfig
      __UpperCamelCase							=						{}
      __UpperCamelCase							=						"gelu"
      def __init__(		self  :						Dict		,			lowercase_  :						Union[str, Any]		,			lowercase_  :						List[Any]=14		,			lowercase_  :						List[Any]=7		,			lowercase_  :						Optional[Any]=True		,			lowercase_  :						str=True		,			lowercase_  :						List[Any]=True		,			lowercase_  :						Tuple=99		,			lowercase_  :						Optional[Any]=32		,			lowercase_  :						Dict=2		,			lowercase_  :						List[str]=4		,			lowercase_  :						List[Any]=37		,			lowercase_  :						Union[str, Any]="gelu"		,			lowercase_  :						int=0.1		,			lowercase_  :						Optional[int]=0.1		,			lowercase_  :						int=512		,			lowercase_  :						List[Any]=0.02		,			):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						str							=	parent
          SCREAMING_SNAKE_CASE_   :						List[Any]							=	batch_size
          SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	seq_length
          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	is_training
          SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	use_input_mask
          SCREAMING_SNAKE_CASE_   :						List[str]							=	use_labels
          SCREAMING_SNAKE_CASE_   :						List[str]							=	vocab_size
          SCREAMING_SNAKE_CASE_   :						List[str]							=	d_model
          SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	num_hidden_layers
          SCREAMING_SNAKE_CASE_   :						int							=	num_attention_heads
          SCREAMING_SNAKE_CASE_   :						str							=	ffn_dim
          SCREAMING_SNAKE_CASE_   :						List[Any]							=	activation_function
          SCREAMING_SNAKE_CASE_   :						Dict							=	activation_dropout
          SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	attention_dropout
          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	max_position_embeddings
          SCREAMING_SNAKE_CASE_   :						int							=	initializer_range
          SCREAMING_SNAKE_CASE_   :						Any							=	None
          SCREAMING_SNAKE_CASE_   :						str							=	0
          SCREAMING_SNAKE_CASE_   :						List[Any]							=	2
          SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	1
      def _SCREAMING_SNAKE_CASE				(		self  :						str):




          '''simple docstring'''


          return XGLMConfig.from_pretrained('''facebook/xglm-564M''')
      def _SCREAMING_SNAKE_CASE				(		self  :						List[Any]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						List[Any]							=	tf.clip_by_value(
              ids_tensor([self.batch_size, self.seq_length]		,			self.vocab_size)		,			clip_value_min=0		,			clip_value_max=3)

          SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	None
          if self.use_input_mask:
              SCREAMING_SNAKE_CASE_   :						Any							=	random_attention_mask([self.batch_size, self.seq_length])

          SCREAMING_SNAKE_CASE_   :						Tuple							=	self.get_config()

          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	floats_tensor([self.num_hidden_layers, self.num_attention_heads]		,			2)

          return (
              config,
              input_ids,
              input_mask,
              head_mask,
          )
      def _SCREAMING_SNAKE_CASE				(		self  :						Optional[Any]):




          '''simple docstring'''


          return XGLMConfig(
              vocab_size=self.vocab_size		,			d_model=self.hidden_size		,			num_layers=self.num_hidden_layers		,			attention_heads=self.num_attention_heads		,			ffn_dim=self.ffn_dim		,			activation_function=self.activation_function		,			activation_dropout=self.activation_dropout		,			attention_dropout=self.attention_dropout		,			max_position_embeddings=self.max_position_embeddings		,			initializer_range=self.initializer_range		,			use_cache=lowercase_		,			bos_token_id=self.bos_token_id		,			eos_token_id=self.eos_token_id		,			pad_token_id=self.pad_token_id		,			return_dict=lowercase_		,			)



      def _SCREAMING_SNAKE_CASE				(		self  :						Optional[Any]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	self.prepare_config_and_inputs()

          (
              (
              SCREAMING_SNAKE_CASE_
          )		,    (
              SCREAMING_SNAKE_CASE_
          )		,    (
              SCREAMING_SNAKE_CASE_
          )		,    (
              SCREAMING_SNAKE_CASE_
          )		,    
          )   :						str							=	config_and_inputs

          SCREAMING_SNAKE_CASE_   :						Tuple							=	{
              '''input_ids''': input_ids,
              '''head_mask''': head_mask,
          }

          return config, inputs_dict




@require_tf
class 							lowerCAmelCase__       (    UpperCAmelCase__       ,	UpperCAmelCase__       ,	unittest.TestCase				):






      '''simple docstring'''

      __UpperCamelCase							=						(TFXGLMModel, TFXGLMForCausalLM) if is_tf_available() else ()
      __UpperCamelCase							=						(TFXGLMForCausalLM,) if is_tf_available() else ()
      __UpperCamelCase							=						(
          {"feature-extraction": TFXGLMModel, "text-generation": TFXGLMForCausalLM} if is_tf_available() else {}
      )
      __UpperCamelCase							=						False
      __UpperCamelCase							=						False
      __UpperCamelCase							=						False
      def _SCREAMING_SNAKE_CASE				(		self  :						List[str]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						List[str]							=	TFXGLMModelTester(self)
          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	ConfigTester(self		,			config_class=lowercase_		,			n_embd=37)
      def _SCREAMING_SNAKE_CASE				(		self  :						str):




          '''simple docstring'''


          self.config_tester.run_common_tests()
      @slow
      def _SCREAMING_SNAKE_CASE				(		self  :						int):




          '''simple docstring'''


          for model_name in TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              SCREAMING_SNAKE_CASE_   :						Tuple							=	TFXGLMModel.from_pretrained(lowercase_)
              self.assertIsNotNone(lowercase_)



      @unittest.skip(reason='''Currently, model embeddings are going to undergo a major refactor.''')
      def _SCREAMING_SNAKE_CASE				(		self  :						int):




          '''simple docstring'''


          super().test_resize_token_embeddings()




@require_tf
class 							lowerCAmelCase__       (    unittest.TestCase				):






      '''simple docstring'''

      @slow
      def _SCREAMING_SNAKE_CASE				(		self  :						Dict		,			lowercase_  :						List[str]=True):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						int							=	TFXGLMForCausalLM.from_pretrained('''facebook/xglm-564M''')
          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	tf.convert_to_tensor([[2, 268, 9865]]		,			dtype=tf.intaa)  # The dog
          # </s> The dog is a very friendly dog. He is very affectionate and loves to play with other
          # fmt: off
          SCREAMING_SNAKE_CASE_   :						Dict							=	[2, 268, 9865, 67, 11, 1988, 57252, 9865, 5, 984, 67, 1988, 213838, 1658, 53, 70446, 33, 6657, 278, 1581]
          # fmt: on
          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	model.generate(lowercase_		,			do_sample=lowercase_		,			num_beams=1)
          if verify_outputs:
              self.assertListEqual(output_ids[0].numpy().tolist()		,			lowercase_)
      @slow
      def _SCREAMING_SNAKE_CASE				(		self  :						int):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						Dict							=	XGLMTokenizer.from_pretrained('''facebook/xglm-564M''')
          SCREAMING_SNAKE_CASE_   :						int							=	TFXGLMForCausalLM.from_pretrained('''facebook/xglm-564M''')

          tf.random.set_seed(0)
          SCREAMING_SNAKE_CASE_   :						int							=	tokenizer('''Today is a nice day and'''		,			return_tensors='''tf''')
          SCREAMING_SNAKE_CASE_   :						Any							=	tokenized.input_ids
          # forces the generation to happen on CPU, to avoid GPU-related quirks (and assure same output regardless of the available devices)
          with tf.device(''':/CPU:0'''):
              SCREAMING_SNAKE_CASE_   :						Dict							=	model.generate(lowercase_		,			do_sample=lowercase_		,			seed=[7, 0])
          SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	tokenizer.decode(output_ids[0]		,			skip_special_tokens=lowercase_)

          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	(
              '''Today is a nice day and warm evening here over Southern Alberta!! Today when they closed schools due'''
          )
          self.assertEqual(lowercase_		,			lowercase_)



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




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						Dict							=	TFXGLMForCausalLM.from_pretrained('''facebook/xglm-564M''')
          SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	XGLMTokenizer.from_pretrained('''facebook/xglm-564M''')

          SCREAMING_SNAKE_CASE_   :						Dict							=	'''left'''

          # use different length sentences to test batching
          SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	[
              '''This is an extremelly long sentence that only exists to test the ability of the model to cope with '''
              '''left-padding, such as in batched generation. The output for the sequence below should be the same '''
              '''regardless of whether left padding is applied or not. When''',
              '''Hello, my dog is a little''',
          ]

          SCREAMING_SNAKE_CASE_   :						int							=	tokenizer(lowercase_		,			return_tensors='''tf'''		,			padding=lowercase_)
          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	inputs['''input_ids''']

          SCREAMING_SNAKE_CASE_   :						Any							=	model.generate(input_ids=lowercase_		,			attention_mask=inputs['''attention_mask''']		,			max_new_tokens=12)

          SCREAMING_SNAKE_CASE_   :						Tuple							=	tokenizer(sentences[0]		,			return_tensors='''tf''').input_ids
          SCREAMING_SNAKE_CASE_   :						List[str]							=	model.generate(input_ids=lowercase_		,			max_new_tokens=12)

          SCREAMING_SNAKE_CASE_   :						Any							=	tokenizer(sentences[1]		,			return_tensors='''tf''').input_ids
          SCREAMING_SNAKE_CASE_   :						int							=	model.generate(input_ids=lowercase_		,			max_new_tokens=12)

          SCREAMING_SNAKE_CASE_   :						Any							=	tokenizer.batch_decode(lowercase_		,			skip_special_tokens=lowercase_)
          SCREAMING_SNAKE_CASE_   :						Tuple							=	tokenizer.decode(output_non_padded[0]		,			skip_special_tokens=lowercase_)
          SCREAMING_SNAKE_CASE_   :						Tuple							=	tokenizer.decode(output_padded[0]		,			skip_special_tokens=lowercase_)

          SCREAMING_SNAKE_CASE_   :						Dict							=	[
              '''This is an extremelly long sentence that only exists to test the ability of the model to cope with '''
              '''left-padding, such as in batched generation. The output for the sequence below should be the same '''
              '''regardless of whether left padding is applied or not. When left padding is applied, the sequence will be '''
              '''a single''',
              '''Hello, my dog is a little bit of a shy one, but he is very friendly''',
          ]
          self.assertListEqual(lowercase_		,			lowercase_)
          self.assertListEqual(lowercase_		,			[non_padded_sentence, padded_sentence])










"""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  :						Any		,			lowercase_  :						Dict		,			lowercase_  :						str=3		,			lowercase_  :						Dict=7		,			lowercase_  :						Any=True		,			lowercase_  :						List[Any]=True		,			lowercase_  :						Union[str, Any]=False		,			lowercase_  :						Optional[int]=True		,			lowercase_  :						Union[str, Any]=99		,			lowercase_  :						Dict=32		,			lowercase_  :						Union[str, Any]=5		,			lowercase_  :						Optional[Any]=4		,			lowercase_  :						List[str]=37		,			lowercase_  :						int="gelu"		,			lowercase_  :						int=0.1		,			lowercase_  :						List[str]=0.1		,			lowercase_  :						Any=512		,			lowercase_  :						List[Any]=16		,			lowercase_  :						Union[str, Any]=2		,			lowercase_  :						Dict=0.02		,			lowercase_  :						Optional[int]=3		,			lowercase_  :						Dict=4		,			lowercase_  :						Optional[int]=None		,			):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						List[Any]							=	parent
          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	batch_size
          SCREAMING_SNAKE_CASE_   :						List[str]							=	seq_length
          SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	is_training
          SCREAMING_SNAKE_CASE_   :						Dict							=	use_input_mask
          SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	use_token_type_ids
          SCREAMING_SNAKE_CASE_   :						str							=	use_labels
          SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	vocab_size
          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	hidden_size
          SCREAMING_SNAKE_CASE_   :						str							=	num_hidden_layers
          SCREAMING_SNAKE_CASE_   :						List[Any]							=	num_attention_heads
          SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	intermediate_size
          SCREAMING_SNAKE_CASE_   :						int							=	hidden_act
          SCREAMING_SNAKE_CASE_   :						Dict							=	hidden_dropout_prob
          SCREAMING_SNAKE_CASE_   :						str							=	attention_probs_dropout_prob
          SCREAMING_SNAKE_CASE_   :						str							=	max_position_embeddings
          SCREAMING_SNAKE_CASE_   :						Dict							=	type_vocab_size
          SCREAMING_SNAKE_CASE_   :						str							=	type_sequence_label_size
          SCREAMING_SNAKE_CASE_   :						List[Any]							=	initializer_range
          SCREAMING_SNAKE_CASE_   :						int							=	num_labels
          SCREAMING_SNAKE_CASE_   :						Dict							=	num_choices
          SCREAMING_SNAKE_CASE_   :						Tuple							=	scope
      def _SCREAMING_SNAKE_CASE				(		self  :						List[Any]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	ids_tensor([self.batch_size, self.seq_length]		,			self.vocab_size)

          SCREAMING_SNAKE_CASE_   :						Tuple							=	None
          if self.use_input_mask:
              SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	random_attention_mask([self.batch_size, self.seq_length])

          SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	None

          SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	None
          SCREAMING_SNAKE_CASE_   :						Dict							=	None
          SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	None
          if self.use_labels:
              SCREAMING_SNAKE_CASE_   :						List[Any]							=	ids_tensor([self.batch_size]		,			self.type_sequence_label_size)
              SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	ids_tensor([self.batch_size, self.seq_length]		,			self.num_labels)
              SCREAMING_SNAKE_CASE_   :						str							=	ids_tensor([self.batch_size]		,			self.num_choices)

          SCREAMING_SNAKE_CASE_   :						Dict							=	self.get_config()

          return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
      def _SCREAMING_SNAKE_CASE				(		self  :						Union[str, Any]):




          '''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=lowercase_		,			initializer_range=self.initializer_range		,			pad_token_id=1		,			new_decoder_architecture=lowercase_		,			)
      def _SCREAMING_SNAKE_CASE				(		self  :						Tuple		,			lowercase_  :						List[Any]		,			lowercase_  :						int		,			lowercase_  :						List[str]		,			lowercase_  :						Any		,			lowercase_  :						Optional[Any]		,			lowercase_  :						Union[str, Any]		,			lowercase_  :						Any):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						Tuple							=	FalconModel(config=lowercase_)
          model.to(lowercase_)
          model.eval()
          SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	model(lowercase_		,			attention_mask=lowercase_)
          SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	model(lowercase_)
          self.parent.assertEqual(result.last_hidden_state.shape		,			(self.batch_size, self.seq_length, self.hidden_size))
      def _SCREAMING_SNAKE_CASE				(		self  :						Tuple		,			lowercase_  :						int		,			lowercase_  :						Dict		,			lowercase_  :						int		,			lowercase_  :						str		,			lowercase_  :						str		,			lowercase_  :						int		,			lowercase_  :						Tuple		,			lowercase_  :						Dict		,			lowercase_  :						int		,			):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						Tuple							=	True
          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	FalconModel(lowercase_)
          model.to(lowercase_)
          model.eval()
          SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	model(
              lowercase_		,			attention_mask=lowercase_		,			encoder_hidden_states=lowercase_		,			encoder_attention_mask=lowercase_		,			)
          SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	model(
              lowercase_		,			attention_mask=lowercase_		,			encoder_hidden_states=lowercase_		,			)
          SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	model(lowercase_		,			attention_mask=lowercase_)
          self.parent.assertEqual(result.last_hidden_state.shape		,			(self.batch_size, self.seq_length, self.hidden_size))
      def _SCREAMING_SNAKE_CASE				(		self  :						Dict		,			lowercase_  :						Union[str, Any]		,			lowercase_  :						Tuple		,			lowercase_  :						int		,			lowercase_  :						Optional[Any]		,			lowercase_  :						Dict		,			lowercase_  :						Dict		,			lowercase_  :						Dict		,			lowercase_  :						List[str]		,			lowercase_  :						List[str]		,			):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						int							=	FalconForCausalLM(config=lowercase_)
          model.to(lowercase_)
          model.eval()
          SCREAMING_SNAKE_CASE_   :						Any							=	model(lowercase_		,			attention_mask=lowercase_		,			labels=lowercase_)
          self.parent.assertEqual(result.logits.shape		,			(self.batch_size, self.seq_length, self.vocab_size))
      def _SCREAMING_SNAKE_CASE				(		self  :						List[str]		,			lowercase_  :						Any		,			lowercase_  :						int		,			lowercase_  :						str		,			lowercase_  :						Tuple		,			lowercase_  :						List[str]		,			lowercase_  :						Optional[int]		,			lowercase_  :						Tuple		,			lowercase_  :						Optional[int]		,			lowercase_  :						str		,			):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						Dict							=	True
          SCREAMING_SNAKE_CASE_   :						List[Any]							=	True
          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	FalconForCausalLM(config=lowercase_)
          model.to(lowercase_)
          model.eval()

          # first forward pass
          SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	model(
              lowercase_		,			attention_mask=lowercase_		,			encoder_hidden_states=lowercase_		,			encoder_attention_mask=lowercase_		,			use_cache=lowercase_		,			)
          SCREAMING_SNAKE_CASE_   :						List[Any]							=	outputs.past_key_values

          # create hypothetical multiple next token and extent to next_input_ids
          SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	ids_tensor((self.batch_size, 3)		,			config.vocab_size)
          SCREAMING_SNAKE_CASE_   :						List[str]							=	ids_tensor((self.batch_size, 3)		,			vocab_size=2)

          # append to next input_ids and
          SCREAMING_SNAKE_CASE_   :						Dict							=	torch.cat([input_ids, next_tokens]		,			dim=-1)
          SCREAMING_SNAKE_CASE_   :						List[Any]							=	torch.cat([input_mask, next_mask]		,			dim=-1)

          SCREAMING_SNAKE_CASE_   :						List[str]							=	model(
              lowercase_		,			attention_mask=lowercase_		,			encoder_hidden_states=lowercase_		,			encoder_attention_mask=lowercase_		,			output_hidden_states=lowercase_		,			)['''hidden_states'''][0]
          SCREAMING_SNAKE_CASE_   :						Any							=	model(
              lowercase_		,			attention_mask=lowercase_		,			encoder_hidden_states=lowercase_		,			encoder_attention_mask=lowercase_		,			past_key_values=lowercase_		,			output_hidden_states=lowercase_		,			)['''hidden_states'''][0]

          # select random slice
          SCREAMING_SNAKE_CASE_   :						int							=	ids_tensor((1,)		,			output_from_past.shape[-1]).item()
          SCREAMING_SNAKE_CASE_   :						List[Any]							=	output_from_no_past[:, -3:, random_slice_idx].detach()
          SCREAMING_SNAKE_CASE_   :						Dict							=	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(lowercase_		,			lowercase_		,			atol=1e-3))



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




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						Tuple							=	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_
          )		,    
          )   :						Tuple							=	config_and_inputs
          SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	{'''input_ids''': input_ids, '''attention_mask''': input_mask}
          return config, inputs_dict




@require_torch
class 							lowerCAmelCase__       (    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 _SCREAMING_SNAKE_CASE				(		self  :						Optional[int]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						str							=	FalconModelTester(self)
          SCREAMING_SNAKE_CASE_   :						List[Any]							=	ConfigTester(self		,			config_class=lowercase_		,			hidden_size=37)
      def _SCREAMING_SNAKE_CASE				(		self  :						Tuple):




          '''simple docstring'''


          self.config_tester.run_common_tests()
      def _SCREAMING_SNAKE_CASE				(		self  :						int):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						List[Any]							=	self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*lowercase_)
      def _SCREAMING_SNAKE_CASE				(		self  :						int):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_		,    *SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	self.model_tester.prepare_config_and_inputs()
          for alibi in [True, False]:
              SCREAMING_SNAKE_CASE_   :						Optional[int]							=	alibi
              self.model_tester.create_and_check_model(lowercase_		,			*lowercase_)
      def _SCREAMING_SNAKE_CASE				(		self  :						Tuple):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_		,    SCREAMING_SNAKE_CASE_   :						List[str]							=	self.model_tester.prepare_config_and_inputs_for_common()
          SCREAMING_SNAKE_CASE_   :						Tuple							=	3
          SCREAMING_SNAKE_CASE_   :						Tuple							=	input_dict['''input_ids''']
          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	input_ids.ne(1).to(lowercase_)
          SCREAMING_SNAKE_CASE_   :						Dict							=	ids_tensor([self.model_tester.batch_size]		,			self.model_tester.type_sequence_label_size)
          SCREAMING_SNAKE_CASE_   :						Tuple							=	FalconForSequenceClassification(lowercase_)
          model.to(lowercase_)
          model.eval()
          SCREAMING_SNAKE_CASE_   :						List[str]							=	model(lowercase_		,			attention_mask=lowercase_		,			labels=lowercase_)
          self.assertEqual(result.logits.shape		,			(self.model_tester.batch_size, self.model_tester.num_labels))
      def _SCREAMING_SNAKE_CASE				(		self  :						int):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_		,    SCREAMING_SNAKE_CASE_   :						int							=	self.model_tester.prepare_config_and_inputs_for_common()
          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	3
          SCREAMING_SNAKE_CASE_   :						int							=	'''single_label_classification'''
          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	input_dict['''input_ids''']
          SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	input_ids.ne(1).to(lowercase_)
          SCREAMING_SNAKE_CASE_   :						Dict							=	ids_tensor([self.model_tester.batch_size]		,			self.model_tester.type_sequence_label_size)
          SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	FalconForSequenceClassification(lowercase_)
          model.to(lowercase_)
          model.eval()
          SCREAMING_SNAKE_CASE_   :						List[str]							=	model(lowercase_		,			attention_mask=lowercase_		,			labels=lowercase_)
          self.assertEqual(result.logits.shape		,			(self.model_tester.batch_size, self.model_tester.num_labels))
      def _SCREAMING_SNAKE_CASE				(		self  :						Dict):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_		,    SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	self.model_tester.prepare_config_and_inputs_for_common()
          SCREAMING_SNAKE_CASE_   :						List[Any]							=	input_dict['''input_ids''']
          SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	FalconForCausalLM(lowercase_)
          model.to(lowercase_)
          model.eval()
          SCREAMING_SNAKE_CASE_   :						str							=	model(lowercase_		,			use_cache=lowercase_)
          SCREAMING_SNAKE_CASE_   :						Any							=	input_ids.shape[0]
          SCREAMING_SNAKE_CASE_   :						Dict							=	model._convert_to_rw_cache(result.past_key_values)
          SCREAMING_SNAKE_CASE_   :						int							=	model._convert_cache_to_standard_format(lowercase_		,			lowercase_)
          for layer in range(len(lowercase_)):
              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 _SCREAMING_SNAKE_CASE				(		self  :						Tuple):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_		,    SCREAMING_SNAKE_CASE_   :						Optional[int]							=	self.model_tester.prepare_config_and_inputs_for_common()
          SCREAMING_SNAKE_CASE_   :						int							=	3
          SCREAMING_SNAKE_CASE_   :						Tuple							=	'''multi_label_classification'''
          SCREAMING_SNAKE_CASE_   :						Tuple							=	input_dict['''input_ids''']
          SCREAMING_SNAKE_CASE_   :						List[str]							=	input_ids.ne(1).to(lowercase_)
          SCREAMING_SNAKE_CASE_   :						Tuple							=	ids_tensor(
              [self.model_tester.batch_size, config.num_labels]		,			self.model_tester.type_sequence_label_size).to(torch.float)
          SCREAMING_SNAKE_CASE_   :						int							=	FalconForSequenceClassification(lowercase_)
          model.to(lowercase_)
          model.eval()
          SCREAMING_SNAKE_CASE_   :						Tuple							=	model(lowercase_		,			attention_mask=lowercase_		,			labels=lowercase_)
          self.assertEqual(result.logits.shape		,			(self.model_tester.batch_size, self.model_tester.num_labels))



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




          '''simple docstring'''


          for model_class in self.all_generative_model_classes:
              SCREAMING_SNAKE_CASE_		,    SCREAMING_SNAKE_CASE_   :						Optional[int]							=	self.model_tester.prepare_config_and_inputs_for_common()

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

              SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	model_class(lowercase_).to(lowercase_)
              if "use_cache" not in inputs:
                  SCREAMING_SNAKE_CASE_   :						Dict							=	True
              SCREAMING_SNAKE_CASE_   :						str							=	model(**lowercase_)

              # 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_   :						Tuple							=	(
                  getattr(lowercase_		,			'''decoder_layers'''		,			lowercase_)
                  or getattr(lowercase_		,			'''num_decoder_layers'''		,			lowercase_)
                  or config.num_hidden_layers
              )
              SCREAMING_SNAKE_CASE_   :						str							=	getattr(lowercase_		,			'''num_kv_heads'''		,			config.num_attention_heads)
              SCREAMING_SNAKE_CASE_   :						Tuple							=	getattr(lowercase_		,			'''d_model'''		,			config.hidden_size)
              SCREAMING_SNAKE_CASE_   :						Dict							=	embed_dim // num_attention_heads

              SCREAMING_SNAKE_CASE_   :						int							=	outputs['''past_key_values''']
              self.assertEqual(len(lowercase_)		,			lowercase_)

              SCREAMING_SNAKE_CASE_		,    SCREAMING_SNAKE_CASE_   :						List[Any]							=	inputs['''input_ids'''].shape
              for i in range(lowercase_):
                  if config.new_decoder_architecture:
                      SCREAMING_SNAKE_CASE_   :						Dict							=	config.num_attention_heads
                  elif config.multi_query:
                      SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	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 _SCREAMING_SNAKE_CASE				(		self  :						List[str]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						Tuple							=	AutoTokenizer.from_pretrained('''Rocketknight1/falcon-rw-1b''')
          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	FalconForCausalLM.from_pretrained('''Rocketknight1/falcon-rw-1b''')
          model.eval()
          model.to(lowercase_)
          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	tokenizer('''My favorite food is'''		,			return_tensors='''pt''').to(lowercase_)

          SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	(
              '''My favorite food is pizza. I love it so much that I have a pizza party every year for my birthday.'''
          )

          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	model.generate(**lowercase_		,			do_sample=lowercase_		,			max_new_tokens=19)
          SCREAMING_SNAKE_CASE_   :						List[Any]							=	tokenizer.batch_decode(lowercase_)[0]

          self.assertEqual(lowercase_		,			lowercase_)
      @slow
      def _SCREAMING_SNAKE_CASE				(		self  :						Union[str, Any]):




          '''simple docstring'''


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

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



      @slow
      def _SCREAMING_SNAKE_CASE				(		self  :						str):




          '''simple docstring'''


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

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


