






"""simple docstring"""






import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import TransformeraDModel, VQDiffusionPipeline, VQDiffusionScheduler, VQModel
from diffusers.pipelines.vq_diffusion.pipeline_vq_diffusion import LearnedClassifierFreeSamplingEmbeddings
from diffusers.utils import load_numpy, slow, torch_device
from diffusers.utils.testing_utils import require_torch_gpu


UpperCAmelCase_     :				Any         =				False




class 							lowerCAmelCase__       (    unittest.TestCase				):






      '''simple docstring'''

      def _SCREAMING_SNAKE_CASE				(		self  :						Any):




          '''simple docstring'''


          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()
      @property
      def _SCREAMING_SNAKE_CASE				(		self  :						Optional[Any]):




          '''simple docstring'''


          return 12
      @property
      def _SCREAMING_SNAKE_CASE				(		self  :						Dict):




          '''simple docstring'''


          return 12
      @property
      def _SCREAMING_SNAKE_CASE				(		self  :						str):




          '''simple docstring'''


          return 32
      @property
      def _SCREAMING_SNAKE_CASE				(		self  :						Any):




          '''simple docstring'''


          torch.manual_seed(0)
          SCREAMING_SNAKE_CASE_   :						Dict							=	VQModel(
              block_out_channels=[32, 64]		,			in_channels=3		,			out_channels=3		,			down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']		,			up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']		,			latent_channels=3		,			num_vq_embeddings=self.num_embed		,			vq_embed_dim=3		,			)
          return model
      @property
      def _SCREAMING_SNAKE_CASE				(		self  :						Tuple):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						int							=	CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''')
          return tokenizer
      @property
      def _SCREAMING_SNAKE_CASE				(		self  :						Optional[int]):




          '''simple docstring'''


          torch.manual_seed(0)
          SCREAMING_SNAKE_CASE_   :						Any							=	CLIPTextConfig(
              bos_token_id=0		,			eos_token_id=2		,			hidden_size=self.text_embedder_hidden_size		,			intermediate_size=37		,			layer_norm_eps=1e-05		,			num_attention_heads=4		,			num_hidden_layers=5		,			pad_token_id=1		,			vocab_size=1000		,			)
          return CLIPTextModel(_lowerCamelCase)
      @property
      def _SCREAMING_SNAKE_CASE				(		self  :						Dict):




          '''simple docstring'''


          torch.manual_seed(0)

          SCREAMING_SNAKE_CASE_   :						int							=	12
          SCREAMING_SNAKE_CASE_   :						List[str]							=	12

          SCREAMING_SNAKE_CASE_   :						List[Any]							=	{
              '''attention_bias''': True,
              '''cross_attention_dim''': 32,
              '''attention_head_dim''': height * width,
              '''num_attention_heads''': 1,
              '''num_vector_embeds''': self.num_embed,
              '''num_embeds_ada_norm''': self.num_embeds_ada_norm,
              '''norm_num_groups''': 32,
              '''sample_size''': width,
              '''activation_fn''': '''geglu-approximate''',
          }

          SCREAMING_SNAKE_CASE_   :						List[Any]							=	TransformeraDModel(**_lowerCamelCase)
          return model
      def _SCREAMING_SNAKE_CASE				(		self  :						Optional[int]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	'''cpu'''

          SCREAMING_SNAKE_CASE_   :						Tuple							=	self.dummy_vqvae
          SCREAMING_SNAKE_CASE_   :						Dict							=	self.dummy_text_encoder
          SCREAMING_SNAKE_CASE_   :						int							=	self.dummy_tokenizer
          SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	self.dummy_transformer
          SCREAMING_SNAKE_CASE_   :						Any							=	VQDiffusionScheduler(self.num_embed)
          SCREAMING_SNAKE_CASE_   :						Tuple							=	LearnedClassifierFreeSamplingEmbeddings(learnable=_lowerCamelCase)

          SCREAMING_SNAKE_CASE_   :						str							=	VQDiffusionPipeline(
              vqvae=_lowerCamelCase		,			text_encoder=_lowerCamelCase		,			tokenizer=_lowerCamelCase		,			transformer=_lowerCamelCase		,			scheduler=_lowerCamelCase		,			learned_classifier_free_sampling_embeddings=_lowerCamelCase		,			)
          SCREAMING_SNAKE_CASE_   :						str							=	pipe.to(_lowerCamelCase)
          pipe.set_progress_bar_config(disable=_lowerCamelCase)

          SCREAMING_SNAKE_CASE_   :						int							=	'''teddy bear playing in the pool'''

          SCREAMING_SNAKE_CASE_   :						str							=	torch.Generator(device=_lowerCamelCase).manual_seed(0)
          SCREAMING_SNAKE_CASE_   :						List[str]							=	pipe([prompt]		,			generator=_lowerCamelCase		,			num_inference_steps=2		,			output_type='''np''')
          SCREAMING_SNAKE_CASE_   :						Tuple							=	output.images

          SCREAMING_SNAKE_CASE_   :						List[Any]							=	torch.Generator(device=_lowerCamelCase).manual_seed(0)
          SCREAMING_SNAKE_CASE_   :						Dict							=	pipe(
              [prompt]		,			generator=_lowerCamelCase		,			output_type='''np'''		,			return_dict=_lowerCamelCase		,			num_inference_steps=2)[0]

          SCREAMING_SNAKE_CASE_   :						List[Any]							=	image[0, -3:, -3:, -1]
          SCREAMING_SNAKE_CASE_   :						List[Any]							=	image_from_tuple[0, -3:, -3:, -1]

          assert image.shape == (1, 24, 24, 3)

          SCREAMING_SNAKE_CASE_   :						Dict							=	np.array([0.65_51, 0.61_68, 0.50_08, 0.56_76, 0.56_59, 0.42_95, 0.60_73, 0.55_99, 0.49_92])

          assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-2
          assert np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 1e-2



      def _SCREAMING_SNAKE_CASE				(		self  :						Dict):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	'''cpu'''

          SCREAMING_SNAKE_CASE_   :						Dict							=	self.dummy_vqvae
          SCREAMING_SNAKE_CASE_   :						Dict							=	self.dummy_text_encoder
          SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	self.dummy_tokenizer
          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	self.dummy_transformer
          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	VQDiffusionScheduler(self.num_embed)
          SCREAMING_SNAKE_CASE_   :						str							=	LearnedClassifierFreeSamplingEmbeddings(
              learnable=_lowerCamelCase		,			hidden_size=self.text_embedder_hidden_size		,			length=tokenizer.model_max_length)

          SCREAMING_SNAKE_CASE_   :						str							=	VQDiffusionPipeline(
              vqvae=_lowerCamelCase		,			text_encoder=_lowerCamelCase		,			tokenizer=_lowerCamelCase		,			transformer=_lowerCamelCase		,			scheduler=_lowerCamelCase		,			learned_classifier_free_sampling_embeddings=_lowerCamelCase		,			)
          SCREAMING_SNAKE_CASE_   :						int							=	pipe.to(_lowerCamelCase)
          pipe.set_progress_bar_config(disable=_lowerCamelCase)

          SCREAMING_SNAKE_CASE_   :						Any							=	'''teddy bear playing in the pool'''

          SCREAMING_SNAKE_CASE_   :						Tuple							=	torch.Generator(device=_lowerCamelCase).manual_seed(0)
          SCREAMING_SNAKE_CASE_   :						Any							=	pipe([prompt]		,			generator=_lowerCamelCase		,			num_inference_steps=2		,			output_type='''np''')
          SCREAMING_SNAKE_CASE_   :						List[str]							=	output.images

          SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	torch.Generator(device=_lowerCamelCase).manual_seed(0)
          SCREAMING_SNAKE_CASE_   :						Dict							=	pipe(
              [prompt]		,			generator=_lowerCamelCase		,			output_type='''np'''		,			return_dict=_lowerCamelCase		,			num_inference_steps=2)[0]

          SCREAMING_SNAKE_CASE_   :						Tuple							=	image[0, -3:, -3:, -1]
          SCREAMING_SNAKE_CASE_   :						List[str]							=	image_from_tuple[0, -3:, -3:, -1]

          assert image.shape == (1, 24, 24, 3)

          SCREAMING_SNAKE_CASE_   :						Dict							=	np.array([0.66_93, 0.60_75, 0.49_59, 0.57_01, 0.55_83, 0.43_33, 0.61_71, 0.56_84, 0.49_88])

          assert np.abs(image_slice.flatten() - expected_slice).max() < 2.0
          assert np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 1e-2




@slow
@require_torch_gpu
class 							lowerCAmelCase__       (    unittest.TestCase				):






      '''simple docstring'''

      def _SCREAMING_SNAKE_CASE				(		self  :						List[Any]):




          '''simple docstring'''


          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()



      def _SCREAMING_SNAKE_CASE				(		self  :						List[Any]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						Any							=	load_numpy(
              '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
              '''/vq_diffusion/teddy_bear_pool_classifier_free_sampling.npy''')

          SCREAMING_SNAKE_CASE_   :						int							=	VQDiffusionPipeline.from_pretrained('''microsoft/vq-diffusion-ithq''')
          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	pipeline.to(_lowerCamelCase)
          pipeline.set_progress_bar_config(disable=_lowerCamelCase)

          # requires GPU generator for gumbel softmax
          # don't use GPU generator in tests though
          SCREAMING_SNAKE_CASE_   :						str							=	torch.Generator(device=_lowerCamelCase).manual_seed(0)
          SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	pipeline(
              '''teddy bear playing in the pool'''		,			num_images_per_prompt=1		,			generator=_lowerCamelCase		,			output_type='''np'''		,			)

          SCREAMING_SNAKE_CASE_   :						int							=	output.images[0]

          assert image.shape == (256, 256, 3)
          assert np.abs(expected_image - image).max() < 2.0










"""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)


