




'''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     _a						:
       def __init__(			self		:			str     ,       lowercase		:			Any     ,       lowercase		:			Optional[int]=3     ,       lowercase		:			List[Any]=7     ,       lowercase		:			List[str]=True     ,       lowercase		:			List[str]=True     ,       lowercase		:			Union[str, Any]=False     ,       lowercase		:			Optional[int]=True     ,       lowercase		:			str=99     ,       lowercase		:			int=32     ,       lowercase		:			Optional[int]=5     ,       lowercase		:			Tuple=4     ,       lowercase		:			Optional[Any]=37     ,       lowercase		:			Any="gelu"     ,       lowercase		:			Optional[int]=0.1     ,       lowercase		:			Any=0.1     ,       lowercase		:			str=512     ,       lowercase		:			str=16     ,       lowercase		:			str=2     ,       lowercase		:			str=0.02     ,       lowercase		:			List[str]=3     ,       lowercase		:			Union[str, Any]=4     ,       lowercase		:			Optional[int]=None     ,       ):



           '''simple docstring'''

           UpperCAmelCase     =	parent
           UpperCAmelCase     =	batch_size
           UpperCAmelCase     =	seq_length
           UpperCAmelCase     =	is_training
           UpperCAmelCase     =	use_input_mask
           UpperCAmelCase     =	use_token_type_ids
           UpperCAmelCase     =	use_labels
           UpperCAmelCase     =	vocab_size
           UpperCAmelCase     =	hidden_size
           UpperCAmelCase     =	num_hidden_layers
           UpperCAmelCase     =	num_attention_heads
           UpperCAmelCase     =	intermediate_size
           UpperCAmelCase     =	hidden_act
           UpperCAmelCase     =	hidden_dropout_prob
           UpperCAmelCase     =	attention_probs_dropout_prob
           UpperCAmelCase     =	max_position_embeddings
           UpperCAmelCase     =	type_vocab_size
           UpperCAmelCase     =	type_sequence_label_size
           UpperCAmelCase     =	initializer_range
           UpperCAmelCase     =	num_labels
           UpperCAmelCase     =	num_choices
           UpperCAmelCase     =	scope
       def 					A   (			self		:			Tuple       ):



           '''simple docstring'''

           UpperCAmelCase     =	ids_tensor([self.batch_size, self.seq_length]     ,       self.vocab_size       )

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

           UpperCAmelCase     =	None

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

           UpperCAmelCase     =	self.get_config()

           return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
       def 					A   (			self		:			Tuple       ):



           '''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 					A   (			self		:			List[str]     ,       lowercase		:			Dict     ,       lowercase		:			List[Any]     ,       lowercase		:			Optional[Any]     ,       lowercase		:			List[Any]     ,       lowercase		:			Tuple     ,       lowercase		:			List[str]     ,       lowercase		:			str       ):



           '''simple docstring'''

           UpperCAmelCase     =	FalconModel(config=lowercase       )
           model.to(lowercase       )
           model.eval()
           UpperCAmelCase     =	model(lowercase     ,       attention_mask=lowercase       )
           UpperCAmelCase     =	model(lowercase       )
           self.parent.assertEqual(result.last_hidden_state.shape     ,       (self.batch_size, self.seq_length, self.hidden_size)       )
       def 					A   (			self		:			str     ,       lowercase		:			List[str]     ,       lowercase		:			Dict     ,       lowercase		:			int     ,       lowercase		:			Dict     ,       lowercase		:			List[Any]     ,       lowercase		:			Any     ,       lowercase		:			List[Any]     ,       lowercase		:			Optional[int]     ,       lowercase		:			Dict     ,       ):



           '''simple docstring'''

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



           '''simple docstring'''

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



           '''simple docstring'''

           UpperCAmelCase     =	True
           UpperCAmelCase     =	True
           UpperCAmelCase     =	FalconForCausalLM(config=lowercase       )
           model.to(lowercase       )
           model.eval()

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

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

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

           UpperCAmelCase     =	model(
               lowercase     ,       attention_mask=lowercase     ,       encoder_hidden_states=lowercase     ,       encoder_attention_mask=lowercase     ,       output_hidden_states=lowercase     ,       )['''hidden_states'''][0]
           UpperCAmelCase     =	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
           UpperCAmelCase     =	ids_tensor((1,)     ,       output_from_past.shape[-1]       ).item()
           UpperCAmelCase     =	output_from_no_past[:, -3:, random_slice_idx].detach()
           UpperCAmelCase     =	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 					A   (			self		:			int       ):



           '''simple docstring'''

           UpperCAmelCase     =	self.prepare_config_and_inputs()
           (
               (
               UpperCAmelCase
           ) ,  (
               UpperCAmelCase
           ) ,  (
               UpperCAmelCase
           ) ,  (
               UpperCAmelCase
           ) ,  (
               UpperCAmelCase
           ) ,  (
               UpperCAmelCase
           ) ,  (
               UpperCAmelCase
           ) ,  
           )     =	config_and_inputs
           UpperCAmelCase     =	{'''input_ids''': input_ids, '''attention_mask''': input_mask}
           return config, inputs_dict






