





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:						Tuple		,  _lowerCAmelCase:						Tuple		,  _lowerCAmelCase:						Any=3		,  _lowerCAmelCase:						Any=7		,  _lowerCAmelCase:						List[Any]=True		,  _lowerCAmelCase:						Tuple=True		,  _lowerCAmelCase:						str=False		,  _lowerCAmelCase:						List[Any]=True		,  _lowerCAmelCase:						Dict=99		,  _lowerCAmelCase:						int=32		,  _lowerCAmelCase:						List[str]=5		,  _lowerCAmelCase:						List[str]=4		,  _lowerCAmelCase:						List[str]=37		,  _lowerCAmelCase:						List[Any]="gelu"		,  _lowerCAmelCase:						Optional[Any]=0.1		,  _lowerCAmelCase:						Optional[int]=0.1		,  _lowerCAmelCase:						Any=512		,  _lowerCAmelCase:						Union[str, Any]=16		,  _lowerCAmelCase:						Dict=2		,  _lowerCAmelCase:						List[str]=0.02		,  _lowerCAmelCase:						Optional[int]=3		,  _lowerCAmelCase:						List[str]=4		,  _lowerCAmelCase:						Any=None		,  )						->    Tuple:
         '''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 	lowerCAmelCase__    (	self:						List[str]       )						->    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 	lowerCAmelCase__    (	self:						Optional[Any]       )						->    Optional[int]:
         '''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=_lowerCAmelCase		,  initializer_range=self.initializer_range		,  pad_token_id=1		,  new_decoder_architecture=_lowerCAmelCase		,  )



      def 	lowerCAmelCase__    (	self:						Dict		,  _lowerCAmelCase:						str		,  _lowerCAmelCase:						List[str]		,  _lowerCAmelCase:						Any		,  _lowerCAmelCase:						List[Any]		,  _lowerCAmelCase:						Tuple		,  _lowerCAmelCase:						List[str]		,  _lowerCAmelCase:						int       )						->    Any:
         '''simple docstring'''

         UpperCAmelCase_											=FalconModel(config=_lowerCAmelCase       )
         model.to(_lowerCAmelCase       )
         model.eval()
         UpperCAmelCase_											=model(_lowerCAmelCase		,  attention_mask=_lowerCAmelCase       )
         UpperCAmelCase_											=model(_lowerCAmelCase       )
         self.parent.assertEqual(result.last_hidden_state.shape		,  (self.batch_size, self.seq_length, self.hidden_size)       )



      def 	lowerCAmelCase__    (	self:						str		,  _lowerCAmelCase:						Optional[Any]		,  _lowerCAmelCase:						List[str]		,  _lowerCAmelCase:						List[Any]		,  _lowerCAmelCase:						str		,  _lowerCAmelCase:						Optional[Any]		,  _lowerCAmelCase:						Tuple		,  _lowerCAmelCase:						Tuple		,  _lowerCAmelCase:						int		,  _lowerCAmelCase:						Union[str, Any]		,  )						->    List[str]:
         '''simple docstring'''

         UpperCAmelCase_											=True
         UpperCAmelCase_											=FalconModel(_lowerCAmelCase       )
         model.to(_lowerCAmelCase       )
         model.eval()
         UpperCAmelCase_											=model(
             _lowerCAmelCase		,  attention_mask=_lowerCAmelCase		,  encoder_hidden_states=_lowerCAmelCase		,  encoder_attention_mask=_lowerCAmelCase		,  )
         UpperCAmelCase_											=model(
             _lowerCAmelCase		,  attention_mask=_lowerCAmelCase		,  encoder_hidden_states=_lowerCAmelCase		,  )
         UpperCAmelCase_											=model(_lowerCAmelCase		,  attention_mask=_lowerCAmelCase       )
         self.parent.assertEqual(result.last_hidden_state.shape		,  (self.batch_size, self.seq_length, self.hidden_size)       )



      def 	lowerCAmelCase__    (	self:						str		,  _lowerCAmelCase:						Optional[Any]		,  _lowerCAmelCase:						List[str]		,  _lowerCAmelCase:						Tuple		,  _lowerCAmelCase:						Tuple		,  _lowerCAmelCase:						Any		,  _lowerCAmelCase:						List[str]		,  _lowerCAmelCase:						str		,  _lowerCAmelCase:						Dict		,  _lowerCAmelCase:						List[str]		,  )						->    Tuple:
         '''simple docstring'''

         UpperCAmelCase_											=FalconForCausalLM(config=_lowerCAmelCase       )
         model.to(_lowerCAmelCase       )
         model.eval()
         UpperCAmelCase_											=model(_lowerCAmelCase		,  attention_mask=_lowerCAmelCase		,  labels=_lowerCAmelCase       )
         self.parent.assertEqual(result.logits.shape		,  (self.batch_size, self.seq_length, self.vocab_size)       )



      def 	lowerCAmelCase__    (	self:						int		,  _lowerCAmelCase:						List[Any]		,  _lowerCAmelCase:						Dict		,  _lowerCAmelCase:						Optional[Any]		,  _lowerCAmelCase:						List[Any]		,  _lowerCAmelCase:						Dict		,  _lowerCAmelCase:						int		,  _lowerCAmelCase:						str		,  _lowerCAmelCase:						str		,  _lowerCAmelCase:						Optional[int]		,  )						->    Optional[int]:
         '''simple docstring'''

         UpperCAmelCase_											=True
         UpperCAmelCase_											=True
         UpperCAmelCase_											=FalconForCausalLM(config=_lowerCAmelCase       )
         model.to(_lowerCAmelCase       )
         model.eval()

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






      def 	lowerCAmelCase__    (	self:						Tuple       )						->    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       (	__lowercase		,      __lowercase		,      __lowercase		,      unittest.TestCase						):
      _snake_case							     =(
          (
              FalconModel,
              FalconForCausalLM,
              FalconForSequenceClassification,
              FalconForTokenClassification,
              FalconForQuestionAnswering,
          )
          if is_torch_available()
          else ()
      )
      _snake_case							     =(FalconForCausalLM,) if is_torch_available() else ()
      _snake_case							     =(
          {
              '''feature-extraction''': FalconModel,
              '''text-classification''': FalconForSequenceClassification,
              '''text-generation''': FalconForCausalLM,
              '''question-answering''': FalconForQuestionAnswering,
              '''token-classification''': FalconForTokenClassification,
              '''zero-shot''': FalconForSequenceClassification,
          }
          if is_torch_available()
          else {}
      )
      _snake_case							     =False
      _snake_case							     =False



      def 	lowerCAmelCase__    (	self:						Optional[Any]       )						->    Union[str, Any]:
         '''simple docstring'''

         UpperCAmelCase_											=FalconModelTester(self       )
         UpperCAmelCase_											=ConfigTester(self		,  config_class=_lowerCAmelCase		,  hidden_size=37       )



      def 	lowerCAmelCase__    (	self:						Dict       )						->    Union[str, Any]:
         '''simple docstring'''

         self.config_tester.run_common_tests()



      def 	lowerCAmelCase__    (	self:						int       )						->    Optional[int]:
         '''simple docstring'''

         UpperCAmelCase_											=self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*_lowerCAmelCase       )



      def 	lowerCAmelCase__    (	self:						Optional[int]       )						->    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(_lowerCAmelCase		,  *_lowerCAmelCase       )



      def 	lowerCAmelCase__    (	self:						List[Any]       )						->    str:
         '''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(_lowerCAmelCase       )
         UpperCAmelCase_											=ids_tensor([self.model_tester.batch_size]		,  self.model_tester.type_sequence_label_size       )
         UpperCAmelCase_											=FalconForSequenceClassification(_lowerCAmelCase       )
         model.to(_lowerCAmelCase       )
         model.eval()
         UpperCAmelCase_											=model(_lowerCAmelCase		,  attention_mask=_lowerCAmelCase		,  labels=_lowerCAmelCase       )
         self.assertEqual(result.logits.shape		,  (self.model_tester.batch_size, self.model_tester.num_labels)       )



      def 	lowerCAmelCase__    (	self:						Any       )						->    Optional[int]:
         '''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(_lowerCAmelCase       )
         UpperCAmelCase_											=ids_tensor([self.model_tester.batch_size]		,  self.model_tester.type_sequence_label_size       )
         UpperCAmelCase_											=FalconForSequenceClassification(_lowerCAmelCase       )
         model.to(_lowerCAmelCase       )
         model.eval()
         UpperCAmelCase_											=model(_lowerCAmelCase		,  attention_mask=_lowerCAmelCase		,  labels=_lowerCAmelCase       )
         self.assertEqual(result.logits.shape		,  (self.model_tester.batch_size, self.model_tester.num_labels)       )



      def 	lowerCAmelCase__    (	self:						str       )						->    Any:
         '''simple docstring'''

         UpperCAmelCase_						,       UpperCAmelCase_											=self.model_tester.prepare_config_and_inputs_for_common()
         UpperCAmelCase_											=input_dict["input_ids"]
         UpperCAmelCase_											=FalconForCausalLM(_lowerCAmelCase       )
         model.to(_lowerCAmelCase       )
         model.eval()
         UpperCAmelCase_											=model(_lowerCAmelCase		,  use_cache=_lowerCAmelCase       )
         UpperCAmelCase_											=input_ids.shape[0]
         UpperCAmelCase_											=model._convert_to_rw_cache(result.past_key_values       )
         UpperCAmelCase_											=model._convert_cache_to_standard_format(_lowerCAmelCase		,  _lowerCAmelCase       )
         for layer in range(len(_lowerCAmelCase       )       ):
            for tensor_idx in range(2       ):
               self.assertTrue(rw_cache[layer][tensor_idx].ndim == 3       )
               self.assertTrue(result.past_key_values[layer][tensor_idx].ndim == 4       )
               self.assertTrue(
                   torch.all(result.past_key_values[layer][tensor_idx] == standard_cache[layer][tensor_idx]       )       )



      def 	lowerCAmelCase__    (	self:						Any       )						->    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(_lowerCAmelCase       )
         UpperCAmelCase_											=ids_tensor(
             [self.model_tester.batch_size, config.num_labels]		,  self.model_tester.type_sequence_label_size       ).to(torch.float       )
         UpperCAmelCase_											=FalconForSequenceClassification(_lowerCAmelCase       )
         model.to(_lowerCAmelCase       )
         model.eval()
         UpperCAmelCase_											=model(_lowerCAmelCase		,  attention_mask=_lowerCAmelCase		,  labels=_lowerCAmelCase       )
         self.assertEqual(result.logits.shape		,  (self.model_tester.batch_size, self.model_tester.num_labels)       )






      def 	lowerCAmelCase__    (	self:						Tuple       )						->    Tuple:
         '''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(_lowerCAmelCase		,  "use_cache"       ):
               return

            UpperCAmelCase_											=model_class(_lowerCAmelCase       ).to(_lowerCAmelCase       )
            if "use_cache" not in inputs:
               UpperCAmelCase_											=True
            UpperCAmelCase_											=model(**_lowerCAmelCase       )

            # 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(_lowerCAmelCase		,  "decoder_layers"		,  _lowerCAmelCase       )
                or getattr(_lowerCAmelCase		,  "num_decoder_layers"		,  _lowerCAmelCase       )
                or config.num_hidden_layers
            )
            UpperCAmelCase_											=getattr(_lowerCAmelCase		,  "num_kv_heads"		,  config.num_attention_heads       )
            UpperCAmelCase_											=getattr(_lowerCAmelCase		,  "d_model"		,  config.hidden_size       )
            UpperCAmelCase_											=embed_dim // num_attention_heads

            UpperCAmelCase_											=outputs["past_key_values"]
            self.assertEqual(len(_lowerCAmelCase       )		,  _lowerCAmelCase       )

            UpperCAmelCase_						,       UpperCAmelCase_											=inputs["input_ids"].shape
            for i in range(_lowerCAmelCase       ):
               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 	lowerCAmelCase__    (	self:						Optional[Any]       )						->    Dict:
         '''simple docstring'''

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

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

         self.assertEqual(_lowerCAmelCase		,  _lowerCAmelCase       )



      @slow
      def 	lowerCAmelCase__    (	self:						Optional[int]       )						->    Optional[int]:
         '''simple docstring'''

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

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






      @slow
      def 	lowerCAmelCase__    (	self:						Tuple       )						->    Optional[int]:
         '''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(_lowerCAmelCase       )
               UpperCAmelCase_											=FalconForCausalLM.from_pretrained(_lowerCAmelCase       )
               model.eval()
               model.to(device=_lowerCAmelCase       )
               UpperCAmelCase_											=tokenizer("My favorite food is"		,  return_tensors="pt"       ).to(_lowerCAmelCase       )

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











from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__lowercase  :   Any						      ={
    """configuration_upernet""": ["""UperNetConfig"""],
}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     __lowercase  :   Tuple						      =[
         """UperNetForSemanticSegmentation""",
         """UperNetPreTrainedModel""",
     ]


if TYPE_CHECKING:
     from .configuration_upernet import UperNetConfig

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_upernet import UperNetForSemanticSegmentation, UperNetPreTrainedModel


else:
     import sys

     __lowercase  :   Any						      =_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)