@require_torch
class     _a						(			__a							,							__a							,							__a							,							unittest.TestCase				):
       __a       :  List[str]            =      (
           (
               FalconModel,
               FalconForCausalLM,
               FalconForSequenceClassification,
               FalconForTokenClassification,
               FalconForQuestionAnswering,
           )
           if is_torch_available()
           else ()
       )
       __a       :  Optional[int]            =      (FalconForCausalLM,) if is_torch_available() else ()
       __a       :  int            =      (
           {
               """feature-extraction""": FalconModel,
               """text-classification""": FalconForSequenceClassification,
               """text-generation""": FalconForCausalLM,
               """question-answering""": FalconForQuestionAnswering,
               """token-classification""": FalconForTokenClassification,
               """zero-shot""": FalconForSequenceClassification,
           }
           if is_torch_available()
           else {}
       )
       __a       :  str            =      False
       __a       :  int            =      False
       def 					A   (			self		:			List[Any]       ):



           '''simple docstring'''

           UpperCAmelCase     =	FalconModelTester(self       )
           UpperCAmelCase     =	ConfigTester(self     ,       config_class=lowercase     ,       hidden_size=37       )
       def 					A   (			self		:			str       ):



           '''simple docstring'''

           self.config_tester.run_common_tests()
       def 					A   (			self		:			Optional[Any]       ):



           '''simple docstring'''

           UpperCAmelCase     =	self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*lowercase       )
       def 					A   (			self		:			Tuple       ):



           '''simple docstring'''

           UpperCAmelCase ,  *UpperCAmelCase     =	self.model_tester.prepare_config_and_inputs()
           for alibi in [True, False]:
               UpperCAmelCase     =	alibi
               self.model_tester.create_and_check_model(lowercase     ,       *lowercase       )
       def 					A   (			self		:			Optional[Any]       ):



           '''simple docstring'''

           UpperCAmelCase ,  UpperCAmelCase     =	self.model_tester.prepare_config_and_inputs_for_common()
           UpperCAmelCase     =	3
           UpperCAmelCase     =	input_dict['''input_ids''']
           UpperCAmelCase     =	input_ids.ne(1       ).to(lowercase       )
           UpperCAmelCase     =	ids_tensor([self.model_tester.batch_size]     ,       self.model_tester.type_sequence_label_size       )
           UpperCAmelCase     =	FalconForSequenceClassification(lowercase       )
           model.to(lowercase       )
           model.eval()
           UpperCAmelCase     =	model(lowercase     ,       attention_mask=lowercase     ,       labels=lowercase       )
           self.assertEqual(result.logits.shape     ,       (self.model_tester.batch_size, self.model_tester.num_labels)       )
       def 					A   (			self		:			Optional[Any]       ):



           '''simple docstring'''

           UpperCAmelCase ,  UpperCAmelCase     =	self.model_tester.prepare_config_and_inputs_for_common()
           UpperCAmelCase     =	3
           UpperCAmelCase     =	'''single_label_classification'''
           UpperCAmelCase     =	input_dict['''input_ids''']
           UpperCAmelCase     =	input_ids.ne(1       ).to(lowercase       )
           UpperCAmelCase     =	ids_tensor([self.model_tester.batch_size]     ,       self.model_tester.type_sequence_label_size       )
           UpperCAmelCase     =	FalconForSequenceClassification(lowercase       )
           model.to(lowercase       )
           model.eval()
           UpperCAmelCase     =	model(lowercase     ,       attention_mask=lowercase     ,       labels=lowercase       )
           self.assertEqual(result.logits.shape     ,       (self.model_tester.batch_size, self.model_tester.num_labels)       )
       def 					A   (			self		:			List[Any]       ):



           '''simple docstring'''

           UpperCAmelCase ,  UpperCAmelCase     =	self.model_tester.prepare_config_and_inputs_for_common()
           UpperCAmelCase     =	input_dict['''input_ids''']
           UpperCAmelCase     =	FalconForCausalLM(lowercase       )
           model.to(lowercase       )
           model.eval()
           UpperCAmelCase     =	model(lowercase     ,       use_cache=lowercase       )
           UpperCAmelCase     =	input_ids.shape[0]
           UpperCAmelCase     =	model._convert_to_rw_cache(result.past_key_values       )
           UpperCAmelCase     =	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 					A   (			self		:			Union[str, Any]       ):



           '''simple docstring'''

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







       def 					A   (			self		:			str       ):



           '''simple docstring'''

           for model_class in self.all_generative_model_classes:
               UpperCAmelCase ,  UpperCAmelCase     =	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

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

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

               UpperCAmelCase     =	outputs['''past_key_values''']
               self.assertEqual(len(lowercase       )     ,       lowercase       )

               UpperCAmelCase ,  UpperCAmelCase     =	inputs['''input_ids'''].shape
               for i in range(lowercase       ):
                   if config.new_decoder_architecture:
                       UpperCAmelCase     =	config.num_attention_heads
                   elif config.multi_query:
                       UpperCAmelCase     =	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     _a						(			unittest.TestCase				):
       @slow
       def 					A   (			self		:			str       ):



           '''simple docstring'''

           UpperCAmelCase     =	AutoTokenizer.from_pretrained('''Rocketknight1/falcon-rw-1b'''       )
           UpperCAmelCase     =	FalconForCausalLM.from_pretrained('''Rocketknight1/falcon-rw-1b'''       )
           model.eval()
           model.to(lowercase       )
           UpperCAmelCase     =	tokenizer('''My favorite food is'''     ,       return_tensors='''pt'''       ).to(lowercase       )

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

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

           self.assertEqual(lowercase     ,       lowercase       )
       @slow
       def 					A   (			self		:			Union[str, Any]       ):



           '''simple docstring'''

           for repo in ["Rocketknight1/tiny-random-falcon-7b", "Rocketknight1/tiny-random-falcon-40b"]:
               UpperCAmelCase     =	AutoTokenizer.from_pretrained(lowercase       )
               UpperCAmelCase     =	FalconForCausalLM.from_pretrained(lowercase       )
               model.eval()
               model.to(lowercase       )
               UpperCAmelCase     =	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 					A   (			self		:			Union[str, Any]       ):



           '''simple docstring'''

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

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










'''simple docstring'''







from typing import Union

from ..utils import add_end_docstrings, is_torch_available, is_vision_available, logging
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_vision_available():
   from PIL import Image

   from ..image_utils import load_image

if is_torch_available():
   from ..models.auto.modeling_auto import MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING

A									=logging.get_logger(__name__)


@add_end_docstrings(__a				)
class     _a						(			__a				):
       def __init__(			self		:			Optional[int]     ,       *lowercase		:			Any     ,       **lowercase		:			Optional[int]       ):



           '''simple docstring'''

           super().__init__(*lowercase     ,       **lowercase       )
           self.check_model_type(lowercase       )
       def 					A   (			self		:			List[str]     ,       lowercase		:			str=None     ,       lowercase		:			List[str]=None     ,       lowercase		:			List[str]=None     ,       **lowercase		:			List[str]       ):



           '''simple docstring'''

           UpperCAmelCase ,  UpperCAmelCase     =	{}, {}
           if padding is not None:
               UpperCAmelCase     =	padding
           if truncation is not None:
               UpperCAmelCase     =	truncation
           if top_k is not None:
               UpperCAmelCase     =	top_k
           return preprocess_params, {}, postprocess_params
       def __call__(			self		:			Optional[Any]     ,       lowercase		:			Union["Image.Image", str]     ,       lowercase		:			str = None     ,       **lowercase		:			Optional[int]       ):



           '''simple docstring'''

           if isinstance(lowercase     ,       (Image.Image, str)       ) and isinstance(lowercase     ,       lowercase       ):
               UpperCAmelCase     =	{'''image''': image, '''question''': question}
           else:
               UpperCAmelCase     =	image
           UpperCAmelCase     =	super().__call__(lowercase     ,       **lowercase       )
           return results
       def 					A   (			self		:			List[Any]     ,       lowercase		:			List[str]     ,       lowercase		:			Any=False     ,       lowercase		:			Any=False       ):



           '''simple docstring'''

           UpperCAmelCase     =	load_image(inputs['''image''']       )
           UpperCAmelCase     =	self.tokenizer(
               inputs['''question''']     ,       return_tensors=self.framework     ,       padding=lowercase     ,       truncation=lowercase       )
           UpperCAmelCase     =	self.image_processor(images=lowercase     ,       return_tensors=self.framework       )
           model_inputs.update(lowercase       )
           return model_inputs
       def 					A   (			self		:			Dict     ,       lowercase		:			Optional[Any]       ):



           '''simple docstring'''

           UpperCAmelCase     =	self.model(**lowercase       )
           return model_outputs







       def 					A   (			self		:			Union[str, Any]     ,       lowercase		:			int     ,       lowercase		:			Optional[Any]=5       ):



           '''simple docstring'''

           if top_k > self.model.config.num_labels:
               UpperCAmelCase     =	self.model.config.num_labels

           if self.framework == "pt":
               UpperCAmelCase     =	model_outputs.logits.sigmoid()[0]
               UpperCAmelCase ,  UpperCAmelCase     =	probs.topk(lowercase       )
           else:
               raise ValueError(f"Unsupported framework: {self.framework}"       )

           UpperCAmelCase     =	scores.tolist()
           UpperCAmelCase     =	ids.tolist()
           return [{"score": score, "answer": self.model.config.idalabel[_id]} for score, _id in zip(lowercase     ,       lowercase       )]




